@intlayer/docs 8.12.5-canary.0 → 9.0.0-canary.3

package/docs/it/plugins/sync-json.md

@@ -1,6 +1,6 @@
 ---
 createdAt: 2025-03-13
-updatedAt: 2025-12-13
+updatedAt: 2026-06-21
 title: Plugin Sync JSON
 description: Sincronizza i dizionari Intlayer con file JSON i18n di terze parti (i18next, next-intl, react-intl, vue-i18n e altri). Mantieni il tuo i18n esistente mentre usi Intlayer per gestire, tradurre e testare i tuoi messaggi.
 keywords:
@@ -24,6 +24,9 @@ slugs:
   - sync-json
 youtubeVideo: https://www.youtube.com/watch?v=MpGMxniDHNg
 history:
+  - version: 9.0.0
+    date: 2026-06-21
+    changes: "Aggiunta l'opzione splitKeys (un dizionario per chiave namespace di primo livello) per layout a file singolo di next-intl / react-intl"
   - version: 7.5.0
     date: 2025-12-13
     changes: "Aggiunto supporto per i formati ICU e i18next"
@@ -62,7 +65,63 @@ pnpm add -D @intlayer/sync-json-plugin
 npm i -D @intlayer/sync-json-plugin
 ```
 
-## Avvio rapido
+## Plugins
+
+Questo pacchetto fornisce due plugin:
+
+- `loadJSON`: Carica file JSON nei dizionari Intlayer.
+  - Questo plugin viene utilizzato per caricare file JSON da una sorgente e verrà caricato nei dizionari Intlayer. Può scansionare l'intera codebase e cercare file JSON specifici.
+    Questo plugin può essere utilizzato
+    - se utilizzi una libreria i18n che impone una posizione specifica per il caricamento dei tuoi JSON (es: `next-intl`, `i18next`, `react-intl`, `vue-i18n`, ecc.), ma vuoi posizionare la dichiarazione del tuo contenuto dove vuoi nella tua codebase.
+    - Può anche essere utilizzato se vuoi recuperare i tuoi messaggi da una sorgente remota (es: un CMS, un'API, ecc.) e memorizzare i tuoi messaggi in file JSON.
+
+  > Sotto il cofano, questo plugin scansionerà l'intera codebase e cercherà file JSON specifici e li caricherà nei dizionari Intlayer.
+  > Nota che questo plugin non scriverà l'output e le traduzioni nei file JSON.
+
+- `syncJSON`: Sincronizza i file JSON con i dizionari Intlayer.
+  - Questo plugin viene utilizzato per sincronizzare i file JSON con i dizionari Intlayer. Può scansionare la posizione data e caricare i JSON che corrispondono al pattern per file JSON specifici. Questo plugin è utile se vuoi ottenere i benefici di Intlayer mentre usi un'altra libreria i18n.
+
+## Usare entrambi i plugin
+
+```ts fileName="intlayer.config.ts"
+import { Locales, type IntlayerConfig } from "intlayer";
+import { loadJSON, syncJSON } from "@intlayer/sync-json-plugin";
+
+const config: IntlayerConfig = {
+  internationalization: {
+    locales: [Locales.ENGLISH, Locales.FRENCH, Locales.SPANISH],
+    defaultLocale: Locales.ENGLISH,
+  },
+
+  // Mantieni i tuoi file JSON attuali sincronizzati con i dizionari Intlayer
+  plugins: [
+    /**
+     * Caricherà tutti i file JSON in src che corrispondono al pattern {key}.i18n json
+     */
+    loadJSON({
+      source: ({ key }) => `./src/**/${key}.i18n.json`,
+      locale: Locales.ENGLISH,
+      priority: 1, // Assicura che questi file JSON abbiano la precedenza sui file in `./locales/en/${key}.json`
+      format: "intlayer", // Formato del contenuto JSON
+    }),
+    /**
+     * Caricherà e scriverà l'output e le traduzioni nei file JSON nella directory locales
+     */
+    syncJSON({
+      format: "i18next",
+      source: ({ key, locale }) => `./locales/${locale}/${key}.json`,
+      priority: 0,
+      format: "i18next",
+    }),
+  ],
+};
+
+export default config;
+```
+
+## `syncJSON` plugin
+
+### Avvio rapido
 
 Aggiungi il plugin al tuo `intlayer.config.ts` e indirizzalo alla tua struttura JSON esistente.
 
@@ -81,6 +140,7 @@ const config: IntlayerConfig = {
     syncJSON({
       // Layout per locale, per namespace (es. next-intl, i18next con namespaces)
       source: ({ key, locale }) => `./locales/${locale}/${key}.json`,
+      format: "icu",
     }),
   ],
 };
@@ -91,14 +151,27 @@ export default config;
 Alternativa: file singolo per locale (comune con configurazioni i18next/react-intl):
 
 ```ts fileName="intlayer.config.ts"
-plugins: [
-  syncJSON({
-    source: ({ locale }) => `./locales/${locale}.json`,
-  }),
-];
+import { Locales, type IntlayerConfig } from "intlayer";
+import { syncJSON } from "@intlayer/sync-json-plugin";
+
+const config: IntlayerConfig = {
+  internationalization: {
+    locales: [Locales.ENGLISH, Locales.FRENCH],
+    defaultLocale: Locales.ENGLISH,
+  },
+  plugins: [
+    syncJSON({
+      format: "i18next",
+      source: ({ locale }) => `./locales/${locale}.json`,
+      format: "i18next",
+    }),
+  ],
+};
+
+export default config;
 ```
 
-### Come funziona
+#### Come funziona
 
 - Lettura: il plugin individua i file JSON dal tuo builder `source` e li carica come dizionari Intlayer.
 - Scrittura: dopo le build e i riempimenti, scrive i JSON localizzati negli stessi percorsi (con una newline finale per evitare problemi di formattazione).
@@ -112,6 +185,7 @@ syncJSON({
   location?: string, // etichetta opzionale, predefinito: "plugin"
   priority?: number, // priorità opzionale per la risoluzione dei conflitti, predefinito: 0
   format?: 'intlayer' | 'icu' | 'i18next', // formattatore opzionale, usato per la compatibilità con il runtime Intlayer
+  splitKeys?: boolean, // opzionale, divide un singolo file in un dizionario per chiave di primo livello (rilevamento automatico)
 });
 ```
 
@@ -136,17 +210,49 @@ syncJSON({
 }),
 ```
 
-## Più sorgenti JSON e priorità
+#### `splitKeys` (boolean)
+
+Controlla se un singolo file JSON le cui **chiavi di primo livello sono namespace** debba diventare un dizionario per ogni chiave di primo livello, invece di un singolo dizionario che contiene l'intero file.
+
+Questo corrisponde al modello di namespace di librerie come `next-intl` e `react-intl`, dove un file `messages/{locale}.json` raggruppa diversi namespace tramite le sue chiavi di primo livello, ciascuna indirizzata indipendentemente (ad esempio `useTranslations('Hero')` si risolve nel dizionario `Hero`).
+
+- `undefined` (predefinito): **rilevamento automatico** — il file viene diviso quando il pattern `source` non ha un segmento `{key}` (un file contiene ogni namespace), e mantenuto come un singolo dizionario altrimenti (un file per chiave).
+- `true`: divide sempre ogni chiave di primo livello nel proprio dizionario.
+- `false`: non divide mai; l'intero file diventa un singolo dizionario.
+
+Dato un singolo file `messages/{locale}.json`:
+
+```json fileName="messages/en.json"
+{
+  "Hero": { "title": "Full-stack developer" },
+  "Nav": { "work": "Work", "about": "About" },
+  "About": { "lead": "I build apps end to end." }
+}
+```
+
+```ts fileName="intlayer.config.ts"
+syncJSON({
+  format: "icu",
+  source: ({ locale }) => `./messages/${locale}.json`,
+  // splitKeys: true, // implicito perché il pattern non ha un segmento `{key}`
+}),
+```
+
+Questo produce tre dizionari — `Hero`, `Nav` e `About` — quindi `useTranslations('Hero')` (next-intl) si risolve correttamente. Durante la riscrittura, tutti i namespace vengono riassemblati nello stesso file per locale.
+
+> Quando mantieni il segmento `{key}` esplicito nel tuo `source` (ad esempio `./locales/${locale}/${key}.json`), ogni file è già un namespace, quindi la divisione è disabilitata per impostazione predefinita.
+
+### Multiple JSON sources and priority
 
 Puoi aggiungere più plugin `syncJSON` per sincronizzare diverse sorgenti JSON. Questo è utile quando hai più librerie i18n o diverse strutture JSON nel tuo progetto.
 
-### Sistema di priorità
+#### Sistema di priorità
 
 Quando più plugin puntano alla stessa chiave del dizionario, il parametro `priority` determina quale plugin ha la precedenza:
 
 - I numeri di priorità più alti prevalgono su quelli più bassi
 - La priorità predefinita dei file `.content` è `0`
-- La priorità predefinita dei file di contenuto dei plugin è `-1`
+- La priorità predefinita dei plugin è `0`
 - I plugin con la stessa priorità vengono elaborati nell'ordine in cui appaiono nella configurazione
 
 ```ts fileName="intlayer.config.ts"
@@ -189,73 +295,140 @@ const config: IntlayerConfig = {
 export default config;
 ```
 
-### Risoluzione dei conflitti
+## Load JSON plugin
 
-Quando la stessa chiave di traduzione esiste in più sorgenti JSON:
+### Quick start
 
-1. Il plugin con la priorità più alta determina il valore finale
-2. Le sorgenti con priorità inferiore vengono usate come fallback per le chiavi mancanti
-3. Questo permette di mantenere le traduzioni legacy mentre si migra gradualmente verso nuove strutture
+Aggiungi il plugin al tuo `intlayer.config.ts` per importare i file JSON esistenti come dizionari Intlayer. Questo plugin è di sola lettura (nessuna scrittura su disco):
 
-## Integrazioni
+```ts fileName="intlayer.config.ts"
+import { Locales, type IntlayerConfig } from "intlayer";
+import { loadJSON } from "@intlayer/sync-json-plugin";
 
-Di seguito sono riportate le mappature comuni. Mantieni il tuo runtime intatto; aggiungi solo il plugin.
+const config: IntlayerConfig = {
+  internationalization: {
+    locales: [Locales.ENGLISH, Locales.FRENCH, Locales.SPANISH],
+    defaultLocale: Locales.ENGLISH,
+  },
+
+  plugins: [
+    // Ingerisci messaggi JSON situati ovunque nel tuo albero sorgente
+    loadJSON({
+      source: ({ key }) => `./src/**/${key}.i18n.json`,
+      // Carica una singola locale per istanza del plugin (predefinito alla defaultLocale della configurazione)
+      locale: Locales.ENGLISH,
+      priority: 0,
+    }),
+  ],
+};
 
-### i18next
+export default config;
+```
 
-Layout tipico dei file: `./public/locales/{locale}/{namespace}.json` o `./locales/{locale}/{namespace}.json`.
+Alternativa: layout per locale, ancora di sola lettura (viene caricata solo la locale selezionata):
 
 ```ts fileName="intlayer.config.ts"
-import { syncJSON } from "@intlayer/sync-json-plugin";
+import { Locales, type IntlayerConfig } from "intlayer";
+import { loadJSON } from "@intlayer/sync-json-plugin";
 
-export default {
+const config: IntlayerConfig = {
+  internationalization: {
+    locales: [Locales.ENGLISH, Locales.FRENCH],
+    defaultLocale: Locales.ENGLISH,
+  },
   plugins: [
-    syncJSON({
-      format: "i18next",
+    loadJSON({
+      // Solo i file per Locales.FRENCH verranno caricati da questo pattern
       source: ({ key, locale }) => `./locales/${locale}/${key}.json`,
+      locale: Locales.FRENCH,
     }),
   ],
 };
+
+export default config;
 ```
 
-### next-intl
+### How it works
 
-Messaggi JSON per locale (spesso `./messages/{locale}.json`) o per namespace.
+- Scopri: costruisce un glob dal tuo builder `source` e raccoglie i file JSON corrispondenti.
+- Ingerisci: carica ogni file JSON come dizionario Intlayer con la `locale` fornita.
+- Sola lettura: non scrive né formatta i file di output; usa `syncJSON` se hai bisogno di una sincronizzazione bidirezionale.
+- Pronto per l'auto-fill: definisce un pattern `fill` in modo che `intlayer content fill` possa popolare le chiavi mancanti.
 
-```ts fileName="intlayer.config.ts"
-plugins: [
-  syncJSON({
-    source: ({ locale, key }) => `./messages/${locale}/${key}.json`,
-  }),
-];
+### API
+
+```ts
+loadJSON({
+  // Costruisci i percorsi ai tuoi JSON. `locale` è opzionale se la tua struttura non ha un segmento locale
+  source: ({ key, locale }) => string,
+
+  // Locale di destinazione per i dizionari caricati da questa istanza del plugin
+  // Predefinito a configuration.internationalization.defaultLocale
+  locale?: Locale,
+
+  // Etichetta opzionale per identificare la sorgente
+  location?: string, // predefinito: "plugin"
+
+  // Priorità utilizzata per la risoluzione dei conflitti contro altre sorgenti
+  priority?: number, // predefinito: 0
+
+  // Formattatore opzionale per il contenuto JSON
+  format?: 'intlayer' | 'icu' | 'i18next', // predefinito: 'intlayer'
+
+  // Divide un singolo file in un dizionario per chiave di primo livello (rilevamento automatico)
+  splitKeys?: boolean,
+});
 ```
 
-Vedi anche: `docs/it/intlayer_with_next-intl.md`.
+#### `format` ('intlayer' | 'icu' | 'i18next')
 
-### react-intl
+Specifica il formattatore da utilizzare per il contenuto del dizionario durante il caricamento dei file JSON. Ciò consente di utilizzare diverse sintassi di formattazione dei messaggi compatibili con varie librerie i18n.
 
-È comune un singolo JSON per locale:
+- `'intlayer'`: Il formattatore Intlayer predefinito (predefinito).
+- `'icu'`: Utilizza la formattazione dei messaggi ICU (compatibile con librerie come react-intl, vue-i18n).
+- `'i18next'`: Utilizza la formattazione dei messaggi i18next (compatibile con i18next, next-i18next, Solid-i18next).
 
-```ts fileName="intlayer.config.ts"
-plugins: [
-  syncJSON({
-    source: ({ locale }) => `./locales/${locale}.json`,
-  }),
-];
+**Esempio:**
+
+```ts
+loadJSON({
+  source: ({ key }) => `./src/**/${key}.i18n.json`,
+  locale: Locales.ENGLISH,
+  format: "icu", // Usa la formattazione ICU per la compatibilità
+}),
 ```
 
-### vue-i18n
+#### `splitKeys` (boolean)
 
-Può essere un singolo file per locale o per namespace:
+Stesso comportamento di [`syncJSON`](#splitkeys-boolean): quando un singolo file JSON raggruppa diversi namespace tramite le sue chiavi di primo livello, ogni chiave di primo livello diventa il proprio dizionario.
 
-```ts fileName="intlayer.config.ts"
-plugins: [
-  syncJSON({
-    source: ({ key, locale }) => `./src/locales/${locale}/${key}.json`,
-  }),
-];
+- `undefined` (predefinito): **rilevamento automatico** — divide quando il pattern `source` non ha un segmento `{key}`, singolo dizionario altrimenti.
+- `true` / `false`: forza o disabilita la divisione.
+
+```ts
+loadJSON({
+  source: ({ locale }) => `./messages/${locale}.json`,
+  format: "icu",
+  // splitKeys auto-enabled: `Hero`, `Nav`, `About`, … ciascuno diventa un dizionario
+}),
 ```
 
+### Behavior and conventions
+
+- Se la tua maschera `source` include un segnaposto per la locale, vengono ingeriti solo i file per la `locale` selezionata.
+- Se non c'è un segmento `{key}` nella tua maschera, ogni chiave di primo livello del file diventa il proprio dizionario per impostazione predefinita (vedi [`splitKeys`](#splitkeys-boolean)). Imposta `splitKeys: false` per caricare invece l'intero file come un singolo dizionario `index`.
+- Le chiavi sono derivate dai percorsi dei file sostituendo il segnaposto `{key}` nel tuo builder `source`.
+- Il plugin utilizza solo i file scoperti e non fabbrica locali o chiavi mancanti.
+- Il percorso `fill` è inferito dal tuo `source` e utilizzato per aggiornare i valori mancanti tramite CLI quando scegli di farlo.
+
+## Conflict resolution
+
+Quando la stessa chiave di traduzione esiste in più sorgenti JSON:
+
+1. Il plugin con la priorità più alta determina il valore finale
+2. Le sorgenti con priorità inferiore vengono usate come fallback per le chiavi mancanti
+3. Questo permette di mantenere le traduzioni legacy mentre si migra gradualmente verso nuove strutture
+
 ## CLI
 
 I file JSON sincronizzati saranno considerati come altri file `.content`. Ciò significa che tutti i comandi di intlayer saranno disponibili per i file JSON sincronizzati. Inclusi:
@@ -268,13 +441,13 @@ I file JSON sincronizzati saranno considerati come altri file `.content`. Ciò s
 
 Vedi [Intlayer CLI](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/cli/index.md) per maggiori dettagli.
 
-## Limitazioni (attuali)
+## Limitations (current)
 
 - Nessun supporto per inserimenti o plurali/ICU quando si utilizzano librerie di terze parti.
 - L'editor visuale non è ancora disponibile per runtime non Intlayer.
 - Sincronizzazione solo di file JSON; i formati di catalogo non JSON non sono supportati.
 
-## Perché è importante
+## Why this matters
 
 - Possiamo raccomandare soluzioni i18n consolidate e posizionare Intlayer come un componente aggiuntivo.
 - Sfruttiamo la loro SEO/parole chiave con tutorial che terminano suggerendo Intlayer per gestire JSON.

package/docs/it/releases/v8.md

@@ -1,6 +1,6 @@
 ---
 createdAt: 2025-09-22
-updatedAt: 2026-01-26
+updatedAt: 2026-06-14
 title: Nuovo Intlayer v8 - Novità
 description: Scopri le novità di Intlayer v8. Miglioramenti significativi nella Developer Experience, nella validazione dei contenuti e nella gestione dei dizionari.
 keywords:
@@ -409,6 +409,16 @@ Per maggiori dettagli, consulta la [Documentazione dei contenuti HTML](https://g
 
 ---
 
+## File di contenuto YAML e Markdown (v8.10.0)
+
+Ora puoi dichiarare i contenuti direttamente utilizzando le estensioni di file `.content.md` e `.content.yaml`. Questo è perfetto per contenuti di lunga forma, blog, documentazione e politiche sulla privacy.
+
+Questi file sono completamente modificabili dall'Editor Visuale, fornendo un flusso di lavoro semplificato per i membri del team non tecnici.
+
+Per maggiori dettagli, consulta la [Documentazione sui file di contenuto YAML](https://intlayer.org/doc/concept/content#yaml-content-file) e la [Documentazione sui file di contenuto Markdown](https://intlayer.org/doc/concept/content/markdown).
+
+---
+
 ## Riscritture URL personalizzate
 
 Intlayer v8 introduce il supporto per le **Riscritture URL personalizzate**, che ti permettono di definire percorsi specifici per ogni locale che differiscono dalla struttura standard `/locale/path`. Questa è una funzionalità potente per migliorare la SEO locale e offrire un'esperienza utente più naturale per i parlanti non inglesi.
@@ -753,6 +763,70 @@ export default {
   </Tab>
 </Tabs>
 
+---
+
+## Regole di Pluralizzazione Unicode CLDR (v8.8.0)
+
+È stato introdotto un nuovo helper per nodi `plural` basato sulle regole di pluralizzazione definite dal Progetto Unicode CLDR, migliorando il supporto per le lingue complesse.
+
+```typescript fileName="src/openings.content.ts"
+import { plural, t, type Dictionary } from "intlayer";
+
+const openingsContent = {
+  key: "total_openings",
+  content: {
+    totalOpenings: t({
+      en: plural({
+        one: "{{count}} opening",
+        other: "{{count}} openings",
+      }),
+      fr: plural({
+        one: "{{count}} offre",
+        other: "{{count}} offres",
+      }),
+      it: plural({
+        // Added Italian translation
+        one: "{{count}} offerta",
+        other: "{{count}} offerte",
+      }),
+    }),
+  },
+} satisfies Dictionary;
+
+export default openingsContent;
+```
+
+Puoi quindi passare il conteggio dinamicamente nel componente del tuo framework:
+
+```tsx
+import type { FC } from "react";
+import { useIntlayer } from "react-intlayer";
+
+const OpeningsComponent: FC<{ count: number }> = ({ count }) => {
+  const { totalOpenings } = useIntlayer("total_openings");
+
+  return (
+    <div>
+      {/* In English:                                  */}
+      {/*  count=0  → "0 openings"   (other)           */}
+      {/*  count=1  → "1 opening"    (one)             */}
+      {/*  count=2  → "2 openings"   (other)           */}
+      {/*  count=21 → "21 openings"  (other)           */}
+      {/* In Italian:                                  */}
+      {/*  count=0  → "0 offerte"    (other)           */}
+      {/*  count=1  → "1 offerta"    (one)             */}
+      {/*  count=2  → "2 offerte"    (other)           */}
+      {/*  count=21 → "21 offerte"   (other)           */}
+      <p>{totalOpenings(count)}</p>
+    </div>
+  );
+};
+```
+
+Per maggiori informazioni, consulta la [Documentazione sulla Pluralizzazione](https://intlayer.org/doc/concept/content/plural).
+
+---
+
 ## Validazione dello schema di contenuto
 
 Intlayer v8 introduce la validazione degli schemi per i dizionari. Ora puoi definire schemi di validazione riutilizzabili nella tua configurazione utilizzando Zod e applicarli ai tuoi file di contenuto. Questo garantisce che i tuoi contenuti rispettino sempre la struttura prevista, intercettando gli errori in fase di build.
@@ -797,9 +871,37 @@ Se il contenuto non corrisponde allo schema (ad esempio, il titolo è troppo cor
 
 ---
 
+## TypeScript: Accessori Primitivi IntlayerNode
+
+Il tipo `IntlayerNode` è stato aggiornato per consentire di chiamare metodi JavaScript primitivi direttamente sui nodi di contenuto. Questo rende possibile interagire con il tuo contenuto localizzato direttamente come se fosse una stringa, un numero, un booleano o un array primitivo standard.
+
+Supportato su React, Preact, Solid, Svelte, Vue e Angular.
+
+### Esempio Stringa
+
+```typescript
+content.placeholder; // Restituisce IntlayerNode<string>
+content.placeholder.value; // Restituisce stringa
+content.placeholder.toString(); // Restituisce stringa
+content.placeholder.toLowerCase(); // Restituisce stringa
+String(content.placeholder); // Restituisce stringa
+content.placeholder.toUpperCase(); // Restituisce stringa in maiuscolo
+content.placeholder.replace("a", "b"); // Restituisce stringa modificata
+```
+
+### Esempio Array
+
+```typescript
+content.myArrayOfString             // Restituisce IntlayerNode<Array<string>>
+content.myArrayOfString.find(...)   // Restituisce elemento
+content.myArrayOfString.join(', ')  // Restituisce stringa unita
+```
+
+---
+
 ### Rilevamento automatico del contenuto potenziato
 
-Nella v8, Intlayer rileva in modo intelligente la sintassi Markdown, i tag HTML e le inserzioni di variabili nelle stringhe di contenuto. Questo significa che spesso puoi omettere funzioni helper come `md()`, `html()` o `insert()`.
+Nella v8, Intlayer rileva in modo intelligente la sintassi Markdown, i tag HTML e le inserzioni di variabili nelle stringhe di contenuto. Questo significa che spesso puoi omettere funzioni helper come `md()`, `html()`, o `insert()`.
 
 Questo comportamento è abilitato per impostazione predefinita. Ora puoi perfezionare questo rilevamento globalmente nel tuo `intlayer.config.ts` o per singolo dizionario.
 
@@ -1002,6 +1104,17 @@ L'estensione Intlayer per VSCode riceve aggiornamenti importanti nella v8 per se
 
 ---
 
+## Tooling: C++ Watcher & LSP basato su OXC (v8.12.0)
+
+Intlayer v8.12.0 apporta importanti miglioramenti alla developer experience:
+
+- **Parcel Watcher**: Il watcher dei contenuti è stato migrato da `chokidar` a `@parcel/watcher`, sfruttando il file watching nativo in C++ per fornire aggiornamenti più rapidi e un consumo di memoria significativamente inferiore.
+- **Nuovo Language Server Protocol (LSP)**: È ora disponibile un LSP completamente nuovo. Costruito con parsing basato su OXC, aiuta il tuo IDE e gli agenti AI a collegare senza soluzione di continuità le chiamate `useIntlayer('my-key')` con i loro file `.content` corrispondenti, e viceversa.
+
+Per maggiori dettagli, consulta la [Documentazione LSP](https://intlayer.org/doc/lsp).
+
+---
+
 ## Ottimizzazioni del compilatore
 
 Intlayer v8 include un nuovo layer di caching per il compilatore Markdown e HTML. Questo garantisce che stringhe di contenuto identiche con la stessa configurazione vengano analizzate solo una volta, riducendo significativamente l'overhead durante i re-render o quando lo stesso contenuto è utilizzato in più punti.
@@ -1057,6 +1170,48 @@ Intlayer v8 include un nuovo layer di caching per il compilatore Markdown e HTML
 
 ---
 
+## Ottimizzazioni sperimentali della build: Minify & Purge (v8.7.0)
+
+Intlayer v8.7.0 introduce nuove funzionalità di build sperimentali nel tuo `intlayer.config.ts` progettate per ottimizzare il tuo bundle di produzione:
+
+- **Minificazione del dizionario**: Minifica i file del dizionario per ridurne le dimensioni.
+- **Pulizia delle chiavi inutilizzate**: Scansiona e rimuove le chiavi di traduzione inutilizzate dai dizionari, rinominando le chiavi attive con caratteri brevi (es. `"products" -> "a"`, `"pricing" -> "b"`). Questo riduce le dimensioni del bundle fino al 5%.
+- **Disabilita i controlli TypeScript**: Accelera le build disabilitando il controllo dei tipi TypeScript durante la fase di compilazione.
+
+```typescript fileName="intlayer.config.ts"
+import { Locales, type IntlayerConfig } from "intlayer";
+
+const config: IntlayerConfig = {
+  internationalization: {
+    locales: [Locales.ENGLISH, Locales.FRENCH],
+    defaultLocale: Locales.ENGLISH,
+  },
+  dictionary: {
+    importMode: "dynamic",
+  },
+  build: {
+    /**
+     * Minify the dictionaries to reduce the bundle size.
+     */
+    minify: true,
+
+    /**
+     * Purge the unused keys in dictionaries
+     */
+    purge: true,
+
+    /**
+     * Indicates if the build should check TypeScript types
+     */
+    checkTypes: false,
+  },
+};
+
+export default config;
+```
+
+---
+
 ## Flessibilità: Modalità di importazione unificata
 
 La proprietà booleana `live` è stata deprecata a favore di una proprietà più completa, `importMode`. Questo consente di definire esplicitamente come devono essere caricati i dizionari: staticamente, dinamicamente o tramite sincronizzazione live.
@@ -1204,6 +1359,49 @@ Il contenuto Markdown e HTML in Svelte ora viene automaticamente convertito in H
 
 ---
 
+## Supporto Angular: Vite Bundler (v8.11.0)
+
+Per gli utenti Angular, Intlayer ora supporta nativamente il bundler Vite tramite un nuovo plugin esbuild personalizzato, accelerando i tempi di sviluppo e di build.
+
+Per i dettagli sulla configurazione, consulta la [Documentazione dell'ambiente Angular](https://intlayer.org/doc/environment/angular).
+
+---
+
+## Generazione della Sitemap (v8.6.0)
+
+Intlayer ora genera automaticamente le sitemap in base alle tue locali e alla modalità di routing. Questo è particolarmente utile per l'ottimizzazione SEO in architetture di router come TanStack Router:
+
+```typescript fileName="src/routes/sitemap.xml.ts"
+import { createFileRoute } from "@tanstack/react-router";
+import { generateSitemap } from "intlayer";
+
+const SITE_URL = (
+  import.meta.env.VITE_SITE_URL ?? "http://localhost:3000"
+).replace(/\/$/, "");
+
+export const Route = createFileRoute("/sitemap.xml")({
+  server: {
+    handlers: {
+      GET: async () => {
+        const sitemap = generateSitemap(
+          [
+            { path: "/", changefreq: "daily", priority: 1.0 },
+            { path: "/about", changefreq: "monthly", priority: 0.8 },
+          ],
+          { siteUrl: SITE_URL }
+        );
+
+        return new Response(sitemap, {
+          headers: { "Content-Type": "application/xml" },
+        });
+      },
+    },
+  },
+});
+```
+
+---
+
 ## Note di migrazione dalla v7
 
 ### Modifiche alla configurazione