@intlayer/docs 9.3.3 → 9.4.0

package/docs/it/packages/intlayer/getIntlayer.md

@@ -0,0 +1,197 @@
+---
+createdAt: 2026-08-23
+updatedAt: 2026-08-23
+title: Documentazione della funzione getIntlayer | intlayer
+description: Scopri come utilizzare la funzione getIntlayer per il package intlayer
+keywords:
+  - getIntlayer
+  - dictionary
+  - content
+  - selector
+  - Intlayer
+  - intlayer
+  - Internationalization
+  - Documentation
+  - JavaScript
+  - TypeScript
+slugs:
+  - doc
+  - packages
+  - intlayer
+  - getIntlayer
+history:
+  - version: 9.4.0
+    date: 2026-08-23
+    changes: "Initial documentation"
+author: aymericzip
+---
+
+# Documentazione: Funzione `getIntlayer` in `intlayer`
+
+## Descrizione
+
+La funzione `getIntlayer` seleziona un dizionario dalla sua chiave e restituisce il suo contenuto interpretato per una determinata locale. È l'equivalente indipendente dal framework dell'hook `useIntlayer`: stesso contenuto, stessi selettori, ma utilizzabile ovunque un contesto React non sia disponibile — script Node, funzioni server, route loader, generatori di metadati, handler Express/Fastify, test.
+
+Legge i dizionari generati da Intlayer in `.intlayer/`, quindi l'argomento `key` è tipizzato e autocompleto dalle tue dichiarazioni di contenuto, e l'oggetto restituito è completamente tipizzato fino a ogni foglia.
+
+**Caratteristiche principali:**
+
+- Chiavi di dizionario tipizzate e contenuto restituito tipizzato
+- Interpreta ogni nodo di contenuto (`t()`, `enu()`, `cond()`, `insert()`, `nest()`, `md()`, `html()`, `file()`, `gender()`)
+- Accetta una locale o un oggetto selettore (collezioni, varianti)
+- I risultati sono memorizzati nella cache per `key + locale + selector`
+- Ricade su un proxy sicuro in sviluppo quando un dizionario è mancante, invece di bloccarsi
+
+---
+
+## Firma della Funzione
+
+```typescript
+getIntlayer(
+  key: DictionaryKeys,                        // Obbligatorio
+  localeOrSelector?: LocalesValues | DictionarySelector, // Opzionale
+  plugins?: Plugins[]                         // Opzionale
+): DeepTransformContent<...>
+```
+
+---
+
+## Parametri
+
+- `key: DictionaryKeys`
+  - **Description**: La chiave del dizionario da leggere, come dichiarato nei tuoi file di contenuto.
+  - **Type**: `DictionaryKeys` — un'unione di ogni chiave di dizionario dichiarata.
+  - **Required**: Yes
+
+- `localeOrSelector: LocalesValues | DictionarySelector`
+  - **Description**: La locale per interpretare il contenuto con, o un oggetto selettore per [dizionari dinamici](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/dynamic_dictionaries/index.md).
+    - `'fr'` — una locale
+    - `{ item: 2 }` — un elemento [collection](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/dynamic_dictionaries/collections.md) (ometti `item` per ottenere ogni elemento come array)
+    - `{ variant: 'black-friday' }` — un [variant](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/dynamic_dictionaries/variants.md) denominato (ometti per quello `default`)
+    - `{ variant: { id: 'prod_abc', userId: '123' } }` — un variant strutturato
+    - Qualsiasi selettore può portare una locale: `{ item: 2, locale: 'fr' }`
+  - **Type**: `LocalesValues | DictionarySelector`
+  - **Required**: No (Optional) — defaults to the configured `defaultLocale`.
+
+- `plugins: Plugins[]`
+  - **Description**: Custom node transformers che sostituiscono i plugin dell'interprete base. Solo uso avanzato; omettilo per mantenere il comportamento predefinito.
+  - **Type**: `Plugins[]`
+  - **Required**: No (Optional)
+
+### Restituzioni
+
+- **Type**: Il contenuto interpretato del dizionario, tipizzato dalla tua dichiarazione.
+- **Description**: Un oggetto semplice che rispecchia il campo `content` del tuo dizionario, dove ogni nodo Intlayer è stato risolto al suo valore finale per la locale richiesta.
+
+---
+
+## Esempio di utilizzo
+
+### Utilizzo di Base
+
+```typescript fileName="src/app.content.ts" codeFormat="typescript"
+import { t, type Dictionary } from "intlayer";
+
+const appContent = {
+  key: "app",
+  content: {
+    title: t({
+      it: "Ciao",
+      en: "Hello",
+      fr: "Bonjour",
+    }),
+  },
+} satisfies Dictionary;
+
+export default appContent;
+```
+
+```typescript codeFormat={["typescript", "esm", "commonjs"]}
+import { getIntlayer } from "intlayer";
+
+const { title } = getIntlayer("app", "it"); // "Ciao"
+```
+
+### Senza una locale
+
+Omettendo la locale il contenuto viene interpretato con la `defaultLocale` dichiarata nella tua [configurazione](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/configuration.md).
+
+```typescript
+import { getIntlayer } from "intlayer";
+
+const { title } = getIntlayer("app"); // Interpretato con la locale predefinita
+```
+
+### All'interno di un server handler
+
+```typescript fileName="src/routes/greeting.ts" codeFormat="typescript"
+import { getIntlayer, getLocale } from "intlayer";
+
+export const greetingHandler = async (request: Request) => {
+  const locale = await getLocale({
+    getHeader: (name) => request.headers.get(name) ?? undefined,
+  });
+
+  const { title } = getIntlayer("app", locale);
+
+  return Response.json({ title });
+};
+```
+
+### Con un selettore (collezioni e varianti)
+
+```typescript
+import { getIntlayer } from "intlayer";
+
+// Un singolo elemento della collezione
+const secondPost = getIntlayer("blog-post", { item: 2, locale: "fr" });
+
+// Ogni elemento della collezione, come un array ordinato
+const allPosts = getIntlayer("blog-post", { locale: "fr" });
+
+// Una variante denominata
+const banner = getIntlayer("banner", { variant: "black-friday", locale: "fr" });
+```
+
+---
+
+## Note sul comportamento
+
+### Caching
+
+I risultati sono memoizzati in una cache a livello di modulo con chiave `key + locale + selector`. Chiamare `getIntlayer("app", "fr")` ripetutamente interpreta il dizionario una sola volta e restituisce lo stesso oggetto in seguito.
+
+### Dizionari mancanti
+
+Durante lo sviluppo, richiedere una chiave che non ha un dizionario generato registra un avviso una volta e restituisce un proxy di fallback sicuro: leggere `content.title` produce la stringa `"app.title"` invece di generare un errore. Questo mantiene una pagina utilizzabile mentre la dichiarazione mancante viene corretta. Eseguire il build di Intlayer (o il server di sviluppo) affinché il dizionario sia generato.
+
+### Dimensione del bundle
+
+`getIntlayer` legge il dizionario unito, che contiene **ogni** locale. Nei bundle client, i [plugin di build](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/bundle_optimization.md) riscrivono la chiamata in modo che solo il contenuto richiesto venga spedito. Quando leggi contenuto al di fuori del rendering (metadata, loader, funzioni server) e vuoi che una singola locale sia caricata su richiesta, usa invece [`getIntlayerAsync`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/packages/intlayer/getIntlayerAsync.md).
+
+---
+
+## Funzioni Correlate
+
+- [`getIntlayerAsync`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/packages/intlayer/getIntlayerAsync.md): Controparte asincrona che carica un singolo chunk di locale.
+- [`getDictionary`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/packages/intlayer/getDictionary.md): Interpreta un oggetto dictionary che passi tu stesso, invece di uno cercato per chiave.
+- [`useIntlayer`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/packages/react-intlayer/useIntlayer.md): L'equivalente React hook, che legge il locale dal provider.
+
+---
+
+## TypeScript
+
+```typescript
+function getIntlayer<
+  const T extends DictionaryKeys,
+  const A extends LocalesValues | DictionarySelector = DeclaredLocales,
+>(
+  key: T,
+  localeOrSelector?: A,
+  plugins?: Plugins[]
+): DeepTransformContent<
+  DictionaryRegistryResult<T, A>,
+  IInterpreterPluginState,
+  ExtractSelectorLocale<A>
+>;
+```

package/docs/it/packages/intlayer/getIntlayerAsync.md

@@ -0,0 +1,141 @@
+---
+createdAt: 2026-08-23
+updatedAt: 2026-08-23
+title: getIntlayerAsync Function Documentation | intlayer
+description: See how to use the getIntlayerAsync function for intlayer package
+keywords:
+  - getIntlayerAsync
+  - dictionary
+  - dynamic import
+  - metadata
+  - bundle optimization
+  - Intlayer
+  - intlayer
+  - Internationalization
+  - Documentation
+  - JavaScript
+  - TypeScript
+slugs:
+  - doc
+  - packages
+  - intlayer
+  - getIntlayerAsync
+history:
+  - version: 9.4.0
+    date: 2026-08-23
+    changes: "Initial documentation"
+author: aymericzip
+---
+
+# Documentation: funzione `getIntlayerAsync` in `intlayer`
+
+## Descrizione
+
+La funzione `getIntlayerAsync` seleziona un dizionario in base alla sua chiave e risolve il suo contenuto per una determinata locale, **caricando solo quella locale**.
+
+È l'equivalente asincrono di [`getIntlayer`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/packages/intlayer/getIntlayer.md), destinato ai casi in cui un dizionario viene letto al di fuori del rendering — route `head` / metadata builders, loaders, server functions.
+
+Dove `getIntlayer` carica il dizionario unito contenente ogni locale, i [build plugins](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/bundle_optimization.md) (`@intlayer/babel`, `@intlayer/swc`) riscrivono questa chiamata in `getDictionaryAsync(loaderMap, key, locale)`, puntandola ai chunk per-locale in `.intlayer/dynamic_dictionaries/`. Il bundle quindi contiene solo la locale effettivamente richiesta.
+
+Senza questi plugin — una build non ottimizzata — la chiamata viene risolta attraverso il registro dizionario sincrono invece: lo stesso contenuto, senza la divisione per-locale.
+
+**Caratteristiche principali:**
+
+- Stesse chiavi tipizzate, selettori e contenuto restituito di `getIntlayer`
+- Carica solo il chunk della locale richiesta nelle build ottimizzate
+- Le chiamate concorrenti per lo stesso chunk condividono un singolo caricamento
+- Sicuro da usare in `async` metadata builders, loaders e server functions
+
+---
+
+## Firma della Funzione
+
+```typescript
+getIntlayerAsync(
+  key: DictionaryKeys,                        // Obbligatorio
+  localeOrSelector?: LocalesValues | DictionarySelector, // Opzionale
+  plugins?: Plugins[]                         // Opzionale
+): Promise<DeepTransformContent<...>>
+```
+
+---
+
+## Parametri
+
+- `key: DictionaryKeys`
+  - **Description**: La chiave del dizionario da leggere, come dichiarato nei tuoi file di contenuto.
+  - **Type**: `DictionaryKeys` — un'unione di ogni chiave di dizionario dichiarata.
+  - **Required**: Yes
+
+- `localeOrSelector: LocalesValues | DictionarySelector`
+  - **Description**: La locale per interpretare il contenuto, o un oggetto selector per [dizionari dinamici](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/dynamic_dictionaries/index.md).
+    - `'fr'` — una locale
+    - `{ item: 2 }` — un elemento di [collection](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/dynamic_dictionaries/collections.md) (ometti `item` per ottenere ogni elemento come array)
+    - `{ variant: 'black-friday' }` — un [variant](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/dynamic_dictionaries/variants.md) denominato (ometti per quello `default`)
+    - `{ variant: { id: 'prod_abc', userId: '123' } }` — una variante strutturata
+    - Qualsiasi selector può contenere una locale: `{ item: 2, locale: 'fr' }`
+  - **Type**: `LocalesValues | DictionarySelector`
+  - **Required**: No (Optional) — defaults to the configured `defaultLocale`.
+
+- `plugins: Plugins[]`
+  - **Description**: Custom node transformers che sostituiscono i plugin base dell'interprete. Uso avanzato soltanto.
+  - **Type**: `Plugins[]`
+  - **Required**: No (Optional)
+
+### Restituisce
+
+- **Type**: `Promise<Content>` — una promise che si risolve nel contenuto interpretato del dizionario, tipizzato dalla tua dichiarazione.
+
+---
+
+## Esempio di utilizzo
+
+### Utilizzo di base
+
+```typescript codeFormat={["typescript", "esm", "commonjs"]}
+import { getIntlayerAsync } from "intlayer";
+
+const { title } = await getIntlayerAsync("app", "fr"); // "Bonjour"
+```
+
+---
+
+## `getIntlayer` vs `getIntlayerAsync`
+
+|                    | [`getIntlayer`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/packages/intlayer/getIntlayer.md) | `getIntlayerAsync`                                     |
+| ------------------ | --------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------ |
+| Returns            | Il contenuto                                                                                                    | Una promise del contenuto                              |
+| Dictionary loaded  | Il dizionario unito (tutte le lingue)                                                                           | Il chunk della lingua richiesta solamente              |
+| Best suited for    | Rendering, percorsi di codice sincroni                                                                          | Metadata, loaders, funzioni server                     |
+| Requires a plugin? | No                                                                                                              | No — la divisione per locale necessita i build plugins |
+
+Entrambi accettano gli stessi argomenti e restituiscono lo stesso contenuto: il cambio da uno all'altro cambia solo **quando** e **quanto** viene caricato.
+
+---
+
+## Funzioni Correlate
+
+- [`getIntlayer`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/packages/intlayer/getIntlayer.md): Equivalente sincrono che legge il dizionario unito.
+- [`getDictionaryAsync`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/packages/intlayer/getDictionaryAsync.md): La funzione di basso livello in cui i plugin di build riscrivono questa chiamata.
+- [`getLocale`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/packages/intlayer/getLocale.md): Rileva la locale di una richiesta in arrivo.
+
+---
+
+## TypeScript
+
+```typescript
+function getIntlayerAsync<
+  const T extends DictionaryKeys,
+  const A extends LocalesValues | DictionarySelector = DeclaredLocales,
+>(
+  key: T,
+  localeOrSelector?: A,
+  plugins?: Plugins[]
+): Promise<
+  DeepTransformContent<
+    DictionaryRegistryResult<T, A>,
+    IInterpreterPluginState,
+    ExtractSelectorLocale<A>
+  >
+>;
+```

package/docs/it/packages/intlayer/getLocalizedPath.md

@@ -31,6 +31,8 @@ author: aymericzip
 
 La funzione `getLocalizedPath` risolve un percorso canonico (percorso interno dell'applicazione) nella sua equivalente localizzata in base alla locale fornita e alle regole di riscrittura. È particolarmente utile per generare URL SEO-friendly che variano in base alla lingua.
 
+È l'equivalente relativo di [`getLocalizedUrl`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/packages/intlayer/getLocalizedUrl.md) — per un input relativo entrambi restituiscono lo stesso valore. A differenza di `getLocalizedUrl`, non restituisce mai un URL assoluto: la configurazione `domains` viene ignorata, quindi una locale servita dal suo proprio dominio restituisce comunque un percorso. Un input assoluto è accettato, ma la sua origine viene scartata — solo il percorso, la query string e l'hash vengono mantenuti.
+
 **Caratteristiche principali:**
 
 - Supporta parametri di route dinamiche usando la sintassi `[param]`.
@@ -60,18 +62,23 @@ getLocalizedPath(
   - **Tipo**: `string`
   - **Obbligatorio**: Sì
 
-- `locale: Locales`
-  - **Descrizione**: La locale di destinazione per la quale il percorso deve essere localizzato.
-  - **Tipo**: `Locales`
-  - **Obbligatorio**: Sì
-
 ### Parametri opzionali
 
+- `locale?: Locales`
+  - **Description**: La locale target per la quale il percorso dovrebbe essere localizzato.
+  - **Type**: `Locales`
+  - **Default**: La locale predefinita della configurazione del tuo progetto.
+
 - `rewriteRules?: RoutingConfig['rewrite']`
   - **Descrizione**: Un oggetto che definisce regole di riscrittura personalizzate. Se non fornito, assume per default la proprietà `routing.rewrite` dalla configurazione del progetto.
   - **Tipo**: `RoutingConfig['rewrite']`
   - **Default**: `configuration.routing.rewrite`
 
+  - `options.locales?: Locales[]` — locale supportati. **Default**: `configuration.internationalization.locales`
+  - `options.defaultLocale?: Locales` — la locale predefinita. **Default**: `configuration.internationalization.defaultLocale`
+  - `options.mode?: 'prefix-no-default' | 'prefix-all' | 'no-prefix' | 'search-params'` — come la locale appare nel percorso. **Default**: `configuration.routing.mode`
+  - `options.rewrite?: RoutingConfig['rewrite']` — regole di riscrittura personalizzate. **Default**: `configuration.routing.rewrite`
+
 ---
 
 ## Restituisce
@@ -79,6 +86,28 @@ getLocalizedPath(
 - **Tipo**: `string`
 - **Descrizione**: Il percorso localizzato per la locale specificata.
 
+Il tipo è ristretto dalle regole di riscrittura dichiarate nella tua configurazione, quindi l'editor mostra il percorso risolto anziché una semplice `string`:
+
+```typescript codeFormat="typescript"
+// Configurazione: mode 'prefix-no-default', defaultLocale 'en',
+//                { '/about': { fr: '/a-propos' }, '/product/[id]': { fr: '/produit/[id]' } }
+const about = getLocalizedPath("/about", Locales.FRENCH);
+//    ^? '/fr/a-propos'
+const product = getLocalizedPath("/product/123", Locales.FRENCH);
+//    ^? '/fr/produit/123'
+const contact = getLocalizedPath("/contact", Locales.FRENCH);
+//    ^? '/fr/contact'  (nessuna regola di riscrittura corrisponde, viene applicato solo il prefisso)
+const home = getLocalizedPath("/", Locales.FRENCH);
+//    ^? '/fr'
+```
+
+Lo stesso narrowing fluisce in [`getLocalizedUrl`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/packages/intlayer/getLocalizedUrl.md), che applica le regole di riscrittura prima di prefissare la locale.
+
+Due to que i casi rimangono allargati a `string`, perché non possono essere risolti al momento della compilazione:
+
+- un percorso che non è un string literal (ad es. uno costruito da una variabile);
+- un percorso che corrisponde a una regola usando un parametro multi-segmento o opzionale (`[...slug]`, `[[...slug]]`, `:param?`).
+
 ---
 
 ## Esempio d'uso
@@ -126,6 +155,18 @@ getLocalizedPath("/contact", Locales.FRENCH, manualRules);
 // Risultato: "/contactez-nous"
 ```
 
+### Omissione della Locale
+
+Quando non viene fornita alcuna locale, il percorso viene localizzato per la locale predefinita configurata:
+
+```typescript codeFormat="typescript"
+import { getLocalizedPath } from "intlayer";
+
+// Configuration: defaultLocale = Locales.ENGLISH, { '/about': { en: '/about', fr: '/a-propos' } }
+getLocalizedPath("/about");
+// Output: "/about"
+```
+
 ---
 
 ## Funzioni correlate

package/docs/it/packages/intlayer/getLocalizedUrl.md

@@ -143,36 +143,6 @@ getLocalizedUrl(
 // Output: "/about" per la locale predefinita (inglese)
 ```
 
-```javascript codeFormat="esm"
-import { getLocalizedUrl, Locales } from "intlayer";
-
-getLocalizedUrl(
-  "/about",
-  Locales.FRENCH,
-  [Locales.ENGLISH, Locales.FRENCH],
-  Locales.ENGLISH,
-  false
-);
-
-// Output: "/fr/about" per la locale francese
-// Output: "/about" per la locale predefinita (inglese)
-```
-
-```javascript codeFormat="commonjs"
-const { getLocalizedUrl, Locales } = require("intlayer");
-
-getLocalizedUrl(
-  "/about",
-  Locales.FRENCH,
-  [Locales.ENGLISH, Locales.FRENCH],
-  Locales.ENGLISH,
-  false
-);
-
-// Output: "/fr/about" per la locale francese
-// Output: "/about" per la locale predefinita (inglese)
-```
-
 ### Override parziale della configurazione
 
 Puoi fornire anche solo alcuni dei parametri opzionali. La funzione utilizzerà la configurazione del tuo progetto per qualsiasi parametro non specificato:
@@ -249,6 +219,12 @@ getLocalizedUrl(
 - **Lingue non supportate:**
   - Per le lingue non elencate in `locales`, la funzione non applica alcun prefisso.
 
+- **Modalità di Routing:**
+  - `'prefix-no-default'`: La locale predefinita non ha prefisso, le altre sì (es. `/about`, `/fr/about`)
+  - `'prefix-all'`: Tutte le locale hanno prefissi (es. `/en/about`, `/fr/about`)
+  - `'no-prefix'`: Nessun prefisso di locale negli URL (locale gestita altrove)
+  - `'search-params'`: Locale specificata tramite parametro di query (es. `/about?locale=fr`)
+
 ---
 
 ## Utilizzo nelle Applicazioni

package/docs/it/packages/intlayer/getMultilingualUrls.md

@@ -31,6 +31,14 @@ author: aymericzip
 
 La funzione `getMultilingualUrls` genera una mappatura di URL multilingue aggiungendo un prefisso all'URL fornito con ciascuna delle lingue supportate. Può gestire sia URL assoluti che relativi, applicando il prefisso della lingua appropriata in base alla configurazione fornita o ai valori predefiniti.
 
+**Caratteristiche principali:**
+
+- È richiesto solo 1 parametro: `url`
+- Oggetto `options` opzionale con `locales`, `defaultLocale` e `mode`
+- Utilizza la configurazione di internazionalizzazione del tuo progetto come impostazioni predefinite
+- Supporta più modalità di routing: `prefix-no-default`, `prefix-all`, `no-prefix` e `search-params`
+- Restituisce un oggetto di mapping con tutte le locale come chiavi e i loro URL corrispondenti come valori
+
 ---
 
 ## Firma della funzione
@@ -139,8 +147,6 @@ getMultilingualUrls(
 // }
 ```
 
----
-
 ### Modalità di Routing Diverse
 
 ```typescript
@@ -206,6 +212,12 @@ getMultilingualUrls("/dashboard", {
 - **Localizzazioni Non Supportate:**
   - Solo le localizzazioni fornite nell'array `locales` sono considerate per la generazione degli URL.
 
+- **Modalità di Routing:**
+  - `'prefix-no-default'`: La locale predefinita non ha prefisso, le altre sì (es. `/dashboard`, `/fr/dashboard`)
+  - `'prefix-all'`: Tutte le locale hanno prefissi (es. `/en/dashboard`, `/fr/dashboard`)
+  - `'no-prefix'`: Nessun prefisso di locale negli URL (tutte le locale restituiscono lo stesso URL)
+  - `'search-params'`: Locale specificata tramite parametro di query (es. `/dashboard?locale=fr`)
+
 ---
 
 ## Utilizzo nelle Applicazioni

package/docs/it/packages/intlayer/getTranslation.md

@@ -31,6 +31,8 @@ author: aymericzip
 
 La funzione `getTranslationContent` recupera il contenuto corrispondente a una specifica localizzazione da un insieme di contenuti linguistici personalizzabili. Se la localizzazione specificata non viene trovata, restituisce per impostazione predefinita il contenuto della localizzazione predefinita configurata nel progetto.
 
+Per maggiori dettagli su come dichiarare le traduzioni, consulta la [documentazione sulla traduzione](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/dictionary/translation.md).
+
 ## Parametri
 
 - `languageContent: CustomizableLanguageContent<Content>`

package/docs/it/packages/next-intlayer/t.md

@@ -102,37 +102,6 @@ export const ServerComponentExample: FC = () => (
 );
 ```
 
-###Traduzioni Inline negli Attributi
-
-La funzione `t` è particolarmente utile per le traduzioni inline negli attributi JSX.
-Quando si localizzano attributi come `alt`, `title`, `href` o `aria-label`, è possibile utilizzare `t` direttamente all'interno dell'attributo.
-
-```jsx
-<button
-  aria-label={t({
-    en: "Submit",
-    fr: "Soumettre",
-    es: "Enviar",
-  })}
->
-  {t({
-    en: "Submit",
-    fr: "Soumettre",
-    es: "Enviar",
-  })}
-  <img
-    src="/path/to/image"
-    alt={t({
-      en: "A beautiful scenery",
-      fr: "Un beau paysage",
-      es: "Un hermoso paisaje",
-    })}
-  />
-</button>
-```
-
----
-
 ### Traduzioni Inline negli Attributi
 
 La funzione `t` è particolarmente utile per le traduzioni inline negli attributi JSX.
@@ -192,6 +161,23 @@ In `next-intlayer`, la locale corrente è gestita tramite provider di contesto:
 
 #### Esempio:
 
+<Tabs>
+ <Tab label='Intlayer >=9.4' value='>=9.4'>
+
+```tsx codeFormat={["typescript", "esm", "commonjs"]}
+import type { FC, ReactNode } from "react";
+import type { Locales } from "intlayer";
+import { IntlayerProvider } from "next-intlayer/server";
+
+const Page: FC<{ locale: Locales; children: ReactNode }> = ({
+  locale,
+  children,
+}) => <IntlayerProvider locale={locale}>{children}</IntlayerProvider>;
+```
+
+ </Tab>
+ <Tab label='Intlayer <9.4' value='<9.4'>
+
 ```tsx codeFormat={["typescript", "esm", "commonjs"]}
 import type { FC } from "react";
 import type { Locales } from "intlayer";
@@ -207,6 +193,9 @@ const Page: FC<{ locale: Locales }> = ({ locale }) => (
 );
 ```
 
+</Tab>
+</Tabs>
+
 ---
 
 ## Errori Comuni e Risoluzione dei Problemi

package/docs/it/packages/next-intlayer/useIntlayer.md

@@ -79,6 +79,34 @@ Le istruzioni per configurare i file di dichiarazione del contenuto sono disponi
 
 Ecco come implementare il hook `useIntlayer` all'interno di una pagina Next.js per caricare dinamicamente contenuti localizzati in base alla locale corrente dell'applicazione:
 
+<Tabs>
+ <Tab label='Intlayer >=9.4' value='>=9.4'>
+
+```tsx fileName="src/pages/[locale]/index.tsx" codeFormat={["typescript", "esm"]}
+import { ClientComponentExample } from "@components/ClientComponentExample";
+import { ServerComponentExample } from "@components/ServerComponentExample";
+import { type NextPageIntlayer } from "next-intlayer";
+import { useIntlayer } from "next-intlayer";
+import { IntlayerProvider } from "next-intlayer/server";
+
+const HomePage: NextPageIntlayer = async ({ params }) => {
+  const { locale } = await params;
+
+  const content = useIntlayer("homepage", locale);
+
+  return (
+    <IntlayerProvider locale={locale}>
+      <p>{content.introduction}</p>
+      <ClientComponentExample />
+      <ServerComponentExample />
+    </IntlayerProvider>
+  );
+};
+```
+
+ </Tab>
+ <Tab label='Intlayer <9.4' value='<9.4'>
+
 ```tsx fileName="src/pages/[locale]/index.tsx" codeFormat={["typescript", "esm"]}
 import { ClientComponentExample } from "@components/ClientComponentExample";
 import { ServerComponentExample } from "@components/ServerComponentExample";
@@ -104,6 +132,9 @@ const HomePage: NextPageIntlayer = async ({ params }) => {
 };
 ```
 
+ </Tab>
+</Tabs>
+
 ```tsx fileName="src/components/ClientComponentExample.tsx" codeFormat={["typescript", "esm"]}
 "use-client";
 

package/docs/it/packages/next-intlayer/useLocale.md

@@ -104,6 +104,8 @@ L'hook `useLocale` accetta i seguenti parametri:
 
 ## Valori di Ritorno
 
+Quando invochi l'hook `useLocale`, restituisce un oggetto contenente le seguenti proprietà:
+
 - **`locale`**: La locale corrente come impostata nel contesto React.
 - **`defaultLocale`**: La locale primaria definita nella configurazione.
 - **`availableLocales`**: Una lista di tutte le localizzazioni disponibili come definite nella configurazione.

package/docs/it/packages/react-intlayer/useDictionary.md

@@ -30,8 +30,6 @@ L'hook `useDictionary` ti consente di elaborare un oggetto che assomiglia a un d
 
 ## Esempio di utilizzo in React
 
-Di seguito un esempio di come utilizzare l'hook `useDictionary` in un componente React:
-
 ```tsx fileName="./ComponentExample.tsx" codeFormat={["typescript", "esm"]}
 import type { FC } from "react";
 import { useDictionary } from "react-intlayer";