@intlayer/docs 8.12.4 → 9.0.0-canary.10

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.

package/docs/it/compat/transloco.md

@@ -0,0 +1,45 @@
+---
+createdAt: 2026-06-13
+updatedAt: 2026-06-13
+title: "Migrare da Transloco a Intlayer"
+description: "Scopri come migrare la tua applicazione Angular da Transloco a Intlayer utilizzando l'adattatore di compatibilità."
+keywords:
+  - transloco
+  - angular
+  - intlayer
+  - migration
+  - compat
+slugs:
+  - doc
+  - compatibility
+  - transloco
+history:
+  - version: 9.0.0
+    date: 2026-06-13
+    changes: "Init history"
+author: aymericzip
+---
+
+# Migrare da Transloco a Intlayer
+
+Se la tua applicazione Angular utilizza attualmente `@jsverse/transloco`, puoi migrare a Intlayer utilizzando il nostro compat adapter. Questa transizione ti consente di mantenere la sintassi del template esistente mentre sfrutti la potente struttura del dizionario di Intlayer.
+
+## Cosa fare
+
+Esegui semplicemente il comando di inizializzazione nel tuo progetto:
+
+```bash
+npx intlayer init
+```
+
+Questo genererà la configurazione necessaria `intlayer.config.ts`. Potrai quindi sostituire i tuoi import Transloco con i moduli `@intlayer/transloco` o affidarti agli alias di build.
+
+## Come funziona sotto il cofano
+
+Transloco utilizza scopes e un `TranslocoService` (`translate`, `selectTranslate`), insieme a direttive strutturali (`*transloco="let t"`) e pipe (`| transloco`).
+
+Sotto il cofano:
+
+- **Scopes:** Mappano naturalmente alle chiavi del dizionario Intlayer, fornendo un'ottima strategia di pruning per l'ottimizzazione del bundle.
+- **Service & Directives:** L'adattatore Angular di Intlayer sostituisce facilmente i provider, permettendo alle tue pipe di template e alle direttive esistenti di risolvere le stringhe rispetto ai dizionari Intlayer.
+- **Build time parsing:** L'analizzatore TypeScript riconosce le chiamate `instant/get`, e il fallback pruning garantisce la correttezza anche quando l'utilizzo del template non è staticamente tracciabile.

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

@@ -0,0 +1,58 @@
+---
+createdAt: 2026-06-13
+updatedAt: 2026-06-13
+title: "Migrare da Vue I18n a Intlayer"
+description: "Scopri come migrare la tua applicazione Vue da vue-i18n a Intlayer utilizzando l'adapter di compatibilità."
+keywords:
+  - vue-i18n
+  - vue
+  - intlayer
+  - migration
+  - compat
+slugs:
+  - doc
+  - compatibility
+  - vue-i18n
+history:
+  - version: 9.0.0
+    date: 2026-06-13
+    changes: "Init history"
+author: aymericzip
+---
+
+# Migrare da Vue I18n a Intlayer
+
+Se la tua applicazione Vue attualmente utilizza `vue-i18n`, puoi migrare a Intlayer senza riscrivere i tuoi componenti o tradurre gli hook. Intlayer fornisce un adattatore di compatibilità che rispecchia perfettamente l'API di `vue-i18n` mentre sfrutta le potenti funzionalità di Intlayer dietro le quinte.
+
+## Cosa fare
+
+Per iniziare, esegui semplicemente il comando di inizializzazione nel tuo progetto:
+
+```bash
+npx intlayer init
+```
+
+Durante l'inizializzazione, Intlayer configura il file di configurazione (`intlayer.config.ts`) e prepara il tuo progetto per la migrazione. Dovrai solo aggiungere il plugin Intlayer alla tua configurazione Vite per creare automaticamente alias per gli import `vue-i18n`.
+
+```typescript fileName="vite.config.ts"
+import { defineConfig } from "vite";
+import vue from "@vitejs/plugin-vue";
+import vueI18nVitePlugin from "@intlayer/vue-i18n/plugin";
+
+export default defineConfig({
+  plugins: [vue(), vueI18nVitePlugin()],
+});
+```
+
+## Cosa fa sotto il cofano
+
+Il `vueI18nVitePlugin` inietta un alias di modulo nel tuo bundler. Qualsiasi import di `vue-i18n` nel tuo codebase verrà reindirizzato in modo trasparente a `@intlayer/vue-i18n`.
+
+**Sotto il cofano, l'adapter gestisce nativamente la complessa sintassi di `vue-i18n`:**
+
+- **Interpolazione e plurali:** Risolve le interpolazioni `{name}` e di lista `{0}`. I plurali con pipe (`"car | cars"`) vengono convertiti in nodi di enumerazione/plurale di Intlayer basati sulla semantica posizionale.
+- **Formati:** Funzioni come `d()` e `n()` avvolgono `Intl` sotto il cofano, rispettando i `datetimeFormats` e `numberFormats` definiti nelle tue opzioni.
+- **Stato globale e locale:** `global.locale` è mappato a un `WritableComputedRef` supportato dal client Intlayer, quindi la reattività si comporta esattamente come previsto (ad esempio `locale.value = 'fr'`).
+- **Direttive:** La direttiva `v-t` è registrata e funziona normalmente.
+
+La tua applicazione continua a renderizzarsi esattamente come prima, ma il contenuto è alimentato dai tuoi dizionari Intlayer, offrendoti type safety, una migliore ottimizzazione del bundle e un'integrazione CMS senza interruzioni.

package/docs/it/compiler.md

@@ -1,6 +1,6 @@
 ---
 createdAt: 2025-09-09
-updatedAt: 2026-03-12
+updatedAt: 2026-06-23
 title: Compiler Intlayer | Estrazione automatica dei contenuti per i18n
 description: Automatizza il tuo processo di internazionalizzazione con il compilatore Intlayer. Estrai contenuti direttamente dai tuoi componenti per un i18n più veloce ed efficiente in Vite, Next.js e altro.
 keywords:
@@ -29,6 +29,7 @@ history:
   - version: 7.3.1
     date: 2025-11-27
     changes: "Rilascio Compiler"
+author: aymericzip
 ---
 
 # Intlayer Compiler | Estrazione Automatica dei Contenuti per i18n
@@ -59,6 +60,8 @@ Come alternativa, per automatizzare il tuo processo i18n mantenendo il pieno con
 
 ## Utilizzo
 
+> The quickest way to wire the compiler in is the interactive setup: run `npx intlayer init --interactive` and select **Compiler**. On Vite there is nothing to configure — the compiler is plugged in directly through the `intlayerCompiler()` plugin. On Next.js the command scaffolds the `babel.config.js` shown below. The non-interactive `intlayer init` leaves the compiler setup untouched.
+
 <Tabs>
  <Tab value='vite'>
 
@@ -78,12 +81,15 @@ Aggiorna il tuo `vite.config.ts` per includere il plugin `intlayerCompiler`:
 
 ```ts fileName="vite.config.ts"
 import { defineConfig } from "vite";
-import { intlayer, intlayerCompiler } from "vite-intlayer";
+import { intlayer } from "vite-intlayer";
 
 export default defineConfig({
   plugins: [
-    intlayer(),
-    intlayerCompiler(), // Aggiunge il plugin del compiler
+    intlayer({
+      proxy: {
+        ignore: (req) => req.url?.startsWith("/api"),
+      },
+    }),
   ],
 });
 ```

package/docs/it/component_i18n.md

@@ -16,6 +16,7 @@ slugs:
   - i18n
 applicationTemplate: https://github.com/aymericzip/intlayer-vite-react-template
 youtubeVideo: https://www.youtube.com/watch?v=dS9L7uJeak4
+author: aymericzip
 ---
 
 # Come rendere un componente multilingue (i18n) con Intlayer

package/docs/it/configuration.md

@@ -1,6 +1,6 @@
 ---
 createdAt: 2024-08-13
-updatedAt: 2026-05-12
+updatedAt: 2026-06-23
 title: Configurazione
 description: Scopri come configurare Intlayer per la tua applicazione. Comprendi le diverse impostazioni e opzioni disponibili per personalizzare Intlayer secondo le tue necessità.
 keywords:
@@ -14,6 +14,12 @@ slugs:
   - concept
   - configuration
 history:
+  - version: 9.0.0
+    date: 2026-06-24
+    changes: "Add `enableProxy` option to the routing configuration"
+  - version: 8.10.0
+    date: 2026-06-17
+    changes: "Aggiunta l'opzione `format` alla configurazione del dizionario"
   - version: 8.9.4
     date: 2026-05-12
     changes: "Aggiunto il supporto per il provider LM Studio"
@@ -98,6 +104,7 @@ history:
   - version: 5.5.11
     date: 2025-06-29
     changes: "Aggiunti i comandi `docs`"
+author: aymericzip
 ---
 
 # Documentazione della configurazione di Intlayer
@@ -134,6 +141,7 @@ Intlayer accetta formati di file di configurazione JSON, JS, MJS e TS:
 ````typescript fileName="intlayer.config.ts" codeFormat="typescript"
 import { Locales, type IntlayerConfig } from "intlayer";
 import { nextjsRewrite } from "intlayer/routing";
+import { syncJSON } from "@intlayer/sync-json-plugin";
 import { z } from "zod";
 
 /**
@@ -584,10 +592,38 @@ const config: IntlayerConfig = {
     }),
   },
 
+  /**
+   * Configurazione del dizionario.
+   */
+  dictionary: {
+    /**
+     * Controlla come vengono importati i dizionari.
+     * - "static": Importato staticamente in fase di compilazione.
+     * - "dynamic": Importato dinamicamente usando Suspense.
+     * - "fetch": Recuperato dinamicamente tramite API di sincronizzazione live.
+     */
+    importMode: "static",
+
+    /**
+     * Il formato del messaggio predefinito per tutti i dizionari nel progetto.
+     * - 'intlayer': Formato intlayer nativo (predefinito).
+     * - 'icu': Formato del messaggio ICU.
+     * - 'i18next': Formato i18next.
+     * - 'vue-i18n': Formato Vue I18n.
+     * - 'po': Formato GNU Gettext PO.
+     */
+    format: "icu",
+  },
+
   /**
    * Configurazione dei plugin.
    */
-  plugins: [],
+  plugins: [
+    syncJSON({
+      format: "icu",
+      source: ({ locale }) => `./messages/${locale}.json`,
+    }),
+  ],
 };
 
 export default config;
@@ -852,24 +888,40 @@ Impostazioni per come i contenuti sono gestiti nell'applicazione, inclusi i nomi
 
 ---
 
+### Configurazione del Sistema
+
+Impostazioni relative ai percorsi interni e ai risultati dell'output di Intlayer. Queste impostazioni sono tipicamente interne e non dovrebbero aver bisogno di essere modificate dall'utente.
+
+| Field                     | Description                                                                                                 | Type     | Default                           | Example              | Note                                                              |
+| ------------------------- | ----------------------------------------------------------------------------------------------------------- | -------- | --------------------------------- | -------------------- | ----------------------------------------------------------------- |
+| `baseDir`                 | La directory di base per il progetto.                                                                       | `string` | `process.cwd()`                   | `'/path/to/project'` | Utilizzato per risolvere tutte le directory correlate a Intlayer. |
+| `dictionariesDir`         | Il percorso della directory per archiviare i dizionari di localizzazione.                                   | `string` | `'.intlayer/dictionary'`          |                      |                                                                   |
+| `moduleAugmentationDir`   | Directory per l'augmentazione dei moduli, che consente migliori suggerimenti dell'IDE e controllo dei tipi. | `string` | `'.intlayer/types'`               | `'intlayer-types'`   | Assicurati di includerlo in `tsconfig.json`.                      |
+| `unmergedDictionariesDir` | La directory per l'archiviazione dei dizionari non uniti.                                                   | `string` | `'.intlayer/unmerged_dictionary'` |                      |                                                                   |
+| `typesDir`                | La directory per l'archiviazione dei tipi di dizionario.                                                    | `string` | `'.intlayer/types'`               |                      |                                                                   |
+| `mainDir`                 | La directory in cui vengono archiviati i file dell'applicazione principale.                                 | `string` | `'.intlayer/main'`                |                      |                                                                   |
+| `configDir`               | La directory in cui vengono archiviati i file di configurazione.                                            | `string` | `'.intlayer/config'`              |                      |                                                                   |
+| `cacheDir`                | La directory in cui vengono archiviati i file della cache.                                                  | `string` | `'.intlayer/cache'`               |                      |                                                                   |
+
 ### Configurazione Dizionario (Dictionary)
 
 Parametri che controllano le operazioni del dizionario, inclusi i comportamenti di auto-compilazione e la generazione dei contenuti.
 
-| Campo                       | Descrizione                                                                                                                                                               | Tipo                                                                                                            | Predefinito | Esempio                                                                                     | Commenti                                                                                                                                                                                                                                                                                                                                                                                                                        |
-| --------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------- | ----------- | ------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `fill`                      | Controlla come vengono generati i file di output della compilazione automatica (traduzione IA).                                                                           | `boolean` &#124; <br/> `FilePathPattern` &#124; <br/> `Partial<Record<Locale, boolean &#124; FilePathPattern>>` | `true`      | `{ en: '/locales/en/{{key}}.json', fr: ({ key }) => '/locales/fr/${key}.json', es: false }` | • `true`: Percorso predefinito (stesso file della sorgente).<br/>• `false`: Disabilita.<br/>• Stringa template/Funzione abilita la generazione per locale.<br/>• Oggetto per locale: Ogni locale corrisponde al proprio template; `false` esclude quel locale.<br/>• L'inclusione di `{{locale}}` abilita la generazione per locale.<br/>• `fill` a livello di dizionario ha sempre la priorità su questa impostazione globale. |
-| `description`               | Aiuta l'editor e il CMS a comprendere lo scopo del dizionario. Utilizzato anche come contesto per generare traduzioni tramite IA.                                         | `string`                                                                                                        | `undefined` | `'User profile section'`                                                                    |                                                                                                                                                                                                                                                                                                                                                                                                                                 |
-| `locale`                    | Trasforma il dizionario in un formato per un locale specifico. Ogni campo dichiarato diventa un nodo di traduzione. Se mancante, il dizionario è considerato multilingue. | `LocalesValues`                                                                                                 | `undefined` | `'en'`                                                                                      | Usalo se il dizionario è per un locale specifico invece di contenere più traduzioni.                                                                                                                                                                                                                                                                                                                                            |
-| `contentAutoTransformation` | Se trasformare automaticamente le stringhe di contenuto in nodi tipizzati (Markdown, HTML o inserimenti).                                                                 | `boolean` &#124; <br/> `{ markdown?: boolean; html?: boolean; insertion?: boolean }`                            | `false`     | `true`                                                                                      | • Markdown : `### Title` → `md('### Title')`.<br/>• HTML : `<div>Title</div>` → `html('<div>Title</div>')`.<br/>• Inserimento : `Hello {{name}}` → `insert('Hello {{name}}')`.                                                                                                                                                                                                                                                  |
-| `location`                  | Indica dove sono memorizzati i file del dizionario e come sono sincronizzati con il CMS.                                                                                  | `'local'` &#124; <br/> `'remote'` &#124; <br/> `'hybrid'` &#124; <br/> `'plugin'` &#124; <br/> `string`         | `'local'`   | `'hybrid'`                                                                                  | • `'local'`: Solo gestione locale.<br/>• `'remote'`: Solo gestione remota (CMS).<br/>• `'hybrid'`: Sia gestione locale che remota.<br/>• `'plugin'` o stringa personalizzata: Gestione tramite plugin o sorgente personalizzata.                                                                                                                                                                                                |
-| `importMode`                | Controlla come vengono importati i dizionari.                                                                                                                             | `'static'` &#124; <br/> `'dynamic'` &#124; <br/> `'fetch'`                                                      | `'static'`  | `'dynamic'`                                                                                 | • `'static'`: Importazione statica.<br/>• `'dynamic'`: Importazione dinamica tramite Suspense.<br/>• `'fetch'`: Recupero tramite l'API Live Sync; fallback a `'dynamic'` in caso di fallimento.<br/>• Richiede i plugin `@intlayer/babel` e `@intlayer/swc`.<br/>• Le chiavi devono essere dichiarate staticamente.<br/>• Ignorato se `optimize` è disattivato.<br/>• Non influisce su `getIntlayer`, `getDictionary`, ecc.     |
-| `priority`                  | Priorità del dizionario. Quando si risolvono i conflitti tra i dizionari, i valori più alti vincono su quelli più bassi.                                                  | `number`                                                                                                        | `undefined` | `1`                                                                                         |                                                                                                                                                                                                                                                                                                                                                                                                                                 |
-| `live`                      | DEPRECATO - usa `importMode: 'fetch'`. Indica se il contenuto del dizionario debba essere recuperato dinamicamente tramite l'API Live Sycn.                               | `boolean`                                                                                                       | `undefined` |                                                                                             | Rinominato in `importMode: 'fetch'` in v8.0.0.                                                                                                                                                                                                                                                                                                                                                                                  |
-| `schema`                    | Generato automaticamente da Intlayer per la convalida dello schema JSON.                                                                                                  | `'https://intlayer.org/schema.json'`                                                                            | Auto-gen    |                                                                                             | Non modificare manualmente.                                                                                                                                                                                                                                                                                                                                                                                                     |
-| `title`                     | Aiuta a identificare i dizionari nell'editor e nel CMS.                                                                                                                   | `string`                                                                                                        | `undefined` | `'User Profile'`                                                                            |                                                                                                                                                                                                                                                                                                                                                                                                                                 |
-| `tags`                      | Categorizza i dizionari e fornisce contesto o istruzioni per l'editor e l'IA.                                                                                             | `string[]`                                                                                                      | `undefined` | `['user', 'profile']`                                                                       |                                                                                                                                                                                                                                                                                                                                                                                                                                 |
-| `version`                   | Versione del dizionario remoto; aiuta a tracciare quale versione è attualmente utilizzata.                                                                                | `string`                                                                                                        | `undefined` | `'1.0.0'`                                                                                   | • Gestito nel CMS.<br/>• Non modificare localmente.                                                                                                                                                                                                                                                                                                                                                                             |
+| Campo                       | Descrizione                                                                                                                                                               | Tipo                                                                                                            | Predefinito  | Esempio                                                                                     | Commenti                                                                                                                                                                                                                                                                                                                                                                                                                        |
+| --------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------- | ------------ | ------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `fill`                      | Controlla come vengono generati i file di output della compilazione automatica (traduzione IA).                                                                           | `boolean` &#124; <br/> `FilePathPattern` &#124; <br/> `Partial<Record<Locale, boolean &#124; FilePathPattern>>` | `true`       | `{ en: '/locales/en/{{key}}.json', fr: ({ key }) => '/locales/fr/${key}.json', es: false }` | • `true`: Percorso predefinito (stesso file della sorgente).<br/>• `false`: Disabilita.<br/>• Stringa template/Funzione abilita la generazione per locale.<br/>• Oggetto per locale: Ogni locale corrisponde al proprio template; `false` esclude quel locale.<br/>• L'inclusione di `{{locale}}` abilita la generazione per locale.<br/>• `fill` a livello di dizionario ha sempre la priorità su questa impostazione globale. |
+| `description`               | Aiuta l'editor e il CMS a comprendere lo scopo del dizionario. Utilizzato anche come contesto per generare traduzioni tramite IA.                                         | `string`                                                                                                        | `undefined`  | `'User profile section'`                                                                    |                                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| `locale`                    | Trasforma il dizionario in un formato per un locale specifico. Ogni campo dichiarato diventa un nodo di traduzione. Se mancante, il dizionario è considerato multilingue. | `LocalesValues`                                                                                                 | `undefined`  | `'en'`                                                                                      | Usalo se il dizionario è per un locale specifico invece di contenere più traduzioni.                                                                                                                                                                                                                                                                                                                                            |
+| `contentAutoTransformation` | Se trasformare automaticamente le stringhe di contenuto in nodi tipizzati (Markdown, HTML o inserimenti).                                                                 | `boolean` &#124; <br/> `{ markdown?: boolean; html?: boolean; insertion?: boolean }`                            | `false`      | `true`                                                                                      | • Markdown : `### Title` → `md('### Title')`.<br/>• HTML : `<div>Title</div>` → `html('<div>Title</div>')`.<br/>• Inserimento : `Hello {{name}}` → `insert('Hello {{name}}')`.                                                                                                                                                                                                                                                  |
+| `location`                  | Indica dove sono memorizzati i file del dizionario e come sono sincronizzati con il CMS.                                                                                  | `'local'` &#124; <br/> `'remote'` &#124; <br/> `'hybrid'` &#124; <br/> `'plugin'` &#124; <br/> `string`         | `'local'`    | `'hybrid'`                                                                                  | • `'local'`: Solo gestione locale.<br/>• `'remote'`: Solo gestione remota (CMS).<br/>• `'hybrid'`: Sia gestione locale che remota.<br/>• `'plugin'` o stringa personalizzata: Gestione tramite plugin o sorgente personalizzata.                                                                                                                                                                                                |
+| `importMode`                | Controlla come vengono importati i dizionari.                                                                                                                             | `'static'` &#124; <br/> `'dynamic'` &#124; <br/> `'fetch'`                                                      | `'static'`   | `'dynamic'`                                                                                 | • `'static'`: Importazione statica.<br/>• `'dynamic'`: Importazione dinamica tramite Suspense.<br/>• `'fetch'`: Recupero tramite l'API Live Sync; fallback a `'dynamic'` in caso di fallimento.<br/>• Richiede i plugin `@intlayer/babel` e `@intlayer/swc`.<br/>• Le chiavi devono essere dichiarate staticamente.<br/>• Ignorato se `optimize` è disattivato.<br/>• Non influisce su `getIntlayer`, `getDictionary`, ecc.     |
+| `format`                    | Il formato del messaggio predefinito per tutti i dizionari nel progetto.                                                                                                  | `'intlayer'` &#124; <br/> `'icu'` &#124; <br/> `'i18next'` &#124; <br/> `'vue-i18n'` &#124; <br/> `'po'`        | `'intlayer'` | `'icu'`                                                                                     | • `'intlayer'`: Formato intlayer nativo.<br/>• `'icu'`: Formato del messaggio ICU.<br/>• `'i18next'`: Formato i18next.<br/>• `'vue-i18n'`: Formato Vue I18n.<br/>• `'po'`: Formato GNU Gettext PO.                                                                                                                                                                                                                              |
+| `priority`                  | Priorità del dizionario. Quando si risolvono i conflitti tra i dizionari, i valori più alti vincono su quelli più bassi.                                                  | `number`                                                                                                        | `undefined`  | `1`                                                                                         |                                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| `live`                      | DEPRECATO - usa `importMode: 'fetch'`. Indica se il contenuto del dizionario debba essere recuperato dinamicamente tramite l'API Live Sycn.                               | `boolean`                                                                                                       | `undefined`  |                                                                                             | Rinominato in `importMode: 'fetch'` in v8.0.0.                                                                                                                                                                                                                                                                                                                                                                                  |
+| `schema`                    | Generato automaticamente da Intlayer per la convalida dello schema JSON.                                                                                                  | `'https://intlayer.org/schema.json'`                                                                            | Auto-gen     |                                                                                             | Non modificare manualmente.                                                                                                                                                                                                                                                                                                                                                                                                     |
+| `title`                     | Aiuta a identificare i dizionari nell'editor e nel CMS.                                                                                                                   | `string`                                                                                                        | `undefined`  | `'User Profile'`                                                                            |                                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| `tags`                      | Categorizza i dizionari e fornisce contesto o istruzioni per l'editor e l'IA.                                                                                             | `string[]`                                                                                                      | `undefined`  | `['user', 'profile']`                                                                       |                                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| `version`                   | Versione del dizionario remoto; aiuta a tracciare quale versione è attualmente utilizzata.                                                                                | `string`                                                                                                        | `undefined`  | `'1.0.0'`                                                                                   | • Gestito nel CMS.<br/>• Non modificare localmente.                                                                                                                                                                                                                                                                                                                                                                             |
 
 **Esempio di `fill`**:
 
@@ -959,22 +1011,6 @@ Le opzioni di build sono applicate ai plugin `@intlayer/babel` e `@intlayer/swc`
 
 ---
 
-### Configurazione di Sistema (System)
-
-Queste impostazioni sono per utenti esperti e per la configurazione interna di Intlayer.
-
-| Campo                     | Descrizione                                       | Tipo     | Predefinito                       | Esempio | Commenti |
-| ------------------------- | ------------------------------------------------- | -------- | --------------------------------- | ------- | -------- |
-| `dictionariesDir`         | Directory per i dizionari compilati.              | `string` | `'.intlayer/dictionary'`          |         |          |
-| `moduleAugmentationDir`   | Directory per l'aumento del modulo TypeScript.    | `string` | `'.intlayer/types'`               |         |          |
-| `unmergedDictionariesDir` | Directory per memorizzare i dizionari non fusi.   | `string` | `'.intlayer/unmerged_dictionary'` |         |          |
-| `typesDir`                | Directory per i tipi generati.                    | `string` | `'.intlayer/types'`               |         |          |
-| `mainDir`                 | Directory per i file principali di Intlayer.      | `string` | `'.intlayer/main'`                |         |          |
-| `configDir`               | Directory per i file di configurazione compilati. | `string` | `'.intlayer/config'`              |         |          |
-| `cacheDir`                | Directory per i file di cache.                    | `string` | `'.intlayer/cache'`               |         |          |
-
----
-
 ### Configurazione Compilatore (Compiler)
 
 Impostazioni che controllano il compilatore Intlayer, che raccoglie i dizionari direttamente dai tuoi componenti.

package/docs/it/custom_domains.md

@@ -1,6 +1,6 @@
 ---
 createdAt: 2026-04-02
-updatedAt: 2026-04-02
+updatedAt: 2026-06-23
 title: Domini personalizzati
 description: Impara come configurare il routing delle locale basato su dominio in Intlayer per servire diverse locale da hostname dedicati.
 keywords:
@@ -17,6 +17,7 @@ history:
   - version: 8.5.0
     date: 2026-04-02
     changes: "Aggiunta del routing delle locale basato su dominio tramite la configurazione routing.domains."
+author: aymericzip
 ---
 
 # Domini personalizzati
@@ -171,10 +172,16 @@ Il plugin Vite `intlayerProxy` applica la stessa logica durante lo sviluppo:
 
 ```typescript fileName="vite.config.ts"
 import { defineConfig } from "vite";
-import { intlayerProxy } from "vite-intlayer";
+import { intlayer } from "vite-intlayer";
 
 export default defineConfig({
-  plugins: [intlayerProxy()],
+  plugins: [
+    intlayer({
+      proxy: {
+        ignore: (req) => req.url?.startsWith("/api"),
+      },
+    }),
+  ],
 });
 ```
 

package/docs/it/custom_url_rewrites.md

@@ -1,6 +1,6 @@
 ---
 createdAt: 2024-08-13
-updatedAt: 2026-01-26
+updatedAt: 2026-06-23
 title: Riscritture URL personalizzate
 description: Scopri come configurare e utilizzare le riscritture URL personalizzate in Intlayer per definire percorsi specifici per lingua.
 keywords:
@@ -16,6 +16,7 @@ history:
   - version: 8.0.0
     date: 2026-01-25
     changes: "Implementazione di riscritture URL centralizzate con formatter specifici per framework e l'hook useRewriteURL."
+author: aymericzip
 ---
 
 # Implementazione delle riscritture URL personalizzate
@@ -341,10 +342,16 @@ Per SolidJS, Vue e Svelte, il plugin Vite `intlayerProxy` gestisce le riscrittur
 
 ```typescript fileName="vite.config.ts"
 import { defineConfig } from "vite";
-import { intlayerProxy } from "vite-intlayer";
+import { intlayer } from "vite-intlayer";
 
 export default defineConfig({
-  plugins: [intlayerProxy()],
+  plugins: [
+    intlayer({
+      proxy: {
+        ignore: (req) => req.url?.startsWith("/api"),
+      },
+    }),
+  ],
 });
 ```