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

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

package/docs/it/releases/v9.md

@@ -0,0 +1,316 @@
+---
+createdAt: 2026-06-14
+updatedAt: 2026-06-26
+title: Nuovo Intlayer v9 - Cosa c'è di nuovo?
+description: Scopri le novità di Intlayer v9. Introduzione di package di compatibilità drop-in per le più diffuse librerie i18n e supporto per Collections e Variants.
+keywords:
+  - Intlayer
+  - Compatibilità
+  - Migrazione
+  - Collections
+  - Variants
+  - i18next
+  - next-intl
+  - vue-i18n
+slugs:
+  - doc
+  - releases
+  - v9
+author: aymericzip
+---
+
+# Nuovo Intlayer v9 - Cosa c'è di nuovo?
+
+Benvenuti a Intlayer v9! Questa major release segna un'enorme pietra miliare nella semplificazione del percorso di migrazione a Intlayer con i **Compat Adapter Packages** per le principali librerie i18n (`react-i18next`, `next-intl`, `vue-i18n`, ecc.) e aggiunge il supporto per strutture di contenuto ricche: **Collections** e **Variants**.
+
+## Indice
+
+<TOC levels={[2]} maxDepth={1} />
+
+---
+
+## Compat Adapter Packages
+
+La migrazione a Intlayer dalle popolari librerie i18n è ora più facile che mai. Abbiamo creato cinque compat package che espongono le **stesse identiche API pubbliche** delle librerie i18n standard, ma delegano tutto il lavoro di traduzione a Intlayer a runtime.
+
+### Esporre la stessa API pubblica con tipizzazione stretta
+
+Sostituendo gli import, ottieni tutti i vantaggi di Intlayer (inclusa la type safety in fase di compilazione rispetto ai tuoi dizionari effettivi) con modifiche minime al codice:
+
+- `@intlayer/i18next`
+- `@intlayer/react-i18next`
+- `@intlayer/next-intl`
+- `@intlayer/react-intl`
+- `@intlayer/next-i18next`
+- `@intlayer/vue-i18n`
+- `@intlayer/lingui`
+
+Ad esempio, è sufficiente cambiare:
+
+```ts
+import { useTranslation } from "react-i18next";
+```
+
+in:
+
+```ts
+import { useTranslation } from "@intlayer/react-i18next";
+```
+
+Le tue chiavi saranno ora **strettamente tipizzate** rispetto ai tuoi dizionari Intlayer, offrendo il completamento automatico completo del dot-path nel tuo IDE!
+
+### Bundler Alias Plugins (Vite, Next.js, Turbopack)
+
+Per consentire la migrazione senza riscrivere manualmente tutte le tue istruzioni di import, ogni compat adapter package include un **plugin bundler personalizzato** (Vite o Next.js) sotto il sottopercorso `/plugin`.
+
+Questi plugin riscrivono automaticamente gli import esistenti (ad esempio `react-i18next` o `next-intl`) nei loro equivalenti `@intlayer/*` in fase di build.
+
+#### Esempio Next.js (Webpack / Turbopack)
+
+Invece di `withIntlayer`, avvolgi la tua configurazione Next.js con il compat plugin:
+
+```ts fileName="next.config.ts"
+import { createNextI18nPlugin } from "@intlayer/next-i18next/plugin";
+import type { NextConfig } from "next";
+
+const withIntlayer = createNextI18nPlugin();
+const nextConfig: NextConfig = {};
+
+export default withIntlayer(nextConfig);
+```
+
+#### Esempio Vite (React, Vue, Solid, Svelte)
+
+```ts fileName="vite.config.ts"
+import vueI18nVitePlugin from "@intlayer/vue-i18n/plugin";
+
+export default defineConfig({
+  plugins: [vueI18nVitePlugin()],
+});
+```
+
+---
+
+## Risolutore Runtime Mutualizzato
+
+Tutti i compat adapter ora instradano la risoluzione delle traduzioni attraverso un singolo parser runtime altamente ottimizzato: `@intlayer/core/messageFormat`.
+
+- **Interpolate Message**: Risolve `{{var}}` standard (spazi bianchi e dot-paths), argomenti formattati ICU (`{v, number, percent}` ecc.) e template `{var}` semplici.
+- **Message Node Resolver**: Risolve nodi annidati: `insert()`, `plural()` (regole plurali CLDR), `enu()` (enumerazione), `gender()`, tag HTML, array e nodi di funzione richiamabili.
+- **Tokenized Tag Parser**: Supporta tag XML/HTML inline e tag numerati (ad esempio, `<1>children</1>`) per abilitare il rendering di testo ricco out of the box.
+
+---
+
+## Specifica delle Funzionalità: Collections & Variants
+
+Intlayer v9 si espande oltre gli oggetti chiave-valore statici, consentendo ai dizionari di dichiarare strutture di layout dinamiche che sono completamente tipizzate end-to-end.
+
+### 1. Collections
+
+Definisci un elenco di elementi ordinati gestito da CMS (ad esempio FAQ, prodotti o elenchi di blog):
+
+```ts fileName="faq.1.content.ts"
+import { t, type Dictionary } from "intlayer";
+
+export default {
+  key: "faq",
+  item: 1,
+  content: {
+    question: t({ en: "What is Intlayer?", fr: "Qu'est-ce qu'Intlayer ?" }),
+    answer: t({ en: "An i18n toolkit.", fr: "Une boîte à outils i18n." }),
+  },
+} satisfies Dictionary;
+```
+
+```ts fileName="faq.2.content.ts"
+import { t, type Dictionary } from "intlayer";
+
+export default {
+  key: "faq",
+  item: 2,
+  content: {
+    question: t({ en: "Is it free?", fr: "Est-ce gratuit ?" }),
+    answer: t({ en: "Yes, open-source.", fr: "Oui, open-source." }),
+  },
+} satisfies Dictionary;
+```
+
+#### Utilizzo:
+
+```ts
+// Fetch all items as an array
+const allFaqs = useIntlayer("faq"); // -> { question: string, answer: string }[]
+
+// Fetch a single item by index
+const faq = useIntlayer("faq", { item: 2 }); // -> { question: string, answer: string }
+```
+
+### 2. Variants
+
+Fornisci A/B test, header stagionali, feature flag o landing page personalizzate:
+
+#### Varianti stringa (es. test A/B)
+
+```ts fileName="hero.content.ts"
+import { t, type Dictionary } from "intlayer";
+
+export default {
+  key: "hero-banner",
+  variant: "default",
+  content: {
+    control: t({ it: "Benvenuto", en: "Welcome", fr: "Bienvenue" }),
+    black_friday: t({
+      it: "Acquista ora",
+      en: "Shop now",
+      fr: "Acheter maintenant",
+    }),
+  },
+} satisfies Dictionary;
+```
+
+#### Utilizzo:
+
+```ts
+const banner = useIntlayer("hero-banner", { variant: "black_friday" });
+```
+
+#### Varianti oggetto (es. Dynamic Records)
+
+```ts fileName="product.content.ts"
+import { t, type Dictionary } from "intlayer";
+
+export default {
+  key: "product-copy",
+  variant: {
+    id: "prod_123",
+    category: "books",
+  },
+  content: {
+    title: t({ it: "Clean Code", en: "Clean Code", fr: "Code Propre" }),
+  },
+} satisfies Dictionary;
+```
+
+#### Utilizzo:
+
+```ts
+// Recupera solo l'elemento richiesto dinamicamente (richiede Suspense)
+const product = useIntlayer("product-copy", {
+  variant: { id: "prod_123", category: "books" },
+});
+```
+
+---
+
+## Caricamento Dinamico e Ottimizzazioni delle Dimensioni del Bundle
+
+Per mantenere i bundle estremamente piccoli, Intlayer v9 supporta il caricamento dinamico lazy loading.
+
+Nella tua configurazione, imposta `importMode` su `'dynamic'` o `'fetch'`:
+
+```ts fileName="intlayer.config.ts"
+export default {
+  dictionary: {
+    importMode: "dynamic", // "static" | "dynamic" | "fetch"
+  },
+};
+```
+
+In fase di build, `@intlayer/swc` e `@intlayer/babel` scansionano i tuoi file e sostituiscono le chiamate `useIntlayer` / `getIntlayer` con wrapper tree-shakeable (`useDictionary` / `useDictionaryDynamic`). Viene caricato solo il contenuto richiesto per l'elemento della collection, la variante o la locale selezionati, impedendo al tuo bundle di produzione di contenere traduzioni inutilizzate.
+
+---
+
+## Vite Plugin: Compiler e Proxy in Bundle
+
+Il plugin Vite `intlayer()` ora raggruppa il **compiler** e il **proxy di locale-routing** direttamente, quindi la maggior parte dei progetti ha bisogno solo di un singolo plugin in `vite.config.ts`:
+
+```ts fileName="vite.config.ts"
+import { defineConfig } from "vite";
+import { intlayer } from "vite-intlayer";
+
+export default defineConfig({
+  plugins: [intlayer()],
+});
+```
+
+- **Compiler**: Si attiva automaticamente quando `compiler.enabled` è impostato su `true` e un percorso `compiler.output` è configurato. Non è più necessario registrare `intlayerCompiler()` separatamente.
+- **Proxy**: Si attiva automaticamente in base alla nuova opzione `routing.enableProxy` (`true` per impostazione predefinita). Collega il middleware di rilevamento locale / reindirizzamento / riscrittura in sviluppo, anteprima e SSR in produzione. Non è più necessario registrare `intlayerProxy()` separatamente.
+
+### Opzione `routing.enableProxy`
+
+Una nuova opzione `routing.enableProxy` controlla se il proxy di routing per le locale è attivo. Il valore predefinito è `true`. Disabilitalo quando desideri gestire il routing delle locale autonomamente:
+
+```ts fileName="intlayer.config.ts"
+import type { IntlayerConfig } from "intlayer";
+
+const config: IntlayerConfig = {
+  routing: {
+    enableProxy: false, // Default: true
+  },
+};
+
+export default config;
+```
+
+I plugin standalone `intlayerCompiler()` e `intlayerProxy()` rimangono esportati per configurazioni avanzate. Registrarli insieme a `intlayer()` è sicuro — ogni plugin si deduplica e viene eseguito una sola volta.
+
+---
+
+## Compilatore disabilitato per impostazione predefinita
+
+A partire da Intlayer v9, il **compilatore è disabilitato per impostazione predefinita** (`compiler.enabled` ora ha come valore predefinito `false`). Per abilitare l'estrazione dei tuoi file `.content.ts` in fase di build, imposta `compiler.enabled: true` nella tua configurazione:
+
+```ts fileName="intlayer.config.ts"
+import type { IntlayerConfig } from "intlayer";
+
+const config: IntlayerConfig = {
+  compiler: {
+    enabled: true, // Predefinito: false — richiesto per abilitare il compilatore dalla v9
+    output: ({ fileName }) => `./${fileName}.content.ts`,
+  },
+};
+
+export default config;
+```
+
+Quando il compilatore è disabilitato, Intlayer salta il passaggio di estrazione in fase di build e si basa sui dizionari che hai già dichiarato. Abilitalo solo quando vuoi che il plugin del bundler (`@intlayer/swc`, `@intlayer/babel` o il plugin Vite `intlayer()`) estragga il contenuto automaticamente.
+
+---
+
+## React Native: importazioni da un unico pacchetto
+
+In un'app React Native o Expo, non è più necessario destreggiarsi tra `react-intlayer` e `react-native-intlayer`. Il pacchetto `react-native-intlayer` ora **riesporta l'intera API `react-intlayer`** (hook, utility e i sottopercorsi `/format`, `/html` e `/markdown`), e il suo `IntlayerProvider` applica automaticamente i polyfill di React Native.
+
+Importa tutto dal pacchetto singolo `react-native-intlayer`:
+
+```tsx
+import {
+  IntlayerProvider,
+  useIntlayer,
+  useLocale,
+} from "react-native-intlayer";
+```
+
+```bash
+npm install intlayer react-native-intlayer
+```
+
+> L'importazione da `react-intlayer` continua a funzionare, ma `react-native-intlayer` è ora il punto di ingresso singolo consigliato per React Native: il suo provider include i polyfill che il provider orientato al web `react-intlayer` non ha.
+
+---
+
+## Note di migrazione da v8
+
+Se stai eseguendo l'aggiornamento da v8, nota che la v9 non include breaking changes. Ma ecco le modifiche chiave:
+
+- **Compilatore disabilitato per impostazione predefinita**: `compiler.enabled` ora ha come valore predefinito `false`. Se dipendi dall'estrazione dei tuoi file `.content.ts` in fase di build, imposta `compiler.enabled: true` nel tuo `intlayer.config.ts`.
+- **Locales & Dialects**: Se utilizzi dipendenze i18n esterne, aggiungi i rispettivi compat adapter plugin nella tua configurazione o setup del bundler per riscrivere automaticamente gli import.
+- **Custom Selectors**: Quando chiami `useIntlayer`, il secondo parametro è ora riservato a un oggetto di opzioni contenente `{ locale, item, variant }`. Se in precedenza passavi direttamente una stringa locale, puoi ancora farlo, ma l'utilizzo dell'oggetto di opzioni è consigliato per selezioni avanzate.
+
+---
+
+## Link utili
+
+- [Guida ai Compat Adapter Packages](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/compat/index.md)
+- [Dizionari Dinamici - Collections & Variants](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/dynamic_dictionaries/index.md)
+- [Riferimento alla Configurazione](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/configuration.md)

package/docs/it/roadmap.md

@@ -29,6 +29,12 @@ Intlayer è una soluzione per la gestione dei contenuti e l'internazionalizzazio
 
 ---
 
+## Sommario
+
+<TOC/>
+
+---
+
 ## Funzionalità Attuali
 
 ### 1. Dichiarazione dei Contenuti

package/docs/ja/CI_CD.md

@@ -30,6 +30,10 @@ Intlayer は、コンテンツ宣言ファイルの翻訳を自動生成する
 
 Intlayer を使用すると、ローカルでは単一のロケールのみを宣言し、すべての翻訳は CMS を通じてリモートで管理するワークフローを採用できます。これにより、コンテンツと翻訳がコードベースから完全に切り離され、コンテンツ編集者にとってより柔軟性が提供され、ホットコンテンツリロード（変更を適用するためにアプリケーションを再ビルドする必要なし）が可能になります。
 
+## CMSを使用する
+
+Intlayerを使用すると、単一のロケールのみをローカルで宣言し、すべての翻訳をCMSを介してリモートで管理するワークフローを採用できます。これにより、コンテンツと翻訳をコードベースから完全に分離でき、コンテンツエディターに対しより高い柔軟性を提供し、Live Sync（アプリケーションを再構築することなく変更を適用）を有効にします。
+
 ### 設定例
 
 ```ts fileName="intlayer.config.ts"

package/docs/ja/autoFill.md

@@ -28,6 +28,53 @@ history:
 author: aymericzip
 ---
 
+# コンテンツ宣言ファイルの翻訳を自動入力
+
+**CI でのコンテンツ宣言ファイルの自動入力**は、開発ワークフローを高速化する方法です。
+
+## 動作の理解
+
+`fill` コマンドには2つのモードがあります：
+
+- **Complete**: 各ロケールのすべての欠落コンテンツを自動的に入力し、現在のファイルまたは指定された別のファイルを編集します。つまり、完全モードは既に翻訳されている既存コンテンツのスキップします。
+- **Review**: 各ロケールのすべてのコンテンツを自動的に入力し、特定のファイルまたは指定された別のファイルを生成します。
+
+`fill` コマンドはすべてのロケールコンテンツ宣言ファイルを処理します。つまり、CMSからのリモートコンテンツは処理しません。CMSは独自の翻訳管理を含んでいます。
+`@intlayer/sync-json-plugin` などのプラグインを使用する場合、Intlayerはこれらのファイルをロケールコンテンツ宣言ファイルに変換します。つまり、これらのファイルは `fill` コマンドによって処理されます。
+
+新しく生成されたファイルには、辞書メタデータとして `filled` 命令が含まれています。この命令は、Intlayerがファイルが自動入力されたかどうかを判定し、存在する場合はこのファイルを再度翻訳の対象からスキップするために使用されます。
+
+Intlayerは自動入力に関して以下の命令を考慮します：
+
+- `.content.{ts|js|json}` ファイルから → `fill` 命令
+- 設定ファイル `.intlayer.config.ts` から → `dictionary.fill` 命令
+- それ以外の場合はデフォルトで `true` に設定されます
+
+ロケール固有のコンテンツ宣言ファイルの場合、`true` 命令は `./{{fileName}}.fill.content.json` に置き換えられます。これは、ロケール固有のコンテンツ宣言ファイルが追加のローカライズされたコンテンツを受け取ることができないためです。そのため、既存のファイルを上書きしないために新しいファイルを生成します。
+
+## デフォルト動作
+
+デフォルトでは、`fill`はグローバルに`true`に設定されています。これは、Intlayerがすべてのコンテンツファイルを自動的に入力し、ファイル自体を編集することを意味します。この動作は、いくつかの方法でカスタマイズできます。
+
+### グローバル設定オプション
+
+1. **`fill: true` (デフォルト)** - すべてのロケールを自動的に埋め、現在のファイルを編集します
+2. **`fill: false`** - このコンテンツファイルの自動埋めを無効にします
+3. **`fill: "./relative/path/to/file"`** - 現在のファイルを編集せずに指定されたファイルを作成/更新します。相対パスは現在のファイルの場所に基づいて解決されます
+4. **`fill: "/absolute/path/to/file"`** - 現在のファイルを編集せずに指定されたファイルを作成/更新します。相対パスは基本ディレクトリの場所に基づいて解決されます（設定ファイル `.intlayer.config.ts` の `baseDir` フィールド）
+5. **`fill: "C:\\absolute\path\to\file"`** - 現在のファイルを編集せずに指定されたファイルを作成/更新します。絶対パスはお使いのオペレーティングシステムに基づいて解決されます
+6. **`fill: { [key in Locales]?: string }`** - 各ロケールについて指定されたファイルを作成/更新します
+
+### v7 の動作変更
+
+v7 では、`fill` コマンドの動作が更新されました：
+
+- **`fill: true`** - 現在のファイルを全ロケールの埋め込みコンテンツで上書きします
+- **`fill: "path/to/file"`** - 指定されたファイルを埋め込みますが、現在のファイルは変更しません
+- **`fill: false`** - 自動埋め込みを完全に無効にします
+
+別のファイルに書き込むためのパスオプションを使用する場合、埋め込みメカニズムはコンテンツ宣言ファイル間の _マスター・スレーブ_ 関係を通じて機能します。メインファイル（マスター）が情報源として機能し、更新されると、Intlayer はパスで指定されたスレーブの宣言ファイルに変更を自動的に適用します。
+
 # 自動入力コンテンツ宣言ファイルの翻訳
 
 **自動入力コンテンツ宣言ファイル**は、開発ワークフローを高速化する方法です。
@@ -88,6 +135,40 @@ Intlayer は、メインファイルにまだ宣言されていないすべて
 
 その後、両方の宣言ファイルは単一の辞書にマージされ、標準の `useIntlayer("example")` フック（React）/ コンポーザブル（Vue）を使ってアクセス可能になります。
 
+## グローバル設定
+
+`intlayer.config.ts` ファイルでグローバル自動入力設定を構成できます。
+
+```ts fileName="intlayer.config.ts"
+import { type IntlayerConfig, Locales } from "intlayer";
+
+const config: IntlayerConfig = {
+  internationalization: {
+    locales: [Locales.ENGLISH, Locales.FRENCH, Locales.SPANISH],
+    defaultLocale: Locales.ENGLISH,
+    requiredLocales: [Locales.ENGLISH, Locales.FRENCH],
+  },
+  dictionary: {
+    // すべての辞書に対して欠落している翻訳を自動生成します
+    fill: "./{{fileName}}Filled.content.ts",
+    //
+    // fill: "/messages/{{locale}}/{{key}}/{{fileName}}.content.json",
+    //
+    // fill: true, // "./{{fileName}}.content.json" を使用しているようなすべての辞書に対して欠落している翻訳を自動生成します
+    //
+    // fill: {
+    //   en: "./{{fileName}}.en.content.json",
+    //   fr: "./{{fileName}}.fr.content.json",
+    //   es: "./{{fileName}}.es.content.json",
+    // },
+  },
+};
+
+export default config;
+```
+
+コンテンツファイルの `fill` フィールドを使用して、辞書ごとに細かく調整することもできます。Intlayer は最初に辞書ごとの設定を検討し、その後グローバル設定にフォールバックします。
+
 ## 自動補完されたファイル形式
 
 自動補完された宣言ファイルに推奨される形式は **JSON** であり、これによりフォーマットの制約を回避できます。ただし、Intlayer は `.ts`、`.js`、`.mjs`、`.cjs` などの他の形式もサポートしています。