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

package/docs/it/configuration.md

@@ -1,6 +1,6 @@
 ---
 createdAt: 2024-08-13
-updatedAt: 2026-05-12
+updatedAt: 2026-06-17
 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,9 @@ slugs:
   - concept
   - configuration
 history:
+  - 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"
@@ -135,6 +138,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";
 
 /**
@@ -585,10 +589,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;
@@ -857,20 +889,21 @@ Impostazioni per come i contenuti sono gestiti nell'applicazione, inclusi i nomi
 
 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`**:
 

package/docs/it/dictionary/condition.md

@@ -67,7 +67,10 @@ export default myConditionalContent;
 
 ## Utilizzo del Contenuto Condizionale con React Intlayer
 
-Per utilizzare il contenuto condizionale all'interno di un componente React, importa e utilizza il hook `useIntlayer` dal pacchetto `react-intlayer`. Questo hook recupera il contenuto per la chiave specificata e consente di passare una condizione per selezionare l'output appropriato.
+<Tabs group="framework">
+  <Tab label="React" value="react">
+
+To utilize conditional content within a React component, import and use the `useIntlayer` hook from the `react-intlayer` package. This hook fetches the content for the specified key and allows you to pass in a condition to select the appropriate output.
 
 ```tsx fileName="**/*.tsx" codeFormat={["typescript", "esm"]}
 import type { FC } from "react";
@@ -80,25 +83,25 @@ const ConditionalComponent: FC = () => {
     <div>
       <p>
         {
-          /* Output: il mio contenuto quando è vero */
+          /* Output: my content when it's true */
           myCondition(true)
         }
       </p>
       <p>
         {
-          /* Output: il mio contenuto quando è falso */
+          /* Output: my content when it's false */
           myCondition(false)
         }
       </p>
       <p>
         {
-          /* Output: il mio contenuto quando la condizione fallisce */
+          /* Output: my content when the condition fails */
           myCondition("")
         }
       </p>
       <p>
         {
-          /* Output: il mio contenuto quando la condizione fallisce */
+          /* Output: my content when the condition fails */
           myCondition(undefined)
         }
       </p>
@@ -109,6 +112,165 @@ const ConditionalComponent: FC = () => {
 export default ConditionalComponent;
 ```
 
+  </Tab>
+  <Tab label="Next.js" value="nextjs">
+
+To utilize conditional content in Next.js Client Components, retrieve it via the `useIntlayer` hook. Here's an example:
+
+```tsx fileName="**/*.tsx" codeFormat={["typescript", "esm"]}
+"use client";
+
+import type { FC } from "react";
+import { useIntlayer } from "next-intlayer";
+
+const ConditionalComponent: FC = () => {
+  const { myCondition } = useIntlayer("my_key");
+
+  return (
+    <div>
+      <p>{myCondition(true)}</p>
+      <p>{myCondition(false)}</p>
+    </div>
+  );
+};
+
+export default ConditionalComponent;
+```
+
+  </Tab>
+  <Tab label="Vue" value="vue">
+
+To utilize conditional content in Vue components, retrieve it via the `useIntlayer` hook. Here's an example:
+
+```vue fileName="**/*.vue"
+<script setup lang="ts">
+import { useIntlayer } from "vue-intlayer";
+
+const { myCondition } = useIntlayer("my_key");
+</script>
+
+<template>
+  <div>
+    <p>{{ myCondition(true) }}</p>
+    <p>{{ myCondition(false) }}</p>
+  </div>
+</template>
+```
+
+  </Tab>
+  <Tab label="Svelte" value="svelte">
+
+To utilize conditional content in Svelte components, retrieve it via the `useIntlayer` hook. The store is accessed with `$`. Here's an example:
+
+```svelte fileName="**/*.svelte"
+<script lang="ts">
+import { useIntlayer } from "svelte-intlayer";
+
+const content = useIntlayer("my_key");
+</script>
+
+<div>
+  <p>{$content.myCondition(true)}</p>
+  <p>{$content.myCondition(false)}</p>
+</div>
+```
+
+  </Tab>
+  <Tab label="Preact" value="preact">
+
+To utilize conditional content in Preact components, retrieve it via the `useIntlayer` hook. Here's an example:
+
+```tsx fileName="**/*.tsx" codeFormat={["typescript", "esm"]}
+import type { FC } from "preact";
+import { useIntlayer } from "preact-intlayer";
+
+const ConditionalComponent: FC = () => {
+  const { myCondition } = useIntlayer("my_key");
+
+  return (
+    <div>
+      <p>{myCondition(true)}</p>
+      <p>{myCondition(false)}</p>
+    </div>
+  );
+};
+
+export default ConditionalComponent;
+```
+
+  </Tab>
+  <Tab label="Solid" value="solid">
+
+To utilize conditional content in SolidJS components, retrieve it via the `useIntlayer` hook. Here's an example:
+
+```tsx fileName="**/*.tsx" codeFormat={["typescript", "esm"]}
+import type { Component } from "solid-js";
+import { useIntlayer } from "solid-intlayer";
+
+const ConditionalComponent: Component = () => {
+  const { myCondition } = useIntlayer("my_key");
+
+  return (
+    <div>
+      <p>{myCondition(true)}</p>
+      <p>{myCondition(false)}</p>
+    </div>
+  );
+};
+
+export default ConditionalComponent;
+```
+
+  </Tab>
+  <Tab label="Angular" value="angular">
+
+To utilize conditional content in Angular components, retrieve it via the `useIntlayer` hook. Here's an example:
+
+```typescript fileName="app.component.ts" codeFormat="typescript"
+import { Component } from "@angular/core";
+import { useIntlayer } from "angular-intlayer";
+
+@Component({
+  selector: "app-conditional",
+  template: `
+    <div>
+      <p>{{ content().myCondition(true) }}</p>
+      <p>{{ content().myCondition(false) }}</p>
+    </div>
+  `,
+})
+export class ConditionalComponent {
+  content = useIntlayer("my_key");
+}
+```
+
+  </Tab>
+  <Tab label="Vanilla JS" value="vanilla">
+
+To utilize conditional content with `vanilla-intlayer`, retrieve it via the `useIntlayer` hook. Here's an example:
+
+```typescript fileName="**/*.ts" codeFormat={["typescript", "esm"]}
+import { installIntlayer, useIntlayer } from "vanilla-intlayer";
+
+installIntlayer();
+
+const content = useIntlayer("my_key").onChange((newContent) => {
+  document.getElementById("true-content")!.textContent =
+    newContent.myCondition(true);
+  document.getElementById("false-content")!.textContent =
+    newContent.myCondition(false);
+});
+
+// Initial render
+document.getElementById("true-content")!.textContent =
+  content.myCondition(true);
+document.getElementById("false-content")!.textContent =
+  content.myCondition(false);
+```
+
+  </Tab>
+</Tabs>
+
 ## Risorse Aggiuntive
 
 Per informazioni più dettagliate sulla configurazione e sull'utilizzo, consulta le seguenti risorse: