@intlayer/docs 9.5.4-canary.0 → 9.5.5

package/docs/it/intlayer_with_remix_3.md

@@ -1,6 +1,6 @@
 ---
 createdAt: 2026-09-09
-updatedAt: 2026-09-11
+updatedAt: 2026-09-19
 title: "Remix 3 i18n - Guida completa per tradurre la tua applicazione"
 description: "Dimentica i18next. La guida 2026 per creare un'applicazione Remix 3 multilingue (i18n). Traduci con agenti IA e ottimizza le dimensioni del bundle, la SEO e le prestazioni."
 keywords:
@@ -19,6 +19,9 @@ slugs:
 applicationTemplate: https://github.com/aymericzip/intlayer-remix-3-template
 applicationShowcase: https://intlayer-remix-3-template.vercel.app
 history:
+  - version: 9.5.5
+    date: 2026-09-19
+    changes: "Utilizzo del middleware e degli hook di remix-intlayer"
   - version: 9.5.0
     date: 2026-09-09
     changes: "Documentazione iniziale per Remix 3"
@@ -39,7 +42,7 @@ Questa guida illustra come integrare **Intlayer** per un'internazionalizzazione
 - **`remix/node-fetch-server`**: Adattatori server per Node.js, con supporto nativo per Bun, Deno e runtime edge.
 - **`remix/cookie`**: Parsing e serializzazione di cookie crittograficamente sicuri.
 
-In combinazione con **Intlayer**, ottieni un sistema completo di internazionalizzazione che garantisce sicurezza in fase di compilazione, traduzioni automatizzate con IA, rendering lato server a zero overhead e routing fluido per locale.
+Combinato con **Intlayer** e il pacchetto **`remix-intlayer`**, un middleware di locale più gli stessi hook `useIntlayer` / `useDictionary` / `useLocale` di `react-intlayer`, associati al contesto di richiesta di Remix, ottieni un sistema completo di internazionalizzazione che offre sicurezza in fase di compilazione, traduzioni automatizzate con IA, rendering lato server a zero overhead e routing fluido delle locali.
 
 ## Sommario
 
@@ -52,7 +55,7 @@ Rispetto alle soluzioni tradizionali come `i18next` o caricatori di traduzioni p
 <AccordionGroup>
 <Accordion header="Copertura completa di Remix 3 e degli standard web">
 
-Intlayer è progettato per funzionare nativamente con gli standard web (`Request`, `Response`, `Headers` e `URL`). Si integra perfettamente nel router Fetch di Remix 3 tramite un middleware leggero, estraendo i valori di lingua dai percorsi URL, dai cookie o dagli header `Accept-Language` senza vincolarti a un runtime specifico.
+Intlayer è progettato per funzionare in modo nativo con gli standard web (`Request`, `Response`, `Headers` e `URL`). `remix-intlayer` si integra nel router Fetch di Remix 3 come un middleware leggero, estraendo la locale dai percorsi URL, dai cookie o dalle intestazioni `Accept-Language` ed esponendola al resto della richiesta, handler, viste e componenti `remix/ui`, senza doverla passare manualmente né vincolarti a un runtime specifico.
 
 </Accordion>
 <Accordion header="Dichiarazioni di contenuto con sicurezza dei tipi">
@@ -109,25 +112,26 @@ Consulta il [Modello di Applicazione](https://github.com/aymericzip/intlayer-rem
 <Steps>
 <Step number={1} title="Installare le dipendenze">
 
-Installa `intlayer` e `remix` (versione 3) utilizzando il tuo gestore di pacchetti preferito:
+Installa `intlayer`, `remix-intlayer` e `remix` (versione 3) utilizzando il tuo gestore di pacchetti preferito:
 
 ```bash packageManager="npm"
-npm install intlayer remix@next
+npm install intlayer remix-intlayer remix@next
 ```
 
 ```bash packageManager="pnpm"
-pnpm add intlayer remix@next
+pnpm add intlayer remix-intlayer remix@next
 ```
 
 ```bash packageManager="yarn"
-yarn add intlayer remix@next
+yarn add intlayer remix-intlayer remix@next
 ```
 
 ```bash packageManager="bun"
-bun add intlayer remix@next
+bun add intlayer remix-intlayer remix@next
 ```
 
 - **`intlayer`**: Motore principale di internazionalizzazione per la gestione della configurazione, la dichiarazione dei dizionari (`t()`, `Dictionary`), gli strumenti CLI e l'interprete a runtime.
+- **`remix-intlayer`**: L'integrazione con Remix 3: il middleware router `intlayer()` che risolve la locale di ogni richiesta, e gli hook `useIntlayer`, `useDictionary` e `useLocale` che la leggono in qualunque punto successivo.
 - **`remix`**: Il pacchetto unificato del framework Remix 3 che esporta `remix/router`, `remix/routes`, `remix/ui`, `remix/middleware/render` e `remix/node-fetch-server`.
 
 </Step>
@@ -254,65 +258,30 @@ bun x intlayer build
 Ciò compila i tuoi contenuti nella directory degli artefatti `.intlayer`, offrendo completamento automatico completo in TypeScript e un rapido recupero dei dizionari.
 
 </Step>
-<Step number={5} title="Implementare il middleware Intlayer">
+<Step number={5} title="Aggiungere il middleware Intlayer">
 
 Remix 3 fornisce una pipeline di middleware componibile tramite `createRouter({ middleware: [...] })`.
 
-Crea un middleware Intlayer che risolve la lingua di ciascuna richiesta in entrata seguendo:
-
-1. Il prefisso del percorso URL tramite `getLocaleFromPath` di Intlayer (ad es. `/it` o `/fr`).
-2. L'utility `getLocale` di Intlayer, che negozia automaticamente attraverso i cookie di memoria (`INTLAYER_LOCALE`), header personalizzati (`x-intlayer-locale`), header standard `Accept-Language` e la tua `defaultLocale`.
-
-```typescript fileName="src/middleware/intlayer.ts" codeFormat={["typescript", "esm"]}
-import {
-  defaultLocale,
-  getCookie,
-  getLocale,
-  getLocaleFromPath,
-  type Locale,
-} from "intlayer";
-import { createContextKey, type Middleware } from "remix/router";
-
-/**
- * Chiave di contesto con sicurezza dei tipi per recuperare la lingua risolta dal RequestContext di Remix 3.
- */
-export const localeKey = createContextKey<Locale>(defaultLocale);
-
-/**
- * Middleware Intlayer per Remix 3.
- *
- * Risolve la lingua della richiesta secondo la seguente priorità:
- * 1. Prefisso del percorso URL (es. `/it/...`) tramite `getLocaleFromPath`
- * 2. Negoziazione di header e cookie tramite `getLocale` (cookie, header personalizzato, Accept-Language, fallback defaultLocale)
- *
- * Associa la lingua risolta al RequestContext di Remix 3.
- */
-export const intlayer = (): Middleware => {
-  return async (context, next) => {
-    // Rilevamento percorso (/it/about -> "it", /about -> undefined)
-    const pathLocale = getLocaleFromPath(context.url.pathname);
-
-    if (pathLocale) {
-      // Assegna la lingua risolta al contesto di richiesta di Remix 3
-      context.set(localeKey, pathLocale);
-
-      return next();
-    }
-
-    const storedLocale = await getLocale({
-      getHeader: (name) => context.headers.get(name),
-      getCookie: (name) =>
-        getCookie(name, context.headers.get("cookie") ?? undefined),
-    });
-
-    // Assegna la lingua risolta al contesto di richiesta di Remix 3
-    context.set(localeKey, storedLocale ?? defaultLocale);
-
-    return next();
-  };
-};
+`remix-intlayer` fornisce il middleware `intlayer()`. Per ogni richiesta in entrata risolve la locale utilizzando:
+
+1. L'URL, in ogni modalità di routing tranne `no-prefix`: il prefisso del percorso (es. `/it` o `/fr`) o il parametro di ricerca `?locale=`.
+2. La locale memorizzata dal client: il cookie di archiviazione (`INTLAYER_LOCALE`) o l'intestazione personalizzata (`x-intlayer-locale`).
+3. La negoziazione standard di `Accept-Language`, ricorrendo alla tua `defaultLocale` configurata.
+
+Il risultato viene memorizzato nel contesto di richiesta di Remix come `context.intlayer` (o `context.get(Intlayer)`), con `locale`, `defaultLocale` e `availableLocales`. Il middleware esegue quindi il resto della richiesta all'interno di un ambito `AsyncLocalStorage` associato a tale contesto, consentendo agli hook del pacchetto di leggere la locale senza argomenti, sia nei gestori di route che nelle viste e nei componenti `remix/ui`:
+
+```typescript
+import { useIntlayer, useLocale } from "remix-intlayer";
+
+// Ovunque a valle del middleware
+const { locale, availableLocales } = useLocale();
+const { title } = useIntlayer("home");
 ```
 
+`useIntlayer("home", "fr")` o `useIntlayer("faq", { item: 2 })` sovrascrivono la locale della richiesta per una singola chiamata, e `useDictionary(homeContent)` legge un dizionario importato anziché una chiave. Al di fuori di una richiesta, gli hook ricorrono alla locale predefinita.
+
+> Il middleware prepara anche i dizionari Intlayer all'avvio del server, in modo che un `intlayer build` mancante non lasci il registro vuoto.
+
 </Step>
 <Step number={6} title="Definire route con sicurezza dei tipi">
 
@@ -342,20 +311,21 @@ routes.localizedHome.href({ locale: "it" }); // "/it"
 
 Remix 3 esegue il rendering dell'interfaccia utente con componenti JSX provenienti da `remix/ui`. Un componente è una **funzione di setup** che riceve un `Handle` e restituisce una **funzione di render**. Il setup viene eseguito una sola volta per istanza, il render viene eseguito a ogni aggiornamento e le props vengono lette tramite `handle.props`.
 
-Inizia con una shell condivisa `Document` che imposta gli attributi `<html lang="..." dir="...">` a partire dalla lingua risolta:
+Inizia con un guscio condiviso `Document` che imposta gli attributi `<html lang="..." dir="...">` dalla locale risolta dal middleware:
 
 ```tsx fileName="src/views/document.tsx" codeFormat={["typescript", "esm"]}
-import { getHTMLTextDir, type Locale } from "intlayer";
+import { getHTMLTextDir } from "intlayer";
+import { useLocale } from "remix-intlayer";
 import type { Handle, RemixNode } from "remix/ui";
 
 type DocumentProps = {
-  locale: Locale;
   title: string;
   children?: RemixNode;
 };
 
 export const Document = (handle: Handle<DocumentProps>) => () => {
-  const { locale, title, children } = handle.props;
+  const { title, children } = handle.props;
+  const { locale } = useLocale();
 
   return (
     <html lang={locale} dir={getHTMLTextDir(locale)}>
@@ -370,47 +340,40 @@ export const Document = (handle: Handle<DocumentProps>) => () => {
 };
 ```
 
-Crea quindi la pagina iniziale. Estrae il dizionario localizzato con `getIntlayer` e mostra un selettore di lingua:
+Poi crea la pagina home. Legge il dizionario localizzato con `useIntlayer` e mostra un selettore di lingua:
 
 ```tsx fileName="src/views/home.tsx" codeFormat={["typescript", "esm"]}
-import {
-  getIntlayer,
-  getLocaleName,
-  getLocalizedPath,
-  type Locale,
-  locales,
-} from "intlayer";
-import type { Handle } from "remix/ui";
-import { routes } from "../routes";
+import { getLocaleName, getLocalizedUrl, getPathWithoutLocale } from "intlayer";
+import { useIntlayer, useLocale } from "remix-intlayer";
 import { Document } from "./document";
 
-type HomePageProps = {
-  locale: Locale;
-};
-
-export const HomePage = (handle: Handle<HomePageProps>) => () => {
-  const { locale } = handle.props;
-  const home = getIntlayer("home", locale);
+export const HomePage = () => () => {
+  const { locale, availableLocales } = useLocale();
+  const home = useIntlayer("home");
+  const pathWithoutLocale = getPathWithoutLocale();
 
   return (
-    <Document locale={locale} title={home.title}>
+    <Document title={home.title}>
       <header>
         <nav aria-label="Languages">
           <span>{home.switchLanguage}</span>
-          {locales.map((targetLocale) => {
-            const isActive = targetLocale === locale;
-
-            return (
-              <a
-                key={targetLocale}
-                href={getLocalizedPath(routes.home.href(), targetLocale)}
-                class={isActive ? "active" : undefined}
-                aria-current={isActive ? "page" : undefined}
-              >
-                {getLocaleName(targetLocale, locale)}
-              </a>
-            );
-          })}
+          <ul>
+            {availableLocales.map((localeItem) => {
+              const isActive = localeItem === locale;
+
+              return (
+                <li key={localeItem} class="p-1">
+                  <a
+                    href={getLocalizedUrl(pathWithoutLocale, localeItem)}
+                    class={isActive ? "active" : undefined}
+                    aria-current={isActive ? "page" : undefined}
+                  >
+                    {getLocaleName(localeItem, locale)}
+                  </a>
+                </li>
+              );
+            })}
+          </ul>
         </nav>
       </header>
       <main>
@@ -422,7 +385,7 @@ export const HomePage = (handle: Handle<HomePageProps>) => () => {
 };
 ```
 
-> Il JSX di Remix non è React: non ci sono hook, `class` viene scritto così com'è (è accettato anche `className`) e i re-render vengono attivati esplicitamente con `handle.update()`. I valori interpolati vengono sottoposti automaticamente a escaping.
+> JSX in Remix non è React: `class` si scrive così com'è (`className` è comunque accettato) e i nuovi rendering vengono attivati esplicitamente con `handle.update()`. I valori interpolati vengono sottoposti a escape automaticamente. Gli hook Intlayer sono semplici funzioni che leggono l'ambito della richiesta, quindi possono essere chiamati sia dalla funzione di setup che da quella di rendering.
 
 </Step>
 <Step number={8} title="Collegare il router e il server">
@@ -431,39 +394,37 @@ Aggiungi il middleware `render()` di `remix/middleware/render` accanto al middle
 
 ```tsx fileName="src/router.tsx" codeFormat={["typescript", "esm"]}
 import { isDeclaredLocale } from "intlayer";
+import { intlayer } from "remix-intlayer";
 import { render } from "remix/middleware/render";
 import { createRouter } from "remix/router";
-import { intlayer, localeKey } from "./middleware/intlayer";
 import { routes } from "./routes";
 import { HomePage } from "./views/home";
 
-// 1. Inizializzare il router con i middleware Intlayer + render
+// 1. Initialize router with Intlayer + render middleware
 export const router = createRouter({
   middleware: [intlayer(), render()],
 });
 
-// 2. Mappare i gestori di route
+// 2. Map route handlers
 router.map(routes, {
   actions: {
-    // Route per la lingua predefinita
+    // Default locale route
     home(context) {
-      const locale = context.get(localeKey);
-      return context.render(<HomePage locale={locale} />);
+      return context.render(<HomePage />);
     },
 
-    // Route localizzata
+    // Localized route
     localizedHome(context) {
       if (!isDeclaredLocale(context.params.locale)) {
         return new Response("Not Found", { status: 404 });
       }
-      const locale = context.get(localeKey);
-      return context.render(<HomePage locale={locale} />);
+      return context.render(<HomePage />);
     },
   },
 });
 ```
 
-> `context.render` accetta un `ResponseInit` opzionale come secondo argomento, ad es. `context.render(<NotFoundPage locale={locale} />, { status: 404 })`.
+> `context.render` accetta un `ResponseInit` opzionale come secondo argomento, ad es. `context.render(<NotFoundPage />, { status: 404 })`. La locale risolta rimane accessibile dall'handler come `context.intlayer.locale`, ad esempio per costruire una risposta `Response.json`.
 
 Infine, esponi il router tramite un gestore `fetch` standard. Lo stesso router funziona su Node.js, Bun, Deno e Cloudflare Workers:
 

package/docs/it/intlayer_with_tanstack+solid.md

@@ -1259,6 +1259,13 @@ Sì: [forme plurali](https://github.com/aymericzip/intlayer/blob/main/docs/docs/
 
 Attraverso l'[editor visivo](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/intlayer_visual_editor.md), che gira sulla tua infrastruttura e permette a chiunque di modificare il testo sul posto nell'app in esecuzione, o il [CMS](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/intlayer_CMS.md), che esternalizza il contenuto così può cambiare senza un deployment.
 
+</Question>
+<Question title="Qual è il costo dell'editor visuale? È eccessivo se non ne ho bisogno?">
+
+L'[editor visuale di Intlayer](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/intlayer_visual_editor.md) ha un **costo pari a zero** sulla tua applicazione se non viene configurato. La logica aggiuntiva viene caricata solo se esplicitamente abilitata e necessaria.
+
+Se abilitato, l'impatto è estremamente ridotto (+5 KB, caricato dinamicamente solo quando attivato) poiché la maggior parte della logica è gestita dal server editor su [app.intlayer.org](https://app.intlayer.org) o tramite il pacchetto `intlayer-editor`. Se hai solo bisogno di una soluzione di traduzione semplice senza editing visuale, Intlayer non aggiunge alcun overhead alla tua applicazione.
+
 </Question>
 <Question title="Intlayer è gratuito e open source?">
 

package/docs/it/intlayer_with_tanstack.md

@@ -1327,6 +1327,13 @@ Sì. Le dichiarazioni di contenuto supportano [forme plurali](https://github.com
 
 Attraverso l'[editor visivo](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/intlayer_visual_editor.md), che gira sulla tua infrastruttura e permette a chiunque di modificare il testo sul posto nel sito in esecuzione, o il [CMS](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/intlayer_CMS.md), che esternalizza il contenuto così può cambiare senza un deployment.
 
+</Question>
+<Question title="Qual è il costo dell'editor visuale? È eccessivo se non ne ho bisogno?">
+
+L'[editor visuale di Intlayer](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/intlayer_visual_editor.md) ha un **costo pari a zero** sulla tua applicazione se non viene configurato. La logica aggiuntiva viene caricata solo se esplicitamente abilitata e necessaria.
+
+Se abilitato, l'impatto è estremamente ridotto (+5 KB, caricato dinamicamente solo quando attivato) poiché la maggior parte della logica è gestita dal server editor su [app.intlayer.org](https://app.intlayer.org) o tramite il pacchetto `intlayer-editor`. Se hai solo bisogno di una soluzione di traduzione semplice senza editing visuale, Intlayer non aggiunge alcun overhead alla tua applicazione.
+
 </Question>
 <Question title="Intlayer è gratuito e open source?">
 

package/docs/it/intlayer_with_vite+preact.md

@@ -1121,6 +1121,13 @@ Sì: [forme plurali](https://github.com/aymericzip/intlayer/blob/main/docs/docs/
 
 Attraverso l'[editor visivo](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/intlayer_visual_editor.md), che gira sulla tua infrastruttura e permette a chiunque di modificare il testo sul posto nell'app in esecuzione, o il [CMS](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/intlayer_CMS.md), che esternalizza il contenuto così può cambiare senza un deployment.
 
+</Question>
+<Question title="Qual è il costo dell'editor visuale? È eccessivo se non ne ho bisogno?">
+
+L'[editor visuale di Intlayer](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/intlayer_visual_editor.md) ha un **costo pari a zero** sulla tua applicazione se non viene configurato. La logica aggiuntiva viene caricata solo se esplicitamente abilitata e necessaria.
+
+Se abilitato, l'impatto è estremamente ridotto (+5 KB, caricato dinamicamente solo quando attivato) poiché la maggior parte della logica è gestita dal server editor su [app.intlayer.org](https://app.intlayer.org) o tramite il pacchetto `intlayer-editor`. Se hai solo bisogno di una soluzione di traduzione semplice senza editing visuale, Intlayer non aggiunge alcun overhead alla tua applicazione.
+
 </Question>
 <Question title="Intlayer è gratuito e open source?">
 

package/docs/it/intlayer_with_vite+react.md

@@ -1068,6 +1068,13 @@ Sì: [forme plurali](https://github.com/aymericzip/intlayer/blob/main/docs/docs/
 
 Attraverso l'[editor visivo](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/intlayer_visual_editor.md), auto-ospitato, che permette a chiunque di modificare il testo sul posto nell'app in esecuzione, o il [CMS](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/intlayer_CMS.md) per il contenuto che deve cambiare senza un deployment.
 
+</Question>
+<Question title="Qual è il costo dell'editor visuale? È eccessivo se non ne ho bisogno?">
+
+L'[editor visuale di Intlayer](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/intlayer_visual_editor.md) ha un **costo pari a zero** sulla tua applicazione se non viene configurato. La logica aggiuntiva viene caricata solo se esplicitamente abilitata e necessaria.
+
+Se abilitato, l'impatto è estremamente ridotto (+5 KB, caricato dinamicamente solo quando attivato) poiché la maggior parte della logica è gestita dal server editor su [app.intlayer.org](https://app.intlayer.org) o tramite il pacchetto `intlayer-editor`. Se hai solo bisogno di una soluzione di traduzione semplice senza editing visuale, Intlayer non aggiunge alcun overhead alla tua applicazione.
+
 </Question>
 <Question title="Intlayer è gratuito e open source?">
 

package/docs/it/intlayer_with_vite+solid.md

@@ -818,6 +818,13 @@ Sì: [forme plurali](https://github.com/aymericzip/intlayer/blob/main/docs/docs/
 
 Attraverso l'[editor visivo](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/intlayer_visual_editor.md), che gira sulla tua infrastruttura e permette a chiunque di modificare il testo sul posto nell'app in esecuzione, o il [CMS](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/intlayer_CMS.md), che esternalizza il contenuto così può cambiare senza un deployment.
 
+</Question>
+<Question title="Qual è il costo dell'editor visuale? È eccessivo se non ne ho bisogno?">
+
+L'[editor visuale di Intlayer](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/intlayer_visual_editor.md) ha un **costo pari a zero** sulla tua applicazione se non viene configurato. La logica aggiuntiva viene caricata solo se esplicitamente abilitata e necessaria.
+
+Se abilitato, l'impatto è estremamente ridotto (+5 KB, caricato dinamicamente solo quando attivato) poiché la maggior parte della logica è gestita dal server editor su [app.intlayer.org](https://app.intlayer.org) o tramite il pacchetto `intlayer-editor`. Se hai solo bisogno di una soluzione di traduzione semplice senza editing visuale, Intlayer non aggiunge alcun overhead alla tua applicazione.
+
 </Question>
 <Question title="Intlayer è gratuito e open source?">
 

package/docs/it/packages/astro-intlayer/exports.md

@@ -1,8 +1,8 @@
 ---
 createdAt: 2026-01-21
-updatedAt: 2026-01-21
+updatedAt: 2026-09-19
 title: Documentazione del pacchetto astro-intlayer
-description: Integrazione Astro per Intlayer, che fornisce la configurazione per il routing basato sulla locale e la gestione dei dizionari.
+description: Integrazione Astro per Intlayer, che fornisce configurazione per il routing basato su locale, middleware, hook, store client e gestione dei dizionari.
 keywords:
   - astro-intlayer
   - astro
@@ -14,6 +14,9 @@ slugs:
   - astro-intlayer
   - exports
 history:
+  - version: 9.5.5
+    date: 2026-09-19
+    changes: "Aggiunta documentazione degli hook useIntlayer, useDictionary, useLocale, del middleware e dei formattatori"
   - version: 8.0.0
     date: 2026-01-21
     changes: "Documentazione unificata per tutte le esportazioni"
@@ -22,7 +25,7 @@ author: aymericzip
 
 # Pacchetto astro-intlayer
 
-Il pacchetto `astro-intlayer` fornisce gli strumenti necessari per integrare Intlayer nelle applicazioni Astro. Configura il routing basato sulla locale e la gestione dei dizionari.
+Il pacchetto `astro-intlayer` fornisce gli strumenti necessari per integrare Intlayer nelle applicazioni Astro. Configura il routing basato su locale, la gestione dei dizionari, la riscrittura delle pagine in fase di compilazione, il middleware di richiesta e gli hook per accedere a contenuti multilingue sia nei componenti `.astro` renderizzati dal server sia negli script lato client.
 
 ## Installazione
 
@@ -34,22 +37,171 @@ npm install astro-intlayer
 
 ### Integrazione
 
-Il pacchetto `astro-intlayer` fornisce un'integrazione per Astro per configurare Intlayer nel tuo progetto.
+Il pacchetto `astro-intlayer` fornisce un'integrazione Astro che configura Intlayer nel tuo progetto.
 
 Importazione:
 
 ```tsx
-import "astro-intlayer";
+import { intlayer } from "astro-intlayer";
 ```
 
-oppure aggiungendolo a `astro.config.mjs`:
+o importazione predefinita in `astro.config.mjs`:
 
 ```ts
+import { defineConfig } from "astro/config";
+import intlayer from "astro-intlayer";
+
 export default defineConfig({
   integrations: [intlayer()],
 });
 ```
 
-| Funzione   | Descrizione                                                 |
-| ---------- | ----------------------------------------------------------- |
-| `intlayer` | Integrazione Astro che configura Intlayer nel tuo progetto. |
+| Funzione   | Descrizione                                                                                                                                                                                                          | Documentazione correlata                                                                                      |
+| ---------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------- |
+| `intlayer` | Integrazione Astro che prepara i dizionari, configura i plugin Vite (alias, proxy di routing, eliminazione), registra automaticamente il middleware di richiesta ed emette pagine pre-renderizzate su URL riscritti. | [intlayer](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/packages/astro-intlayer/intlayer.md) |
+
+### Hook (Server e Client)
+
+Importazione:
+
+```tsx
+import { useIntlayer, useDictionary, useLocale } from "astro-intlayer";
+```
+
+| Hook            | Descrizione                                                                                                                                                                                                  | Documentazione correlata                                                                                                |
+| --------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------- |
+| `useIntlayer`   | Seleziona un dizionario tramite la sua chiave e restituisce il suo contenuto localizzato. Nel frontmatter `.astro`, legge il locale di richiesta da `Astro.locals`. In `<script>`, legge dallo store client. | [useIntlayer](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/packages/astro-intlayer/useIntlayer.md)     |
+| `useDictionary` | Trasforma un oggetto dizionario e restituisce il contenuto per il locale risolto. Funziona nel frontmatter e negli script client.                                                                            | [useDictionary](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/packages/astro-intlayer/useDictionary.md) |
+| `useLocale`     | Restituisce il locale corrente, il locale predefinito, i locale disponibili e una funzione per aggiornare il locale.                                                                                         | [useLocale](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/packages/astro-intlayer/useLocale.md)         |
+
+### Middleware (astro-intlayer/middleware)
+
+Importazione:
+
+```tsx
+import { onRequest } from "astro-intlayer/middleware";
+```
+
+| Esportazione | Tipo                | Descrizione                                                                                                                                                                      | Documentazione correlata                                                                                        |
+| ------------ | ------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------- |
+| `onRequest`  | `MiddlewareHandler` | Middleware Astro che rileva il locale della richiesta e allega `Astro.locals.intlayer`. Registrato automaticamente da `intlayer()`, o importato manualmente per essere composto. | [onRequest](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/packages/astro-intlayer/onRequest.md) |
+
+### Utilità
+
+Importazione:
+
+```tsx
+import { getIntlayerLocals } from "astro-intlayer";
+```
+
+| Funzione            | Descrizione                                                                                                                              | Documentazione correlata |
+| ------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- | ------------------------ |
+| `getIntlayerLocals` | Funzione helper per recuperare l'oggetto `IntlayerLocals` corrente dall'ambito di archiviazione della richiesta fuori da `Astro.locals`. | -                        |
+
+### Utilità Client (astro-intlayer/client)
+
+Importazione:
+
+```tsx
+import {
+  useIntlayer,
+  useDictionary,
+  useDictionaryDynamic,
+  useLocale,
+  useLocaleStorage,
+  useLocaleCookie,
+  getIntlayer,
+  getDictionary,
+  installIntlayer,
+  setLocaleInStorage,
+  setLocaleCookie,
+  localeInStorage,
+  localeCookie,
+} from "astro-intlayer/client";
+```
+
+Quando importato nel browser o all'interno dei tag client `<script>`, `astro-intlayer` si mappa automaticamente su `astro-intlayer/client` (alimentato da `vanilla-intlayer`), fornendo getter di dizionario lato client, sottoscrittori dello store e strumenti di persistenza del locale.
+
+### Formattatori (astro-intlayer/format)
+
+Importazione:
+
+```tsx
+import {
+  useIntl,
+  useDate,
+  useNumber,
+  useCurrency,
+  usePercentage,
+  useRelativeTime,
+  useList,
+  useUnit,
+  useCompact,
+} from "astro-intlayer/format";
+```
+
+| Hook              | Descrizione                                                                                                            |
+| ----------------- | ---------------------------------------------------------------------------------------------------------------------- |
+| `useIntl`         | Restituisce un'istanza Intl associata al locale con funzionalità di memorizzazione nella cache e iscrizione.           |
+| `useDate`         | Restituisce una funzione di formattazione della data associata al locale corrente (`Intl.DateTimeFormat`).             |
+| `useNumber`       | Restituisce una funzione di formattazione numerica associata al locale corrente (`Intl.NumberFormat`).                 |
+| `useCurrency`     | Restituisce una funzione di formattazione della valuta associata al locale corrente.                                   |
+| `usePercentage`   | Restituisce una funzione di formattazione della percentuale associata al locale corrente.                              |
+| `useRelativeTime` | Restituisce una funzione di formattazione del tempo relativo associata al locale corrente (`Intl.RelativeTimeFormat`). |
+| `useList`         | Restituisce una funzione di formattazione di elenchi associata al locale corrente (`Intl.ListFormat`).                 |
+| `useUnit`         | Restituisce una funzione di formattazione delle unità associata al locale corrente.                                    |
+| `useCompact`      | Restituisce una funzione di formattazione numerica compatta associata al locale corrente (es. `1.5K`).                 |
+
+### Utilità HTML (astro-intlayer/html)
+
+Importazione:
+
+```tsx
+import { renderHTML, useHTML, useHTMLRenderer } from "astro-intlayer/html";
+```
+
+| Esportazione      | Tipo       | Descrizione                                                          |
+| ----------------- | ---------- | -------------------------------------------------------------------- |
+| `renderHTML`      | `Function` | Funzione di utilità autonoma per il rendering dei nodi HTML.         |
+| `useHTML`         | `Hook`     | Hook per ottenere il contesto e la configurazione del provider HTML. |
+| `useHTMLRenderer` | `Hook`     | Hook per ottenere una funzione di rendering HTML preconfigurata.     |
+
+### Utilità Markdown (astro-intlayer/markdown)
+
+Importazione:
+
+```tsx
+import {
+  compileMarkdown,
+  renderMarkdown,
+  parseMarkdown,
+  useMarkdown,
+  useMarkdownRenderer,
+} from "astro-intlayer/markdown";
+```
+
+| Esportazione          | Tipo       | Descrizione                                                          |
+| --------------------- | ---------- | -------------------------------------------------------------------- |
+| `compileMarkdown`     | `Function` | Compila stringhe markdown in una rappresentazione strutturata.       |
+| `renderMarkdown`      | `Function` | Renderizza il contenuto markdown in nodi di output.                  |
+| `parseMarkdown`       | `Function` | Analizza il contenuto markdown non elaborato in un AST.              |
+| `useMarkdown`         | `Hook`     | Hook per ottenere il contesto del provider markdown.                 |
+| `useMarkdownRenderer` | `Hook`     | Hook per ottenere una funzione di rendering Markdown preconfigurata. |
+
+### Tipi
+
+Importazione:
+
+```tsx
+import type {
+  IntlayerLocals,
+  UseLocaleProps,
+  UseLocaleResult,
+} from "astro-intlayer";
+```
+
+| Tipo              | Descrizione                                                                                             |
+| ----------------- | ------------------------------------------------------------------------------------------------------- |
+| `IntlayerLocals`  | L'oggetto allegato a `Astro.locals.intlayer` contenente `locale`, `defaultLocale` e `availableLocales`. |
+| `UseLocaleProps`  | Proprietà di configurazione opzionali accettate da `useLocale()`.                                       |
+| `UseLocaleResult` | Il tipo restituito da `useLocale()`, che fornisce proprietà del locale e metodi di aggiornamento.       |