@intlayer/docs 5.5.8

package/it/dictionary/condition.md

@@ -0,0 +1,213 @@
+# Contenuto Condizionale / Condizione in Intlayer
+
+## Come Funziona la Condizione
+
+In Intlayer, il contenuto condizionale viene realizzato tramite la funzione `cond`, che mappa condizioni specifiche (tipicamente valori booleani) al loro contenuto corrispondente. Questo approccio consente di selezionare dinamicamente il contenuto in base a una determinata condizione. Quando integrato con React Intlayer o Next Intlayer, il contenuto appropriato viene automaticamente scelto in base alla condizione fornita in fase di esecuzione.
+
+## Configurazione del Contenuto Condizionale
+
+Per configurare il contenuto condizionale nel tuo progetto Intlayer, crea un modulo di contenuto che includa le tue definizioni condizionali. Di seguito sono riportati esempi in vari formati.
+
+```typescript fileName="**/*.content.ts" contentDeclarationFormat="typescript"
+import { cond, type Dictionary } from "intlayer";
+
+const myConditionalContent = {
+  key: "my_key",
+  content: {
+    myCondition: cond({
+      true: "il mio contenuto quando è vero",
+      false: "il mio contenuto quando è falso",
+      fallback: "il mio contenuto quando la condizione fallisce", // Opzionale
+    }),
+  },
+} satisfies Dictionary;
+
+export default myConditionalContent;
+```
+
+```javascript fileName="**/*.content.mjs" contentDeclarationFormat="esm"
+import { cond } from "intlayer";
+
+/** @type {import('intlayer').Dictionary} */
+const myConditionalContent = {
+  key: "my_key",
+  content: {
+    myCondition: cond({
+      true: "il mio contenuto quando è vero",
+      false: "il mio contenuto quando è falso",
+      fallback: "il mio contenuto quando la condizione fallisce", // Opzionale
+    }),
+  },
+};
+
+export default myConditionalContent;
+```
+
+```javascript fileName="**/*.content.cjs" contentDeclarationFormat="commonjs"
+const { cond } = require("intlayer");
+
+/** @type {import('intlayer').Dictionary} */
+const myConditionalContent = {
+  key: "my_key",
+  content: {
+    myCondition: cond({
+      true: "il mio contenuto quando è vero",
+      false: "il mio contenuto quando è falso",
+      fallback: "il mio contenuto quando la condizione fallisce", // Opzionale
+    }),
+  },
+};
+
+module.exports = myConditionalContent;
+```
+
+```json5 fileName="**/*.content.json" contentDeclarationFormat="json"
+{
+  "$schema": "https://intlayer.org/schema.json",
+  "key": "my_key",
+  "content": {
+    "myCondition": {
+      "nodeType": "condition",
+      "condition": {
+        "true": "il mio contenuto quando è vero",
+        "false": "il mio contenuto quando è falso",
+        "fallback": "il mio contenuto quando la condizione fallisce", // Opzionale
+      },
+    },
+  },
+}
+```
+
+> Se non viene dichiarato alcun fallback, l'ultima chiave dichiarata sarà presa come fallback se la condizione non viene validata.
+
+## 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.
+
+```tsx fileName="**/*.tsx" codeFormat="typescript"
+import type { FC } from "react";
+import { useIntlayer } from "react-intlayer";
+
+const ConditionalComponent: FC = () => {
+  const { myCondition } = useIntlayer("my_key");
+
+  return (
+    <div>
+      <p>
+        {
+          /* Output: il mio contenuto quando è vero */
+          myCondition(true)
+        }
+      </p>
+      <p>
+        {
+          /* Output: il mio contenuto quando è falso */
+          myCondition(false)
+        }
+      </p>
+      <p>
+        {
+          /* Output: il mio contenuto quando la condizione fallisce */
+          myCondition("")
+        }
+      </p>
+      <p>
+        {
+          /* Output: il mio contenuto quando la condizione fallisce */
+          myCondition(undefined)
+        }
+      </p>
+    </div>
+  );
+};
+
+export default ConditionalComponent;
+```
+
+```javascript fileName="**/*.mjx" codeFormat="esm"
+import { useIntlayer } from "react-intlayer";
+
+const ConditionalComponent = () => {
+  const { myCondition } = useIntlayer("my_key");
+
+  return (
+    <div>
+      <p>
+        {
+          /* Output: il mio contenuto quando è vero */
+          myCondition(true)
+        }
+      </p>
+      <p>
+        {
+          /* Output: il mio contenuto quando è falso */
+          myCondition(false)
+        }
+      </p>
+      <p>
+        {
+          /* Output: il mio contenuto quando la condizione fallisce */
+          myCondition("")
+        }
+      </p>
+      <p>
+        {
+          /* Output: il mio contenuto quando la condizione fallisce */
+          myCondition(undefined)
+        }
+      </p>
+    </div>
+  );
+};
+
+export default ConditionalComponent;
+```
+
+```javascript fileName="**/*.cjs" codeFormat="commonjs"
+const { useIntlayer } = require("react-intlayer");
+
+const ConditionalComponent = () => {
+  const { myCondition } = useIntlayer("my_key");
+
+  return (
+    <div>
+      <p>
+        {
+          /* Output: il mio contenuto quando è vero */
+          myCondition(true)
+        }
+      </p>
+      <p>
+        {
+          /* Output: il mio contenuto quando è falso */
+          myCondition(false)
+        }
+      </p>
+      <p>
+        {
+          /* Output: il mio contenuto quando la condizione fallisce */
+          myCondition("")
+        }
+      </p>
+      <p>
+        {
+          /* Output: il mio contenuto quando la condizione fallisce */
+          myCondition(undefined)
+        }
+      </p>
+    </div>
+  );
+};
+
+module.exports = ConditionalComponent;
+```
+
+## Risorse Aggiuntive
+
+Per informazioni più dettagliate sulla configurazione e sull'utilizzo, consulta le seguenti risorse:
+
+- [Documentazione CLI di Intlayer](https://github.com/aymericzip/intlayer/blob/main/docs/it/intlayer_cli.md)
+- [Documentazione React Intlayer](https://github.com/aymericzip/intlayer/blob/main/docs/it/intlayer_with_create_react_app.md)
+- [Documentazione Next Intlayer](https://github.com/aymericzip/intlayer/blob/main/docs/it/intlayer_with_nextjs_15.md)
+
+Queste risorse offrono ulteriori approfondimenti sulla configurazione e sull'utilizzo di Intlayer in diversi ambienti e framework.

package/it/dictionary/content_extention_customization.md

@@ -0,0 +1,81 @@
+# Personalizzazione delle Estensioni dei Contenuti
+
+## Estensioni dei File di Contenuto
+
+Intlayer consente di personalizzare le estensioni per i file di dichiarazione dei contenuti. Questa personalizzazione offre flessibilità nella gestione di progetti su larga scala e aiuta a evitare conflitti con altri moduli.
+
+### Estensioni Predefinite
+
+Per impostazione predefinita, Intlayer monitora tutti i file con le seguenti estensioni per le dichiarazioni di contenuto:
+
+- `.content.json`
+- `.content.ts`
+- `.content.tsx`
+- `.content.js`
+- `.content.jsx`
+- `.content.mjs`
+- `.content.mjx`
+- `.content.cjs`
+- `.content.cjx`
+
+Queste estensioni predefinite sono adatte per la maggior parte delle applicazioni. Tuttavia, quando hai esigenze specifiche, puoi definire estensioni personalizzate per ottimizzare il processo di build e ridurre il rischio di conflitti con altri componenti.
+
+### Personalizzazione delle Estensioni dei Contenuti
+
+Per personalizzare le estensioni dei file che Intlayer utilizza per identificare i file di dichiarazione dei contenuti, puoi specificarle nel file di configurazione di Intlayer. Questo approccio è utile per progetti su larga scala, dove limitare l'ambito del processo di monitoraggio migliora le prestazioni di build.
+
+Ecco un esempio di come definire estensioni personalizzate nel file di configurazione:
+
+```typescript fileName="intlayer.config.ts" codeFormat="typescript"
+import type { IntlayerConfig } from "intlayer";
+
+const config: IntlayerConfig = {
+  content: {
+    fileExtensions: [".my_content.ts", ".my_content.tsx"], // Le tue estensioni personalizzate
+  },
+};
+
+export default config;
+```
+
+```javascript fileName="intlayer.config.mjs" codeFormat="esm"
+/** @type {import('intlayer').IntlayerConfig} */
+const config = {
+  content: {
+    fileExtensions: [".my_content.cjs", ".my_content.cjx"], // Le tue estensioni personalizzate
+  },
+};
+
+export default config;
+```
+
+```javascript fileName="intlayer.config.cjs" codeFormat="commonjs"
+/** @type {import('intlayer').IntlayerConfig} */
+const config = {
+  content: {
+    fileExtensions: [".my_content.mjs", ".my_content.mjx"], // Le tue estensioni personalizzate
+  },
+};
+
+module.exports = config;
+```
+
+In questo esempio, la configurazione specifica due estensioni personalizzate: `.my_content.ts` e `.my_content.tsx`. Intlayer monitorerà solo i file con queste estensioni per costruire i dizionari.
+
+### Vantaggi delle Estensioni Personalizzate
+
+- **Prestazioni di Build**: Ridurre l'ambito dei file monitorati può migliorare significativamente le prestazioni di build in progetti di grandi dimensioni.
+- **Evitare Conflitti**: Le estensioni personalizzate aiutano a prevenire conflitti con altri file JavaScript o TypeScript nel tuo progetto.
+- **Organizzazione**: Le estensioni personalizzate ti consentono di organizzare i file di dichiarazione dei contenuti in base alle esigenze del tuo progetto.
+
+### Linee Guida per le Estensioni Personalizzate
+
+Quando personalizzi le estensioni dei file di contenuto, tieni presente le seguenti linee guida:
+
+- **Unicità**: Scegli estensioni uniche all'interno del tuo progetto per evitare conflitti.
+- **Nomenclatura Coerente**: Usa convenzioni di denominazione coerenti per una migliore leggibilità e manutenzione del codice.
+- **Evitare Estensioni Comuni**: Evita di utilizzare estensioni comuni come `.ts` o `.js` per prevenire conflitti con altri moduli o librerie.
+
+## Conclusione
+
+Personalizzare le estensioni dei file di contenuto in Intlayer è una funzionalità preziosa per ottimizzare le prestazioni e prevenire conflitti in applicazioni su larga scala. Seguendo le linee guida descritte in questa documentazione, puoi gestire efficacemente le dichiarazioni di contenuto e garantire un'integrazione fluida con altre parti del tuo progetto.

package/it/dictionary/enumeration.md

@@ -0,0 +1,221 @@
+# Enumerazione / Pluralizzazione
+
+## Come Funziona l'Enumerazione
+
+In Intlayer, l'enumerazione viene realizzata tramite la funzione `enu`, che mappa chiavi specifiche ai loro contenuti corrispondenti. Queste chiavi possono rappresentare valori numerici, intervalli o identificatori personalizzati. Quando utilizzata con React Intlayer o Next Intlayer, il contenuto appropriato viene selezionato automaticamente in base alla lingua dell'applicazione e alle regole definite.
+
+## Configurazione dell'Enumerazione
+
+Per configurare l'enumerazione nel tuo progetto Intlayer, devi creare un modulo di contenuto che includa le definizioni di enumerazione. Ecco un esempio di una semplice enumerazione per il numero di auto:
+
+```typescript fileName="**/*.content.ts" contentDeclarationFormat="typescript"
+import { enu, type Dictionary } from "intlayer";
+
+const carEnumeration = {
+  key: "car_count",
+  content: {
+    numberOfCar: enu({
+      "<-1": "Meno di meno una macchina",
+      "-1": "Meno una macchina",
+      "0": "Nessuna macchina",
+      "1": "Una macchina",
+      ">5": "Alcune macchine",
+      ">19": "Molte macchine",
+      "fallback": "Valore di fallback", // Opzionale
+    }),
+  },
+} satisfies Dictionary;
+
+export default carEnumeration;
+```
+
+```javascript fileName="**/*.content.mjs" contentDeclarationFormat="esm"
+import { enu } from "intlayer";
+
+/** @type {import('intlayer').Dictionary} */
+const carEnumeration = {
+  key: "car_count",
+  content: {
+    numberOfCar: enu({
+      "<-1": "Meno di meno una macchina",
+      "-1": "Meno una macchina",
+      "0": "Nessuna macchina",
+      "1": "Una macchina",
+      ">5": "Alcune macchine",
+      ">19": "Molte macchine",
+      "fallback": "Valore di fallback", // Opzionale
+    }),
+  },
+};
+
+export default carEnumeration;
+```
+
+```javascript fileName="**/*.content.cjs" contentDeclarationFormat="commonjs"
+const { enu } = require("intlayer");
+
+/** @type {import('intlayer').Dictionary} */
+const carEnumeration = {
+  key: "car_count",
+  content: {
+    numberOfCar: enu({
+      "<-1": "Meno di meno una macchina",
+      "-1": "Meno una macchina",
+      "0": "Nessuna macchina",
+      "1": "Una macchina",
+      ">5": "Alcune macchine",
+      ">19": "Molte macchine",
+      "fallback": "Valore di fallback", // Opzionale
+    }),
+  },
+};
+
+module.exports = carEnumeration;
+```
+
+```json fileName="**/*.content.json" contentDeclarationFormat="json"
+{
+  "$schema": "https://intlayer.org/schema.json",
+  "key": "car_count",
+  "content": {
+    "numberOfCar": {
+      "nodeType": "enumeration",
+      "enumeration": {
+        "<-1": "Meno di meno una macchina",
+        "-1": "Meno una macchina",
+        "0": "Nessuna macchina",
+        "1": "Una macchina",
+        ">5": "Alcune macchine",
+        ">19": "Molte macchine",
+        "fallback": "Valore di fallback" // Opzionale
+      }
+    }
+  }
+}
+```
+
+In questo esempio, `enu` mappa varie condizioni a contenuti specifici. Quando utilizzato in un componente React, Intlayer può scegliere automaticamente il contenuto appropriato in base alla variabile fornita.
+
+> L'ordine di dichiarazione è importante nelle enumerazioni di Intlayer. La prima dichiarazione valida è quella che verrà selezionata. Se si applicano più condizioni, assicurati che siano ordinate correttamente per evitare comportamenti inaspettati.
+
+> Se non viene dichiarato un valore di fallback, la funzione restituirà `undefined` se nessuna chiave corrisponde.
+
+## Utilizzo dell'Enumerazione con React Intlayer
+
+Per utilizzare l'enumerazione in un componente React, puoi sfruttare il hook `useIntlayer` del pacchetto `react-intlayer`. Questo hook recupera il contenuto corretto in base all'ID specificato. Ecco un esempio di come usarlo:
+
+```tsx fileName="**/*.tsx" codeFormat="typescript"
+import type { FC } from "react";
+import { useIntlayer } from "react-intlayer";
+
+const CarComponent: FC = () => {
+  const { numberOfCar } = useIntlayer("car_count");
+
+  return (
+    <div>
+      <p>
+        {
+          numberOfCar(0) // Output: Nessuna macchina
+        }
+      </p>
+      <p>
+        {
+          numberOfCar(6) // Output: Alcune macchine
+        }
+      </p>
+      <p>
+        {
+          numberOfCar(20) // Output: Molte macchine
+        }
+      </p>
+      <p>
+        {
+          numberOfCar(0.01) // Output: Valore di fallback
+        }
+      </p>
+    </div>
+  );
+};
+```
+
+```javascript fileName="**/*.mjx" codeFormat="esm"
+import { useIntlayer } from "react-intlayer";
+
+const CarComponent = () => {
+  const { numberOfCar } = useIntlayer("car_count");
+
+  return (
+    <div>
+      <p>
+        {
+          numberOfCar(0) // Output: Nessuna macchina
+        }
+      </p>
+      <p>
+        {
+          numberOfCar(6) // Output: Alcune macchine
+        }
+      </p>
+      <p>
+        {
+          numberOfCar(20) // Output: Molte macchine
+        }
+      </p>
+      <p>
+        {
+          numberOfCar(0.01) // Output: Valore di fallback
+        }
+      </p>
+    </div>
+  );
+};
+
+export default CarComponent;
+```
+
+```javascript fileName="**/*.cjs" codeFormat="commonjs"
+const { useIntlayer } = require("react-intlayer");
+
+const CarComponent = () => {
+  const { numberOfCar } = useIntlayer("car_count");
+
+  return (
+    <div>
+      <p>
+        {
+          numberOfCar(0) // Output: Nessuna macchina
+        }
+      </p>
+      <p>
+        {
+          numberOfCar(6) // Output: Alcune macchine
+        }
+      </p>
+      <p>
+        {
+          numberOfCar(20) // Output: Molte macchine
+        }
+      </p>
+      <p>
+        {
+          numberOfCar(0.01) // Output: Valore di fallback
+        }
+      </p>
+    </div>
+  );
+};
+
+module.exports = CarComponent;
+```
+
+In questo esempio, il componente regola dinamicamente il suo output in base al numero di macchine. Il contenuto corretto viene scelto automaticamente, a seconda dell'intervallo specificato.
+
+## Risorse Aggiuntive
+
+Per informazioni più dettagliate sulla configurazione e sull'utilizzo, consulta le seguenti risorse:
+
+- [Documentazione CLI di Intlayer](https://github.com/aymericzip/intlayer/blob/main/docs/it/intlayer_cli.md)
+- [Documentazione React Intlayer](https://github.com/aymericzip/intlayer/blob/main/docs/it/intlayer_with_create_react_app.md)
+- [Documentazione Next Intlayer](https://github.com/aymericzip/intlayer/blob/main/docs/it/intlayer_with_nextjs_15.md)
+
+Queste risorse forniscono ulteriori approfondimenti sulla configurazione e sull'utilizzo di Intlayer in diversi ambienti e con vari framework.