@intlayer/docs 9.0.0-canary.4 → 9.0.0-canary.6

package/docs/it/compat/i18n-js.md

@@ -0,0 +1,44 @@
+---
+createdAt: 2026-06-13
+updatedAt: 2026-06-13
+title: "Migrare da i18n-js a Intlayer"
+description: "Scopri come migrare la tua applicazione da i18n-js a Intlayer utilizzando l'adattatore di compatibilità."
+keywords:
+  - i18n-js
+  - intlayer
+  - migration
+  - compat
+slugs:
+  - doc
+  - compatibility
+  - i18n-js
+history:
+  - version: 9.0.0
+    date: 2026-06-13
+    changes: "Init history"
+author: aymericzip
+---
+
+# Migrare da i18n-js a Intlayer
+
+La transizione dalla libreria `i18n-js` a Intlayer è una migrazione altamente ottimizzata progettata per trasferire grandi configurazioni di traduzioni nel sistema di risoluzione dei file strutturato di Intlayer.
+
+## Cosa fare
+
+Esegui il seguente comando di configurazione nel tuo repository:
+
+```bash
+npx intlayer init
+```
+
+Con `intlayer.config.ts` preparato, puoi aggiungere l'alias di Intlayer alla configurazione del tuo bundler in modo che qualsiasi importazione di `i18n-js` abbia come destinazione il package di compatibilità `@intlayer/i18n-js`.
+
+## Cosa fa sotto il cofano
+
+`i18n-js` accede ai namespace attraverso espressioni come `i18n.t('scope.key', {name})` insieme ai fallback locale e alle mappature plurali specifiche.
+
+Sotto il cofano:
+
+- **Interpolation:** L'adapter di compatibilità analizza facilmente le mappature `%{name}` nel valore del dizionario runtime di destinazione.
+- **Pluralization:** Sostituisce le sottochiavi `one/other` e le mappa rispetto ai potenti meccanismi plurali sottostanti di Intlayer (`Intl.PluralRules`), astraendo le mappature manuali.
+- **Locales:** Invece di caricare payload linguistici monolitici al bootstrap, i dizionari vengono serviti in modo ottimale in base alla configurazione del contesto corrente tramite la configurazione nativa di Intlayer.

package/docs/it/compat/i18next.md

@@ -0,0 +1,59 @@
+---
+createdAt: 2026-06-13
+updatedAt: 2026-06-13
+title: "Migrare da i18next a Intlayer"
+description: "Scopri come migrare la tua applicazione Vanilla JS/TS da i18next a Intlayer utilizzando l'adattatore di compatibilità."
+keywords:
+  - i18next
+  - vanilla
+  - javascript
+  - typescript
+  - intlayer
+  - migration
+  - compat
+slugs:
+  - doc
+  - compatibility
+  - i18next
+history:
+  - version: 9.0.0
+    date: 2026-06-13
+    changes: "Init history"
+author: aymericzip
+---
+
+# Migrazione da i18next a Intlayer
+
+Per un tutorial dettagliato passo-passo, consulta la nostra completa [Guida alla migrazione da i18next](../migration_from_i18next_to_intlayer.md).
+
+Intlayer replica perfettamente le caratteristiche runtime core di `i18next`. Utilizzando il package compat, le tue applicazioni Vanilla o i moduli interni possono continuare a sfruttare la sintassi familiare.
+
+## Cosa fare
+
+Per iniziare, inizializza Intlayer nel tuo progetto:
+
+```bash
+npx intlayer init
+```
+
+Se stai utilizzando Vite, includi il plugin Intlayer per instradare gli import a `@intlayer/i18next`:
+
+```typescript fileName="vite.config.ts"
+import { defineConfig } from "vite";
+import { i18nextVitePlugin } from "@intlayer/i18next/plugin";
+
+export default defineConfig({
+  plugins: [i18nextVitePlugin()],
+});
+```
+
+## Cosa fa sotto il cofano
+
+Il `i18nextVitePlugin` reindirizza gli import `i18next` a `@intlayer/i18next`, evitando l'aumento del bundle dalle inclusioni dei file JSON.
+
+Sotto il cofano:
+
+- **Configurazione dell'istanza:** `createInstance` analizza correttamente e applica i fallback degli namespace sfruttando la pipeline di compilazione di Intlayer per il recupero del dizionario.
+- **Interpolazione:** Supporto nativo per le sostituzioni `{{name}}` e l'annidamento ricorsivo di `$t(key)`.
+- **Contesto e plurali:** Identifica e risolve i formati di suffisso come `key_male` e `key_one`/`key_other` valutandoli rispetto allo standard `Intl.PluralRules`.
+- **Oggetti di ritorno:** La modalità `returnObjects: true` estrae in sicurezza gli alberi dai dizionari di Intlayer.

package/docs/it/compat/index.md

@@ -0,0 +1,51 @@
+---
+createdAt: 2026-06-13
+updatedAt: 2026-06-13
+title: "Intlayer Compat Adapters"
+description: "Migra la tua soluzione i18n esistente a Intlayer senza attriti utilizzando compat adapters."
+keywords:
+  - compat
+  - migration
+  - internationalization
+  - i18n
+  - Intlayer
+slugs:
+  - doc
+  - compatibility
+history:
+  - version: 9.0.0
+    date: 2026-06-13
+    changes: "Init history"
+author: aymericzip
+---
+
+# Adattatori di compatibilità Intlayer
+
+La migrazione di un'applicazione di grandi dimensioni a una nuova libreria di internazionalizzazione può essere impegnativa. Per facilitare questa transizione, Intlayer fornisce **adattatori di compatibilità** per le librerie i18n più popolari dell'ecosistema.
+
+Questi pacchetti adattatore espongono la **stessa API pubblica** delle tue librerie i18n esistenti, ma delegano tutto il lavoro di traduzione a Intlayer a runtime.
+
+## Come funziona
+
+Quando usi un compat adapter, non hai bisogno di riscrivere gli import della tua applicazione o cambiare come utilizzi i tuoi translation hooks e componenti. Invece, i plugin bundler di Intlayer eseguono automaticamente l'alias dei tuoi import esistenti ai package compat di Intlayer.
+
+Ad esempio, uno sviluppatore sostituisce `import { useTranslation } from 'react-i18next'` con `import { useTranslation } from '@intlayer/react-i18next'` (fatto automaticamente dal plugin bundler), e l'app continua a funzionare con le traduzioni ora servite dai dizionari di Intlayer. Le chiavi sono anche tipizzate rispetto ai tuoi dizionari di Intlayer!
+
+## Adattatori Compat Disponibili
+
+Scegli la tua libreria esistente di seguito per vedere come eseguire la migrazione senza problemi:
+
+- [Vue I18n](./vue-i18n.md)
+- [Transloco](./transloco.md)
+- [React Intl](./react-intl.md)
+- [Svelte I18n](./svelte-i18n.md)
+- [React i18next](./react-i18next.md)
+- [Polyglot.js](./polyglot.md)
+- [NuxtJS I18n](./nuxtjs-i18n.md)
+- [NGX Translate](./ngx-translate.md)
+- [Next Translate](./next-translate.md)
+- [Next Intl](./next-intl.md)
+- [Next i18next](./next-i18next.md)
+- [i18next](./i18next.md)
+- [Lingui](./lingui.md)
+- [I18n-js](./i18n-js.md)

package/docs/it/compat/lingui.md

@@ -0,0 +1,44 @@
+---
+createdAt: 2026-06-13
+updatedAt: 2026-06-13
+title: "Migrare da Lingui a Intlayer"
+description: "Scopri come migrare la tua applicazione da Lingui a Intlayer utilizzando l'adattatore di compatibilità."
+keywords:
+  - lingui
+  - intlayer
+  - migration
+  - compat
+slugs:
+  - doc
+  - compatibility
+  - lingui
+history:
+  - version: 9.0.0
+    date: 2026-06-13
+    changes: "Init history"
+author: aymericzip
+---
+
+# Migrazione da Lingui a Intlayer
+
+Se il tuo progetto attualmente si basa sulla compilazione basata su macro di Lingui, il passaggio a Intlayer ti consente di mantenere i tuoi potenti workflow macro supportandoli nativamente con la strategia di compilazione JSON di Intlayer.
+
+## Cosa fare
+
+Per iniziare, inizializza Intlayer nel tuo progetto:
+
+```bash
+npx intlayer init
+```
+
+Questo crea il tuo `intlayer.config.ts`. Assicurati di mantenere `@lingui/babel-plugin-lingui-macro` / `@lingui/swc-plugin` nel tuo build step per eseguire _prima_ del compilatore Intlayer. Quindi, utilizza l'alias del plugin bundler per instradare `@lingui/core` e `@lingui/react` a `@intlayer/lingui`.
+
+## Cosa fa sotto il cofano
+
+Lingui utilizza macro (come `` t`Hello ${name}` `` e `<Trans>`) che vengono compilate in chiamate runtime come `i18n._(id, values)`.
+
+Sotto il cofano:
+
+- **Macro:** Si compilano esattamente come prima, garantendo nessuna interruzione nella sintassi del tuo codice sorgente.
+- **Traduzione runtime:** L'alias `i18n._()` utilizza i dizionari di Intlayer. Sia gli ID esplicitamente denominati che gli ID con hash sono completamente mappati utilizzando i plugin di sincronizzazione `.po` di Intlayer per aggregare e rimuovere le chiavi in modo sicuro.
+- **Funzionalità ICU:** Il supporto per pluralizzazione, selezione e varianti ICU rimane robusto grazie al parser ICU unificato di Intlayer, garantendo output di rendering identici.

package/docs/it/compat/next-i18next.md

@@ -0,0 +1,57 @@
+---
+createdAt: 2026-06-13
+updatedAt: 2026-06-13
+title: "Migrare da next-i18next a Intlayer"
+description: "Scopri come migrare la tua applicazione Next.js da next-i18next a Intlayer utilizzando l'adapter di compatibilità."
+keywords:
+  - next-i18next
+  - nextjs
+  - intlayer
+  - migration
+  - compat
+slugs:
+  - doc
+  - compatibility
+  - next-i18next
+history:
+  - version: 9.0.0
+    date: 2026-06-13
+    changes: "Init history"
+author: aymericzip
+---
+
+# Migra da next-i18next a Intlayer
+
+Per un tutorial completo e dettagliato passo dopo passo, consulta la nostra [Guida alla migrazione da next-i18next](../migration_from_next-i18next_to_intlayer.md).
+
+Intlayer gestisce tutte le implementazioni di Next.js Pages Router e App Router in modo trasparente. Utilizzando l'adapter puoi migrare la tua implementazione `next-i18next` senza riscrivere il codice.
+
+## Cosa fare
+
+Per iniziare, esegui:
+
+```bash
+npx intlayer init
+```
+
+Questo crea il file di configurazione Intlayer necessario. Per integrare Intlayer dietro le quinte, aggiorna il tuo `next.config.ts`:
+
+```typescript fileName="next.config.ts"
+import type { NextConfig } from "next";
+import { createNextI18nPlugin } from "@intlayer/next-i18next/plugin";
+
+const withIntlayer = createNextI18nPlugin();
+
+const nextConfig: NextConfig = {};
+
+export default withIntlayer(nextConfig);
+```
+
+## Come funziona internamente
+
+Il `createNextI18nPlugin` combina il comportamento nativo di Next.js insieme al plugin core `next-intlayer`, iniettando tutti gli alias Webpack/Turbopack richiesti per `next-i18next`, `react-i18next` e `i18next`.
+
+Internamente:
+
+- **`serverSideTranslations` & `appWithTranslation`:** Ora funzionano come wrapper per i loader interni di Intlayer, evitando l'iniezione di grandi JSON statici.
+- **Client hooks:** Delega immediatamente a `@intlayer/react-i18next` mantenendo tutti i formati, i plurali e le funzionalità degli spazi dei nomi annidati.

package/docs/it/compat/next-intl.md

@@ -0,0 +1,59 @@
+---
+createdAt: 2026-06-13
+updatedAt: 2026-06-13
+title: "Migrare da next-intl a Intlayer"
+description: "Scopri come migrare la tua applicazione Next.js da next-intl a Intlayer utilizzando l'adapter di compatibilità."
+keywords:
+  - next-intl
+  - nextjs
+  - intlayer
+  - migration
+  - compat
+slugs:
+  - doc
+  - compatibility
+  - next-intl
+history:
+  - version: 9.0.0
+    date: 2026-06-13
+    changes: "Init history"
+author: aymericzip
+---
+
+# Migrare da next-intl a Intlayer
+
+Per un tutorial completo e dettagliato passo dopo passo, consulta la nostra [Guida alla Migrazione da next-intl](../migration_from_next-intl_to_intlayer.md).
+
+La migrazione da `next-intl` a Intlayer ti consente di mantenere il routing dell'applicazione e la sintassi completamente intatti.
+
+## Cosa fare
+
+Esegui il seguente comando nel tuo repository:
+
+```bash
+npx intlayer init
+```
+
+Questo creerà un file `intlayer.config.ts`. Nel tuo `next.config.ts`, utilizza il wrapper del plugin per iniettare facilmente gli alias `next-intl` verso `@intlayer/next-intl`.
+
+```typescript fileName="next.config.ts"
+import type { NextConfig } from "next";
+import { createNextIntlPlugin } from "@intlayer/next-intl/plugin";
+
+const withIntlayer = createNextIntlPlugin();
+
+const nextConfig: NextConfig = {};
+
+export default withIntlayer(nextConfig);
+```
+
+## Cosa fa sotto il cofano
+
+Il bundler wrapper sostituisce le traduzioni, ma **lascia intatte le funzionalità di `next-intl/navigation`** (ad es. `Link`, `redirect`, `usePathname`).
+
+Sotto il cofano:
+
+- **ICU runtime:** I plurali (`=0`, `one`, `other`), select/selectordinal, gli argomenti `#` e gli argomenti formattati (`{ts, date, long}`) funzionano correttamente utilizzando il resolver condiviso `resolveMessage(..., 'icu')`.
+- **`useTranslations()` & `getTranslations()`:** Le chiamate di scope bare estraggono il primo segmento di chiave come identificatore corretto del dizionario. Gli spazi dei nomi annidati si dividono elegantemente in percorsi di dizionario e prefissi.
+- **Rich formatting:** Sia `t.rich()` che `t.markup()` sono completamente implementati in modo nativo, convertendo i nodi simili a HTML in chunk React renderizzati.
+- **`useFormatter`:** `relativeTime`, `list`, `dateTimeRange` e i formati denominati dalla configurazione si collegano ai formatter `Intl` nativi principali.

package/docs/it/compat/next-translate.md

@@ -0,0 +1,45 @@
+---
+createdAt: 2026-06-13
+updatedAt: 2026-06-13
+title: "Migrare da Next Translate a Intlayer"
+description: "Scopri come migrare la tua applicazione Next.js da next-translate a Intlayer utilizzando l'adapter di compatibilità."
+keywords:
+  - next-translate
+  - nextjs
+  - intlayer
+  - migration
+  - compat
+slugs:
+  - doc
+  - compatibility
+  - next-translate
+history:
+  - version: 9.0.0
+    date: 2026-06-13
+    changes: "Init history"
+author: aymericzip
+---
+
+# Migrare da Next Translate a Intlayer
+
+Migrare da `next-translate` a Intlayer è una sostituzione quasi totale che mantiene la tua sintassi e i tuoi tag esistenti.
+
+## Cosa fare
+
+Inizializza Intlayer nel tuo progetto:
+
+```bash
+npx intlayer init
+```
+
+La CLI scaffolderà la tua configurazione. Puoi quindi applicare il plugin Intlayer nel tuo `next.config.ts`, che inietta alias di sottopercorsi in fase di build mappando `next-translate/useTranslation` a `@intlayer/next-translate`.
+
+## Cosa fa dietro le quinte
+
+`next-translate` fornisce hook come `useTranslation('ns')`, `t('ns:key.path')`, e il componente `<Trans>`.
+
+Dietro le quinte:
+
+- **Interpolazione & Plurali:** Si basa strettamente sul comportamento dell'adapter `react-i18next`. Gestiti dinamicamente sono i placeholder `{{var}}` e la pluralizzazione mappata da suffissi come `key_0`, `key_one`, e `key_other`.
+- **Componente `<Trans>`:** Direttamente supportato per il parsing di tag simili a HTML insieme a un prop `components` basato su array.
+- **Namespaces:** L'aliasing dei subpath assicura che il tuo `useTranslation` faccia riferimento ai namespace dei dizionari interni corretti senza necessità di modifiche manuali.

package/docs/it/compat/ngx-translate.md

@@ -0,0 +1,45 @@
+---
+createdAt: 2026-06-13
+updatedAt: 2026-06-13
+title: "Migrare da NGX-Translate a Intlayer"
+description: "Scopri come migrare la tua applicazione Angular da ngx-translate a Intlayer utilizzando l'adattatore di compatibilità."
+keywords:
+  - ngx-translate
+  - angular
+  - intlayer
+  - migration
+  - compat
+slugs:
+  - doc
+  - compatibility
+  - ngx-translate
+history:
+  - version: 9.0.0
+    date: 2026-06-13
+    changes: "Init history"
+author: aymericzip
+---
+
+# Migrare da NGX-Translate a Intlayer
+
+Migrare la tua applicazione Angular da `ngx-translate` a Intlayer è facile con l'adapter di compatibilità, che ti permette di evitare la necessità di riscrivere tutti i tuoi template.
+
+## Cosa fare
+
+Inizia eseguendo:
+
+```bash
+npx intlayer init
+```
+
+Questo configura `intlayer.config.ts`. Sostituisci le tue configurazioni `TranslateModule.forRoot()` e gli alias di importazione in modo appropriato per puntare a `@intlayer/ngx-translate`.
+
+## Cosa fa sotto il cofano
+
+`ngx-translate` usa `TranslateService` (`instant`, `get`, `stream`) insieme alla pipe `{{ 'KEY' | translate:params }}` e alla direttiva `[translate]`.
+
+Sotto il cofano:
+
+- **Services:** `TranslateService` wraps `getIntlayer` e un locale observable, fornendo esattamente gli stessi metodi.
+- **Pipes & Directives:** Re-implementate per risolvere direttamente contro i dizionari di Intlayer.
+- **Loaders:** I setup di `TranslateHttpLoader` vengono convertiti in warning stubs perché Intlayer risolve e aggrega intrinsecamente i tuoi dizionari al momento della build (o attraverso standard dynamic imports), eliminando completamente la necessità di HTTP loaders.

package/docs/it/compat/nuxtjs-i18n.md

@@ -0,0 +1,46 @@
+---
+createdAt: 2026-06-13
+updatedAt: 2026-06-13
+title: "Migrazione da NuxtJS I18n a Intlayer"
+description: "Scopri come migrare la tua applicazione Nuxt.js da @nuxtjs/i18n a Intlayer utilizzando l'adapter di compatibilità."
+keywords:
+  - nuxtjs-i18n
+  - nuxt
+  - vue
+  - intlayer
+  - migration
+  - compat
+slugs:
+  - doc
+  - compatibility
+  - nuxtjs-i18n
+history:
+  - version: 9.0.0
+    date: 2026-06-13
+    changes: "Init history"
+author: aymericzip
+---
+
+# Migrare da NuxtJS I18n a Intlayer
+
+La migrazione della tua applicazione Nuxt da `@nuxtjs/i18n` a Intlayer è un processo senza soluzione di continuità utilizzando il modulo adattatore Nuxt.
+
+## Cosa fare
+
+Per inizializzare il progetto, esegui:
+
+```bash
+npx intlayer init
+```
+
+Questo configurerà `intlayer.config.ts`. Quindi, aggiungi il modulo Intlayer Nuxt (ad es. `@intlayer/nuxt-i18n`) nell'array dei moduli del tuo `nuxt.config.ts`. Questo applica automaticamente la configurazione di compatibilità per la tua applicazione.
+
+## Cosa fa dietro le quinte
+
+`@nuxtjs/i18n` wraps `vue-i18n` while providing Nuxt-specific routing composables (`useLocalePath`, `useSwitchLocalePath`, `<NuxtLinkLocale>`).
+
+Dietro le quinte:
+
+- **Translations:** Relies natively on the `@intlayer/vue-i18n` compat layer for all string translation tasks (fully supporting `vue-i18n` formats, pipe plurals, and reactivity).
+- **Routing:** Mirrors the routing composables using Intlayer's localized URL helpers.
+- **Configuration:** Reads the `availableLocales` and default settings straight from your `intlayer.config.ts` to coordinate Nuxt pages automatically.

package/docs/it/compat/polyglot.md

@@ -0,0 +1,45 @@
+---
+createdAt: 2026-06-13
+updatedAt: 2026-06-13
+title: "Migrare da Polyglot.js a Intlayer"
+description: "Scopri come migrare da Polyglot.js a Intlayer utilizzando l'adapter di compatibilità."
+keywords:
+  - polyglot
+  - airbnb
+  - intlayer
+  - migration
+  - compat
+slugs:
+  - doc
+  - compatibility
+  - polyglot
+history:
+  - version: 9.0.0
+    date: 2026-06-13
+    changes: "Init history"
+author: aymericzip
+---
+
+# Migrare da Polyglot.js a Intlayer
+
+Se stai usando Polyglot.js di Airbnb, migrare a Intlayer è estremamente semplice usando il livello di compatibilità.
+
+## Cosa fare
+
+Esegui semplicemente il comando di inizializzazione nel tuo progetto:
+
+```bash
+npx intlayer init
+```
+
+Questo genera `intlayer.config.ts`. Puoi quindi utilizzare l'alias del plugin bundler per reindirizzare trasparentemente gli import di Polyglot a `@intlayer/polyglot`.
+
+## Cosa fa dietro le quinte
+
+La sintassi di Polyglot.js si basa tipicamente su `polyglot.t('key', {name})` con interpolazioni `%{name}` e plurali `smart_count` separati da `"singular |||| plural"`.
+
+Dietro le quinte:
+
+- **Interpolazione:** Il layer di compatibilità gestisce nativamente i placeholder `%{var}`.
+- **Plurali:** La stringa viene divisa a `||||` e valutata rispetto a `Intl.PluralRules` nativo secondo la locale attiva, rispecchiando l'ordine dei bucket di Polyglot per locale.
+- **Dizionari:** Eviti la necessità di fornire configurazioni JSON enormi a `new Polyglot()` – Intlayer gestisce i dizionari dinamicamente e li ripulisce automaticamente.

package/docs/it/compat/react-i18next.md

@@ -0,0 +1,58 @@
+---
+createdAt: 2026-06-13
+updatedAt: 2026-06-13
+title: "Migrare da react-i18next a Intlayer"
+description: "Scopri come migrare la tua applicazione React da react-i18next a Intlayer utilizzando l'adapter di compatibilità."
+keywords:
+  - react-i18next
+  - i18next
+  - intlayer
+  - migration
+  - compat
+slugs:
+  - doc
+  - compatibility
+  - react-i18next
+history:
+  - version: 9.0.0
+    date: 2026-06-13
+    changes: "Init history"
+author: aymericzip
+---
+
+# Migrare da react-i18next a Intlayer
+
+Per un tutorial completo e dettagliato passo dopo passo, consulta la nostra [Guida alla migrazione da react-i18next](../migration_from_react-i18next_to_intlayer.md).
+
+Utilizzando l'adapter di compatibilità di Intlayer puoi migrare da `react-i18next` senza apportare alcuna modifica agli import del tuo codice sorgente.
+
+## Cosa fare
+
+Per inizializzare il progetto, esegui:
+
+```bash
+npx intlayer init
+```
+
+Durante l'inizializzazione, Intlayer installerà `@intlayer/react-i18next` e creerà `intlayer.config.ts`. Nel tuo bundler (come Vite), applica il plugin Intlayer:
+
+```typescript fileName="vite.config.ts"
+import { defineConfig } from "vite";
+import react from "@vitejs/plugin-react";
+import { reactI18nextVitePlugin } from "@intlayer/react-i18next/plugin";
+
+export default defineConfig({
+  plugins: [react(), reactI18nextVitePlugin()],
+});
+```
+
+## Cosa fa sotto il cofano
+
+Il `reactI18nextVitePlugin` avvolge il plugin core `vite-intlayer` e inietta alias di resolve per `react-i18next` e `i18next`, reindirizzandoli a `@intlayer/react-i18next` e `@intlayer/i18next`.
+
+Sotto il cofano:
+
+- **`useTranslation` & `withTranslation`:** Riscritti per utilizzare gli hook nativi di Intlayer, fornendoti il completamento automatico di TypeScript per le tue chiavi di dizionario. Supporta senza problemi i namespace (ad es. `t('namespace:key')`).
+- **Plurali & Contesto:** Gestisce la pluralizzazione basata su suffissi di i18next (`key_one`, `key_other`) utilizzando `Intl.PluralRules` nativo e suffissi di contesto (`key_male`).
+- **Componente `<Trans>`:** Re-implementato per supportare il prop `components`, forme oggetto e array, e tag numerati `<1>...</1>` che mappano direttamente ai tuoi nodi React.
+- **Istanza `i18n`:** Risolve le chiavi direttamente da Intlayer senza recuperare grandi file JSON, risultando in dimensioni di bundle significativamente inferiori.

package/docs/it/compat/react-intl.md

@@ -0,0 +1,55 @@
+---
+createdAt: 2026-06-13
+updatedAt: 2026-06-13
+title: "Migrare da React Intl a Intlayer"
+description: "Scopri come migrare la tua applicazione React da react-intl a Intlayer utilizzando l'adapter di compatibilità."
+keywords:
+  - react-intl
+  - formatjs
+  - intlayer
+  - migration
+  - compat
+slugs:
+  - doc
+  - compatibility
+  - react-intl
+history:
+  - version: 9.0.0
+    date: 2026-06-13
+    changes: "Init history"
+author: aymericzip
+---
+
+# Migra da React Intl a Intlayer
+
+Se la tua applicazione React utilizza `react-intl` (FormatJS), la transizione a Intlayer è semplicissima. Il nostro compat layer gestisce facilmente ICU MessageFormat e tutti i componenti `Formatted*` esistenti.
+
+## Cosa fare
+
+Inizia eseguendo il comando di inizializzazione nel tuo progetto:
+
+```bash
+npx intlayer init
+```
+
+Quindi, configura il plugin Intlayer Vite o Next.js nella tua configurazione. Questo plugin inietta alias in fase di build per reindirizzare gli import di `react-intl` a `@intlayer/react-intl`.
+
+```typescript fileName="vite.config.ts"
+import { defineConfig } from "vite";
+import react from "@vitejs/plugin-react";
+import reactIntlVitePlugin from "@intlayer/react-intl/plugin";
+
+export default defineConfig({
+  plugins: [react(), reactIntlVitePlugin()],
+});
+```
+
+## Cosa fa sotto il cofano
+
+Il plugin bundler crea un alias di `react-intl` a `@intlayer/react-intl`. Invece di analizzare manualmente file JSON di grandi dimensioni e avvolgere la tua app in un `IntlProvider`, il plugin Intlayer estrae staticamente le chiavi e utilizza i dizionari Intlayer a runtime.
+
+Sotto il cofano:
+
+- **ICU MessageFormat:** Intlayer utilizza il resolver `resolveMessage(..., 'icu')` che supporta completamente la pluralizzazione ICU, la selezione, la formattazione di data/numero e i tag di testo ricco nativamente.
+- **Method & JSX callers:** `intl.formatMessage({ id: 'a.b' })` e `<FormattedMessage id="a.b">` sono identificati dai plugin compilatore Intlayer (`@intlayer/babel` / `@intlayer/swc`), convertendo le chiavi puntate piatte in modo che il primo segmento si risolva correttamente nella chiave del dizionario Intlayer.
+- **Formatters:** `<FormattedNumber>`, `<FormattedDate>`, ecc., si collegano ai `core/formatters` nativi utilizzando `Intl`.

package/docs/it/compat/svelte-i18n.md

@@ -0,0 +1,47 @@
+---
+createdAt: 2026-06-13
+updatedAt: 2026-06-13
+title: "Migrare da Svelte I18n a Intlayer"
+description: "Scopri come migrare la tua applicazione Svelte da svelte-i18n a Intlayer utilizzando l'adapter di compatibilità."
+keywords:
+  - svelte-i18n
+  - svelte
+  - intlayer
+  - migration
+  - compat
+slugs:
+  - doc
+  - compatibility
+  - svelte-i18n
+history:
+  - version: 9.0.0
+    date: 2026-06-13
+    changes: "Init history"
+author: aymericzip
+---
+
+# Migrare da Svelte I18n a Intlayer
+
+Migrare la tua applicazione Svelte da `svelte-i18n` a Intlayer richiede solo un momento utilizzando l'adapter di compatibilità.
+
+## Cosa fare
+
+Esegui semplicemente il comando di inizializzazione nel tuo progetto:
+
+```bash
+npx intlayer init
+```
+
+Questo genera `intlayer.config.ts`. Assicurati che i tuoi plugin SvelteKit / Vite siano avvolti con il plugin alias di Intlayer per mappare senza problemi `svelte-i18n` a `@intlayer/svelte-i18n`.
+
+## Cosa fa sotto il cofano
+
+Svelte-i18n si basa su store (`$_`, `$t`, `$format`, ecc.) ampiamente utilizzati e su ICU MessageFormat.
+
+Sotto il cofano:
+
+- **Store:** Intlayer proxies i store `svelte-i18n`. `$_` diventa uno store derivato della locale corrente che restituisce un resolver Intlayer.
+- **Chiavi:** Le tue chiavi flat (ad es. `$_('home.title')`) vengono valutate in modo che il primo segmento del percorso rappresenti il dizionario Intlayer.
+- **Sintassi ICU:** Completamente gestita dal resolver ICU condiviso (analisi equivalente di `intl-messageformat`).
+- **Formatter:** Le chiamate `$date`, `$time`, `$number` reindirizzano in sicurezza ai formatter core nativi di Intlayer.
+- **Analisi Babel/SWC:** L'analizzatore Intlayer legge i chiamanti dello store Svelte (`$_`) all'interno dei tuoi file sorgente `.svelte` prima della compilazione per costruire automaticamente i chunk di dizionario rilevanti.