home / skills / fusengine / agents / react-i18n

react-i18n skill

/plugins/react-expert/skills/react-i18n

This skill enables React apps to implement i18n with react-i18next using TypeScript Selector API and Suspense integration for scalable translations.

npx playbooks add skill fusengine/agents --skill react-i18n

Review the files below or copy the command above to add this skill to your agents.

Files (22)
SKILL.md
5.5 KB
---
name: react-i18n
description: react-i18next for React 19 - useTranslation hook, TypeScript Selector API, namespaces, pluralization, lazy loading, Suspense integration. Use when implementing translations in React apps (not Next.js).
version: 1.0.0
user-invocable: true
references: references/i18next-basics.md, references/typescript-types.md, references/namespaces.md, references/pluralization.md, references/interpolation.md, references/lazy-loading.md, references/language-detection.md, references/react-19-integration.md, references/trans-component.md, references/testing.md, references/rtl-support.md, references/fallback-strategies.md, references/templates/basic-setup.md, references/templates/language-switcher.md, references/templates/typed-translations.md, references/templates/form-validation-i18n.md, references/templates/lazy-loading-routes.md, references/templates/date-number-formatter.md, references/templates/plural-interpolation.md, references/templates/trans-component-examples.md, references/templates/testing-i18n.md
---

# react-i18next for React 19

## Agent Workflow (MANDATORY)

Before ANY implementation, use `TeamCreate` to spawn 3 agents:

1. **fuse-ai-pilot:explore-codebase** - Analyze existing i18n setup and translation patterns
2. **fuse-ai-pilot:research-expert** - Verify latest react-i18next/i18next docs via Context7/Exa
3. **mcp__context7__query-docs** - Check TypeScript Selector API and React 19 Suspense patterns

After implementation, run **fuse-ai-pilot:sniper** for validation.

---

## MANDATORY: SOLID Principles

**ALWAYS apply SOLID principles from `solid-react` skill.**

→ See `../solid-react/SKILL.md` for complete rules

**Key Rules:**
- Files < 100 lines (split at 90)
- Interfaces in `modules/[feature]/src/interfaces/`
- JSDoc mandatory on all exports
- No business logic in components

---

## Core Hooks

| Hook | Purpose | Guide |
|------|---------|-------|
| `useTranslation()` | Access translations and i18n instance | `references/i18next-basics.md` |
| `useTranslation(ns)` | Load specific namespace | `references/namespaces.md` |
| `useTranslation([ns])` | Load multiple namespaces | `references/namespaces.md` |

→ See `references/i18next-basics.md` for detailed usage

---

## Key Packages

| Package | Purpose | Size |
|---------|---------|------|
| `i18next` | Core library | ~40KB |
| `react-i18next` | React bindings | ~12KB |
| `i18next-http-backend` | Lazy loading | ~5KB |
| `i18next-browser-languagedetector` | Auto-detection | ~8KB |

---

## Key Features

### TypeScript Selector API (i18next ≥25.4)
Type-safe translations with autocompletion.
→ See `references/typescript-types.md`

### Namespaces
Organize translations by feature for code splitting.
→ See `references/namespaces.md`

### Pluralization
Count-based rules with ICU MessageFormat support.
→ See `references/pluralization.md`

### Interpolation
Variables, dates, numbers, and currency formatting.
→ See `references/interpolation.md`

### Lazy Loading
Load translations on-demand per route.
→ See `references/lazy-loading.md`

### Language Detection
Auto-detect from browser, URL, cookie, localStorage.
→ See `references/language-detection.md`

### React 19 Integration
Suspense, useTransition, Concurrent Rendering.
→ See `references/react-19-integration.md`

### Trans Component
JSX elements inside translations.
→ See `references/trans-component.md`

### Testing
Mock i18n for unit tests.
→ See `references/testing.md`

### RTL Support
Right-to-left languages (Arabic, Hebrew).
→ See `references/rtl-support.md`

### Fallback Strategies
Handle missing keys gracefully.
→ See `references/fallback-strategies.md`

---

## Templates

| Template | Use Case |
|----------|----------|
| `templates/basic-setup.md` | Configuration with React 19 |
| `templates/language-switcher.md` | Dropdown component |
| `templates/typed-translations.md` | TypeScript Selector API |
| `templates/form-validation-i18n.md` | Translated form errors |
| `templates/lazy-loading-routes.md` | Per-route loading |
| `templates/date-number-formatter.md` | Intl formatting |
| `templates/plural-interpolation.md` | Count-based messages |
| `templates/trans-component-examples.md` | JSX in translations |
| `templates/testing-i18n.md` | Unit test setup |

---

## Modular Architecture (SOLID)

```text
src/
├── modules/cores/i18n/
│   ├── src/
│   │   ├── interfaces/
│   │   │   └── i18n.interface.ts
│   │   ├── services/
│   │   │   └── i18n.service.ts
│   │   ├── hooks/
│   │   │   └── useLanguage.ts
│   │   └── config/
│   │       └── i18n.config.ts
│   ├── components/
│   │   └── LanguageSwitcher.tsx
│   └── locales/
│       ├── en/
│       │   └── translation.json
│       └── fr/
│           └── translation.json
└── main.tsx
```

---

## Best Practices

1. **Suspense**: Wrap app with `<Suspense>` for loading states
2. **Namespaces**: One namespace per feature/module
3. **TypeScript**: Use Selector API for type-safe keys
4. **Lazy Loading**: Load namespaces on-demand
5. **Detection**: Configure language detection order
6. **Fallback**: Always set `fallbackLng`

---

## Forbidden (Anti-Patterns)

- ❌ Hardcoded strings → use `t('key')`
- ❌ No Suspense → causes loading flicker
- ❌ All translations in one file → use namespaces
- ❌ No fallback language → broken UI
- ❌ String concatenation → use interpolation `{{var}}`
- ❌ Manual language state → use `i18n.changeLanguage()`

Overview

This skill provides a ready-to-use react-i18next integration tailored for React 19 and TypeScript. It equips projects with the useTranslation hook, the TypeScript Selector API, namespaces, pluralization, lazy loading, and Suspense-friendly patterns for concurrent rendering. Use it to implement robust, type-safe translations in React apps (not Next.js).

How this skill works

The skill sets up a modular i18n core with services, hooks, and config files that initialize i18next, register backends and detectors, and expose typed selectors. It uses react-i18next hooks (useTranslation) and the i18next Selector API to provide autocomplete and compile-time safety. Namespaces are loaded lazily per feature or route, and the app is wrapped with Suspense for smooth loading states.

When to use it

  • Implement translations in a React 19 application (non-Next.js).
  • Need type-safe translation keys and autocompletion with TypeScript.
  • Want per-feature code-splitting of translation files (namespaces).
  • Require lazy loading of locales and Suspense integration for concurrent rendering.
  • Support pluralization, interpolation, and RTL languages.

Best practices

  • Follow SOLID: small files (<100 lines), interfaces in modules/*/src/interfaces/, and no business logic in components.
  • Wrap the app in Suspense and provide a concise loading UI for namespace fetches.
  • Organize translations by namespace per feature to enable lazy loading and simpler maintenance.
  • Use the TypeScript Selector API to enforce type safety and avoid runtime key errors.
  • Configure language detection order and always set fallbackLng to prevent broken UI.

Example use cases

  • Feature module with its own namespace and lazy-loaded translations for route-based code splitting.
  • Typed translation calls in forms and validation messages using the Selector API for autocompletion.
  • Language switcher component using i18n.changeLanguage() and persisted detection (cookie/localStorage).
  • Pluralized messages and ICU formatting for counts, currency, and dates in checkout flows.
  • Unit tests that mock i18n to assert translated UI output without loading backends.

FAQ

Is this suitable for Next.js projects?

No. This skill targets React 19 apps and React client patterns; Next.js requires different SSR-aware setup.

How do I avoid translation flicker on load?

Wrap the app or route trees with Suspense and lazy-load namespaces; ensure fallbackLng is set and provide a small loading component.