@intlayer/docs 9.4.0-canary.0 → 9.4.0

package/docs/it/intlayer_with_vite+lit.md

@@ -109,6 +109,8 @@ Più di una semplice soluzione i18n, Intlayer fornisce un **[editor visivo](http
 
 ---
 
+Vedi [Application Template](https://github.com/aymericzip/intlayer-vite-lit-template) su GitHub.
+
 ## Guida passo-passo per configurare Intlayer in un'applicazione Vite e Lit
 
 <Steps>
@@ -478,6 +480,8 @@ Innanzitutto, aggiungi `intlayerProxy` alla tua configurazione Vite:
 
 > Nota che per utilizzare `intlayerProxy` in produzione, devi spostare `vite-intlayer` da `devDependencies` a `dependencies`.
 
+> A partire da Intlayer v9, `intlayerProxy()` è raggruppato direttamente nel plugin `intlayer()` e abilitato per impostazione predefinita tramite l'opzione `routing.enableProxy` (`true` per impostazione predefinita). Registrarlo separatamente come mostrato di seguito è ora facoltativo — viene mantenuto per la compatibilità con le versioni precedenti e per le configurazioni che necessitano di controllare l'ordine dei plugin. Imposta `routing.enableProxy: false` per rinunciare. Vedi le [note sulla versione v9](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/releases/v9.md).
+
 ```typescript {3,7} fileName="vite.config.ts" codeFormat={["typescript", "esm", "commonjs"]}
 import { defineConfig } from "vite";
 import { intlayer } from "vite-intlayer";

package/docs/it/intlayer_with_vite+preact.md

@@ -61,10 +61,6 @@ author: aymericzip
   </Tab>
 </Tabs>
 
-> Questo pacchetto è in fase di sviluppo. Consulta la [issue](https://github.com/aymericzip/intlayer/issues/118) per maggiori informazioni. Mostra il tuo interesse per Intlayer per Preact mettendo un like alla issue
-
-Consulta il [Template dell'Applicazione](https://github.com/aymericzip/intlayer-vite-preact-template) su GitHub.
-
 ## Table of Contents
 
 <TOC/>
@@ -122,6 +118,8 @@ Più di una semplice soluzione i18n, Intlayer fornisce un **[editor visivo](http
 
 ## Guida Passo-Passo per Configurare Intlayer in un'Applicazione Vite e Preact
 
+Vedi [Application Template](https://github.com/aymericzip/intlayer-vite-preact-template) su GitHub.
+
 <Steps>
 
 <Step number={1} title="Installa le Dipendenze">
@@ -516,6 +514,30 @@ const App: FunctionalComponent = () => (
 export default App;
 ```
 
+In parallelo, puoi anche utilizzare `intlayerProxy` per aggiungere il routing lato server alla tua applicazione. Questo plugin rileverà automaticamente la locale corrente in base all'URL e imposterà il cookie locale appropriato. Se non è specificata alcuna locale, il plugin determinerà la locale più appropriata in base alle preferenze della lingua del browser dell'utente. Se non viene rilevata alcuna locale, reindizzerà alla locale predefinita.
+
+> Nota che per utilizzare `intlayerProxy` in produzione, è necessario spostare il package `vite-intlayer` da `devDependencies` a `dependencies`.
+
+> A partire da Intlayer v9, `intlayerProxy()` è integrato direttamente nel plugin `intlayer()` e abilitato per impostazione predefinita tramite l'opzione `routing.enableProxy` (`true` per impostazione predefinita). Registrarlo separatamente come mostrato di seguito è ora opzionale — è mantenuto per compatibilità con le versioni precedenti e per setup che necessitano di controllare l'ordine dei plugin. Impostare `routing.enableProxy: false` per disattivarlo. Vedi le [note di rilascio v9](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/releases/v9.md).
+
+```typescript {3,7} fileName="vite.config.ts"
+import { defineConfig } from "vite";
+import { intlayer } from "vite-intlayer";
+import preact from "@preact/preset-vite";
+
+// https://vitejs.dev/config/
+export default defineConfig({
+  plugins: [
+    preact(),
+    intlayer({
+      proxy: {
+        ignore: (req) => req.url?.startsWith("/api"),
+      },
+    }),
+  ],
+});
+```
+
 </Step>
 
 <Step number={8} title="Cambia l'URL quando cambia la lingua" isOptional={true}>
@@ -592,6 +614,10 @@ export default LocaleSwitcher;
 >
 > > - [Hook `useLocale`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/packages/react-intlayer/useLocale.md) (l'API è simile per `preact-intlayer`)> - [Hook `getLocaleName`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/packages/intlayer/getLocaleName.md)> - [Hook `getLocalizedUrl`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/packages/intlayer/getLocalizedUrl.md)> - [Hook `getHTMLTextDir`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/packages/intlayer/getHTMLTextDir.md)> - [Attributo `hreflang`](https://developers.google.com/search/docs/specialty/international/localized-versions?hl=fr)> - [Attributo `lang`](https://developer.mozilla.org/it/docs/Web/HTML/Global_attributes/lang)> - [Attributo `dir`](https://developer.mozilla.org/it/docs/Web/HTML/Global_attributes/dir)> - [Attributo `aria-current`](https://developer.mozilla.org/it/docs/Web/Accessibility/ARIA/Attributes/aria-current)> - [API Popover](https://developer.mozilla.org/it/docs/Web/API/Popover_API)
 
+Di seguito è riportato il **Passaggio 9** aggiornato con spiegazioni aggiunte ed esempi di codice perfezionati:
+
+---
+
 </Step>
 
 <Step number={9} title="Cambia gli attributi HTML di lingua e direzione" isOptional={true}>
@@ -661,6 +687,12 @@ const App: FunctionalComponent = () => (
 export default App;
 ```
 
+Applicando questi cambiamenti, la tua applicazione:
+
+- Assicurati che l'attributo **language** (`lang`) rifletta correttamente la locale corrente, il che è importante per SEO e comportamento del browser.
+- Regola la **direzione del testo** (`dir`) in base alla locale, migliorando la leggibilità e l'usabilità per le lingue con ordini di lettura diversi.
+- Fornisci un'esperienza più **accessibile**, poiché le tecnologie assistive dipendono da questi attributi per funzionare in modo ottimale.
+
 </Step>
 
 <Step number={10} title="Creazione di un componente di collegamento localizzato" isOptional={true}>

package/docs/it/intlayer_with_vite+react.md

@@ -504,6 +504,8 @@ In parallelo, puoi anche utilizzare il `intlayerProxy` per aggiungere il routing
 
 > Nota che per usare `intlayerProxy` in produzione, devi spostare il pacchetto `vite-intlayer` da `devDependencies` a `dependencies`.
 
+> A partire da Intlayer v9, `intlayerProxy()` è incluso direttamente nel plugin `intlayer()` ed è abilitato per impostazione predefinita tramite l'opzione `routing.enableProxy` (`true` per impostazione predefinita). Registrarlo separatamente come mostrato di seguito è ora facoltativo — è mantenuto per la compatibilità con le versioni precedenti e per le configurazioni che necessitano di controllare l'ordine dei plugin. Impostare `routing.enableProxy: false` per disabilitarlo. Consulta le [note di rilascio della v9](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/releases/v9.md).
+
 ```typescript {3,7} fileName="vite.config.ts" codeFormat={["typescript", "esm", "commonjs"]}
 import { defineConfig } from "vite";
 import react from "@vitejs/plugin-react-swc";
@@ -741,13 +743,8 @@ export const Link = forwardRef<HTMLAnchorElement, LinkProps>(
 Link.displayName = "Link";
 ```
 
-- Funzione di utilità per verificare se un URL è esterno.
-- Se l'URL inizia con http:// o https://, è considerato esterno.
-
 #### Come funziona
 
-/\*\*
-
 - **Rilevamento dei link esterni**:  
   La funzione helper `checkIsExternalLink` determina se un URL è esterno. I link esterni vengono lasciati invariati perché non necessitano di localizzazione.
 
@@ -763,6 +760,8 @@ Link.displayName = "Link";
 Integrando questo componente `Link` in tutta la tua applicazione, mantieni un'esperienza utente coerente e consapevole della lingua, beneficiando inoltre di un miglior SEO e usabilità.
 </Step>
 
+</Step>
+
 <Step number={1} title="Estrarre il contenuto dei tuoi componenti" isOptional={true}>
 
 Se hai una base di codice esistente, trasformare migliaia di file può richiedere molto tempo.

package/docs/it/intlayer_with_vite+react_compiler.md

@@ -237,6 +237,8 @@ export default defineConfig({
 
 > Il plugin Vite `intlayerCompiler()` viene utilizzato per estrarre il contenuto dai componenti e scrivere i file `.content`.
 
+> A partire da Intlayer v9, il compiler è integrato direttamente nel plugin `intlayer()` e si attiva automaticamente quando `compiler.enabled` è impostato con un percorso `compiler.output`. Registrare `intlayerCompiler()` separatamente come mostrato di seguito è ora facoltativo — si deduplica automaticamente se aggiunto. Vedi le [note sulla versione v9](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/releases/v9.md).
+
 </Step>
 
 <Step number={4} title="Compilare il Codice">

package/docs/it/intlayer_with_vite+solid.md

@@ -46,6 +46,17 @@ author: aymericzip
   loading="lazy"
 />
 
+  </Tab>
+  <Tab label="Demo" value="demo">
+
+<iframe
+  src="https://intlayer-vite-solid.vercel.app"
+  className="m-auto overflow-hidden rounded-lg border-0 max-md:size-full max-md:h-[700px] md:aspect-16/9 md:w-full"
+  title="Demo Intlayer Vite + Solid Template"
+  sandbox="allow-forms allow-modals allow-popups allow-presentation allow-same-origin allow-scripts"
+  loading="lazy"
+/>
+
   </Tab>
 </Tabs>
 
@@ -53,10 +64,6 @@ author: aymericzip
 
 <TOC/>
 
-> Questo pacchetto è in fase di sviluppo. Consulta la [issue](https://github.com/aymericzip/intlayer/issues/117) per maggiori informazioni. Mostra il tuo interesse per Intlayer per Solid mettendo un like alla issue
-
-<!-- Vedi il [Template dell'Applicazione](https://github.com/aymericzip/intlayer-solid-template) su GitHub. -->
-
 ## Perché Intlayer rispetto alle alternative?
 
 Rispetto alle soluzioni principali come `@solid-primitives/i18n` o `i18next`, Intlayer è una soluzione dotata di ottimizzazioni integrate come:
@@ -164,10 +171,6 @@ bun add vite-intlayer --dev
 
   Il pacchetto principale che fornisce strumenti di internazionalizzazione per la gestione della configurazione, la traduzione, la [dichiarazione dei contenuti](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/dictionary/content_file.md), la traspilazione e i [comandi CLI](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/cli/index.md).
 
-- **solid-intlayer**
-
-  Il pacchetto che integra Intlayer con l'applicazione Solid. Fornisce provider di contesto e hook per l'internazionalizzazione in Solid.
-
 - **vite-intlayer**
 
   Include il plugin Vite per integrare Intlayer con il [bundler Vite](https://vite.dev/guide/why.html#why-bundle-for-production), oltre a middleware per rilevare la lingua preferita dall'utente, gestire i cookie e gestire il reindirizzamento degli URL.
@@ -244,8 +247,6 @@ export default appContent;
 
 > Le dichiarazioni di contenuto possono essere definite ovunque nella tua applicazione non appena vengono incluse nella directory `contentDir` (di default, `./src`). E devono corrispondere all'estensione del file di dichiarazione del contenuto (di default, `.content.{json,ts,tsx,js,jsx,mjs,cjs,md,mdx,yaml,yml}`).
 
-> Per maggiori dettagli, consulta la [documentazione sulla dichiarazione del contenuto](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/dictionary/content_file.md).
-
 </Step>
 
 <Step number={5} title="Utilizzare Intlayer nel tuo codice">
@@ -493,29 +494,10 @@ export const Link: ParentComponent<AnchorProps> = (props) => {
 };
 ```
 
-</Step>
-
 <Step number={11} title="Renderizzare Markdown" isOptional={true}>
 
 Intlayer supporta il rendering del contenuto Markdown direttamente nella tua applicazione Solid usando il suo parser interno. Per impostazione predefinita, Markdown è trattato come testo normale. Per renderizzarlo come HTML ricco, avvolgi la tua applicazione con il `MarkdownProvider`.
 
-```tsx fileName="src/index.tsx"
-import { render } from "solid-js/web";
-import { MarkdownProvider } from "solid-intlayer/markdown";
-import App from "./App";
-
-const root = document.getElementById("root");
-
-render(
-  () => (
-    <MarkdownProvider>
-      <App />
-    </MarkdownProvider>
-  ),
-  root!
-);
-```
-
 Poi puoi usarlo nei tuoi componenti:
 
 ```tsx
@@ -745,5 +727,3 @@ Per migliorare la tua esperienza di sviluppo con Intlayer, puoi installare l'**E
 ### Approfondimenti
 
 Per approfondire, puoi implementare l'[editor visuale](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/intlayer_visual_editor.md) o esternalizzare i tuoi contenuti utilizzando il [CMS](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/intlayer_CMS.md).
-
----

package/docs/it/intlayer_with_vite+svelte.md

@@ -456,6 +456,8 @@ In parallelo, puoi anche utilizzare `intlayerProxy` per aggiungere il routing la
 
 > Nota che per utilizzare `intlayerProxy` in produzione, è necessario spostare il pacchetto `vite-intlayer` da `devDependencies` a `dependencies`.
 
+> A partire da Intlayer v9, `intlayerProxy()` è incluso direttamente nel plugin `intlayer()` e abilitato per impostazione predefinita attraverso l'opzione `routing.enableProxy` (`true` per impostazione predefinita). Registrarlo separatamente come mostrato di seguito è ora facoltativo — viene mantenuto per la compatibilità con le versioni precedenti e per le configurazioni che necessitano di controllare l'ordine dei plugin. Imposta `routing.enableProxy: false` per escluderlo. Vedi le [note di rilascio v9](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/releases/v9.md).
+
 ```typescript {3,7} fileName="vite.config.ts" codeFormat={["typescript", "esm", "commonjs"]}
 import { defineConfig } from "vite";
 import { svelte } from "@sveltejs/vite-plugin-svelte";
@@ -506,6 +508,29 @@ const changeLocale = (event: Event) => {
 
 </Step>
 
+<Step number={9} title="Link Internazionalizzati" isOptional={true}>
+
+Per SEO, è consigliato aggiungere un prefisso alle tue route con la locale (ad es. `/about`, `/fr/about`).
+
+```svelte fileName="src/lib/components/Link.svelte"
+<script lang="ts">
+  import { getLocalizedUrl } from "intlayer";
+  import { useLocale } from "svelte-intlayer";
+
+  export let href = "";
+  const { locale } = useLocale();
+
+  // Aiutante per prefissare l'URL
+  $: localizedHref = getLocalizedUrl(href, $locale);
+</script>
+
+<a href={localizedHref}>
+  <slot />
+</a>
+```
+
+</Step>
+
 <Step number={1} title="Estrarre il contenuto dei tuoi componenti" isOptional={true}>
 
 Se hai una base di codice esistente, trasformare migliaia di file può richiedere molto tempo.
@@ -707,6 +732,8 @@ Questa estensione offre:
 
 Per maggiori dettagli su come utilizzare l'estensione, consulta la [documentazione della Intlayer VS Code Extension](https://intlayer.org/doc/vs-code-extension).
 
+---
+
 ### Vai oltre
 
 Per andare oltre, puoi implementare l'[editor visuale](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/intlayer_visual_editor.md) o esternalizzare i tuoi contenuti utilizzando il [CMS](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/intlayer_CMS.md).

package/docs/it/intlayer_with_vite+vanilla.md

@@ -470,6 +470,8 @@ Innanzitutto, aggiungi `intlayerProxy` alla tua configurazione Vite:
 
 > Tieni presente che per utilizzare `intlayerProxy` in produzione, devi spostare `vite-intlayer` da `devDependencies` a `dependencies`.
 
+> A partire da Intlayer v9, `intlayerProxy()` è integrato direttamente nel plugin `intlayer()` ed è abilitato per impostazione predefinita tramite l'opzione `routing.enableProxy` (`true` per impostazione predefinita). Registrarlo separatamente come mostrato di seguito è ora opzionale — è mantenuto per la compatibilità con le versioni precedenti e per le configurazioni che hanno bisogno di controllare l'ordine dei plugin. Impostare `routing.enableProxy: false` per disabilitarlo. Vedi le [note sulla versione v9](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/releases/v9.md).
+
 ```typescript {3,7} fileName="vite.config.ts" codeFormat={["typescript", "esm", "commonjs"]}
 import { defineConfig } from "vite";
 import { intlayer } from "vite-intlayer";

package/docs/it/intlayer_with_vite+vue.md

@@ -102,6 +102,17 @@ Più di una semplice soluzione i18n, Intlayer fornisce un **[editor visivo](http
   loading="lazy"
 />
 
+  </Tab>
+  <Tab label="Demo" value="demo">
+
+<iframe
+  src="https://intlayer-vite-vue-template.vercel.app"
+  className="m-auto overflow-hidden rounded-lg border-0 max-md:size-full max-md:h-[700px] md:aspect-16/9 md:w-full"
+  title="Demo - intlayer-vite-vue-template"
+  sandbox="allow-forms allow-modals allow-popups allow-presentation allow-same-origin allow-scripts"
+  loading="lazy"
+/>
+
   </Tab>
 </Tabs>
 
@@ -359,6 +370,8 @@ app.mount("#app");
 
 Accedi ai tuoi dizionari di contenuti in tutta l'applicazione creando un componente Vue principale e utilizzando i composables `useIntlayer`:
 
+Accedi ai tuoi dizionari di contenuti in tutta l'applicazione creando un componente Vue principale e utilizzando i composables `useIntlayer`:
+
 ```vue fileName="src/HelloWord.vue"
 <script setup lang="ts">
 import { ref } from "vue";
@@ -410,6 +423,8 @@ const countRef = ref(0);
 </template>
 ```
 
+> Se la tua app esiste già, puoi usare l'[Intlayer Compiler](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/compiler.md), così come il comando [extract](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/cli/extract.md), per trasformare migliaia di componenti in un secondo.
+
 #### Accesso ai contenuti in Intlayer
 
 Intlayer offre diverse API per accedere ai tuoi contenuti:
@@ -428,8 +443,6 @@ Intlayer offre diverse API per accedere ai tuoi contenuti:
   - Usa `const content = useIntlayer("myContent");` e `{{ content.myContent }}` / `<content.myContent />`.
   - Oppure usa `const { myContent } = useIntlayer(\"myContent\");` e `{{ myContent}}` / `<myContent/>` per destrutturare il contenuto.
 
-> Se la tua app esiste già, puoi utilizzare l' [Intlayer Compiler](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/compiler.md) in combinazione con il [comando extract](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/cli/extract.md) per convertire migliaia di componenti in un secondo.
-
 </Step>
 
 <Step number={6} title="Cambiare la lingua del tuo contenuto" isOptional={true}>
@@ -617,6 +630,10 @@ import LocaleSwitcher from "@components/LocaleSwitcher.vue";
 
 Parallelamente, puoi anche utilizzare il `intlayerProxy` per aggiungere il routing lato server alla tua applicazione. Questo plugin rileverà automaticamente la locale corrente basandosi sull'URL e imposterà il cookie della locale appropriata. Se non viene specificata alcuna locale, il plugin determinerà la locale più adatta in base alle preferenze linguistiche del browser dell'utente. Se non viene rilevata alcuna locale, effettuerà un reindirizzamento alla locale predefinita.
 
+> Nota che per utilizzare `intlayerProxy` in produzione, è necessario spostare il package `vite-intlayer` da `devDependencies` a `dependencies`.
+
+> A partire da Intlayer v9, `intlayerProxy()` è integrato direttamente nel plugin `intlayer()` ed è abilitato per impostazione predefinita tramite l'opzione `routing.enableProxy` (`true` per impostazione predefinita). Registrarlo separatamente come mostrato di seguito è ora facoltativo — viene mantenuto per la compatibilità con versioni precedenti e per configurazioni che necessitano di controllare l'ordine dei plugin. Impostare `routing.enableProxy: false` per disabilitarlo. Consulta le [note di rilascio v9](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/releases/v9.md).
+
 ```typescript {3,7} fileName="vite.config.ts" codeFormat={["typescript", "esm", "commonjs"]}
 import { defineConfig } from "vite";
 import vue from "@vitejs/plugin-vue";
@@ -1118,3 +1135,5 @@ Per maggiori dettagli su come utilizzare l'estensione, consulta la [documentazio
 ### Approfondimenti
 
 Per approfondire, puoi implementare l'[editor visuale](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/intlayer_visual_editor.md) o esternalizzare i tuoi contenuti utilizzando il [CMS](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/intlayer_CMS.md).
+
+Once you share these, I'll audit the Italian translation against the English source and return the fully updated Italian content.---

package/docs/it/live-sync.md

@@ -42,8 +42,6 @@ La Sincronizzazione Live consente alla tua app di riflettere le modifiche ai con
 
 ## Attivare la sincronizzazione live
 
-> Live Sync richiede una connessione continua al server ed è disponibile nel piano enterprise.
-
 Abilita Live Sync aggiornando la configurazione di Intlayer:
 
 ```typescript fileName="intlayer.config.ts" codeFormat={["typescript", "esm", "commonjs"]}
@@ -85,6 +83,19 @@ export default config;
 
 Avvia il server Live Sync per avvolgere la tua applicazione:
 
+Esempio utilizzando un server standalone:
+
+```json5 fileName="package.json"
+{
+  "scripts": {
+    // ... altri script
+    "live:start": "npx intlayer live",
+  },
+}
+```
+
+Puoi anche utilizzare il tuo application server in parallelo utilizzando l'argomento `--process`.
+
 Esempio con Next.js:
 
 ```json5 fileName="package.json"

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

@@ -0,0 +1,136 @@
+---
+createdAt: 2026-08-24
+updatedAt: 2026-08-24
+title: Documentazione del pacchetto elysia-intlayer
+description: Plugin Elysia per Intlayer, che fornisce funzioni di traduzione e rilevamento della locale.
+keywords:
+  - elysia-intlayer
+  - elysia
+  - plugin
+  - internationalization
+  - i18n
+slugs:
+  - doc
+  - packages
+  - elysia-intlayer
+  - exports
+history:
+  - version: 9.4.0
+    date: 2026-08-24
+    changes: "Documentazione unificata per tutte le esportazioni"
+author: aymericzip
+---
+
+# Pacchetto elysia-intlayer
+
+Il pacchetto `elysia-intlayer` fornisce un plugin per applicazioni Elysia per gestire l'internazionalizzazione. Rileva la locale dell'utente e inietta un oggetto `intlayer` nel contesto della route.
+
+## Installazione
+
+```bash packageManager="npm"
+npm install intlayer elysia-intlayer
+```
+
+```bash packageManager="pnpm"
+pnpm add intlayer elysia-intlayer
+```
+
+```bash packageManager="yarn"
+yarn add intlayer elysia-intlayer
+```
+
+```bash packageManager="bun"
+bun add intlayer elysia-intlayer
+```
+
+> `elysia` è una peer dependency (`>=1.0.0`). Elysia è pensato per il runtime **Bun**.
+
+## Esportazioni
+
+### Plugin
+
+Importazione:
+
+```ts
+import { intlayer } from "elysia-intlayer";
+```
+
+| Funzione   | Descrizione                                                                                                                                                                                                                                                                                                                                  | Documento correlato                                                                                            |
+| ---------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------- |
+| `intlayer` | Plugin Elysia che integra Intlayer nella tua applicazione Elysia. Gestisce il rilevamento della locale dallo storage (cookie, header) e poi da `Accept-Language`, inietta un oggetto `intlayer` che espone `locale`, `t`, `getIntlayer` e `getDictionary` nel contesto della route e configura il contesto di richiesta `AsyncLocalStorage`. | [intlayer](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/packages/elysia-intlayer/intlayer.md) |
+
+### Funzioni
+
+Importazione:
+
+```ts
+import { t, getIntlayer, getDictionary } from "elysia-intlayer";
+```
+
+| Funzione        | Descrizione                                                                                                                                                                                                                                                                                       | Documento correlato                                                                                    |
+| --------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------ |
+| `t`             | Funzione di traduzione globale che recupera il contenuto per la locale corrente in Elysia. Utilizza `AsyncLocalStorage` per accedere al contesto di richiesta configurato dal plugin `intlayer` e ricade sulla locale predefinita al di fuori di esso. Accessibile anche tramite `intlayer.t`.    | [translation](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/dictionary/translation.md) |
+| `getIntlayer`   | Recupera un dizionario tramite la sua chiave dalla dichiarazione generata e ne restituisce il contenuto per la locale corrente. Versione ottimizzata di `getDictionary`. Utilizza `AsyncLocalStorage` per accedere al contesto della richiesta. Accessibile anche tramite `intlayer.getIntlayer`. | -                                                                                                      |
+| `getDictionary` | Elabora gli oggetti dizionario e restituisce il contenuto per la locale corrente. Elabora traduzioni `t()`, enumerazioni, markdown, HTML, ecc. Utilizza `AsyncLocalStorage` per accedere al contesto della richiesta. Accessibile anche tramite `intlayer.getDictionary`.                         | -                                                                                                      |
+
+### Tipi
+
+Importazione:
+
+```ts
+import type { IntlayerContext, TranslateFunction } from "elysia-intlayer";
+```
+
+| Tipo                | Descrizione                                                                                                                                                             |
+| ------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `IntlayerContext`   | Forma dell'oggetto `intlayer` iniettato in ogni contesto di route: `locale`, `locale_storage`, `locale_detected`, `defaultLocale`, `t`, `getIntlayer`, `getDictionary`. |
+| `TranslateFunction` | Firma della funzione di traduzione, che traduce una locale map nel contenuto corrispondente alla locale della richiesta corrente.                                       |
+
+## Utilizzo
+
+```ts fileName="src/index.ts"
+import { Elysia } from "elysia";
+import { getDictionary, getIntlayer, intlayer, t } from "elysia-intlayer";
+import dictionaryExample from "./index.content";
+
+const app = new Elysia()
+  // Carica il plugin di internazionalizzazione
+  .use(intlayer())
+  // Leggi la locale e gli helper dal contesto della route
+  .get("/", ({ intlayer }) => ({
+    locale: intlayer!.locale,
+    greeting: intlayer!.t({
+      it: "Ciao",
+      en: "Hello",
+      fr: "Bonjour",
+      es: "Hola",
+    }),
+    content: intlayer!.getIntlayer("index").exampleOfContent,
+  }))
+  // Oppure usa gli helper standalone, legati alla richiesta corrente
+  .get("/t_example", () =>
+    t({
+      it: "Esempio di contenuto restituito in italiano",
+      en: "Example of returned content in English",
+      fr: "Exemple de contenu renvoyé en français",
+      es: "Ejemplo de contenido devuelto en español",
+    })
+  )
+  .get("/getIntlayer_example", () => getIntlayer("index").exampleOfContent)
+  .get(
+    "/getDictionary_example",
+    () => getDictionary(dictionaryExample).exampleOfContent
+  )
+  .listen(3000);
+
+console.log(
+  `🦊 Elysia is running at ${app.server?.hostname}:${app.server?.port}`
+);
+```
+
+> Il plugin registra il proprio contesto tramite un `derive` **globale**, che Elysia tipizza come `Partial<{ intlayer: IntlayerContext }>`. A runtime il valore è sempre presente per le route registrate dopo `.use(intlayer())`, quindi usa la non-null assertion (`intlayer!.locale`) — oppure l'optional chaining — per soddisfare TypeScript in modalità `strict`.
+
+## Documentazione correlata
+
+- [Elysia i18n - Guida completa per tradurre la tua app](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/intlayer_with_elysia.md)
+- [Configurazione](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/configuration.md)

package/docs/it/packages/elysia-intlayer/intlayer.md

@@ -0,0 +1,139 @@
+---
+createdAt: 2026-08-24
+updatedAt: 2026-08-24
+title: Documentazione del plugin intlayer per Elysia | elysia-intlayer
+description: Scopri come utilizzare il plugin intlayer del pacchetto elysia-intlayer
+keywords:
+  - intlayer
+  - elysia
+  - plugin
+  - Intlayer
+  - Internazionalizzazione
+  - Documentazione
+slugs:
+  - doc
+  - packages
+  - elysia-intlayer
+  - intlayer
+history:
+  - version: 9.4.0
+    date: 2026-08-24
+    changes: "Inizializzazione della documentazione"
+author: aymericzip
+---
+
+# Documentazione del plugin intlayer per Elysia
+
+Il plugin `intlayer` per Elysia rileva la locale dell'utente e inietta un oggetto `intlayer` nel contesto della route. Consente inoltre l'uso di funzioni di traduzione globali all'interno del contesto della richiesta.
+
+## Utilizzo
+
+```ts fileName="src/index.ts"
+import { Elysia } from "elysia";
+import { intlayer } from "elysia-intlayer";
+
+const app = new Elysia().use(intlayer()).get("/", ({ intlayer }) =>
+  intlayer!.t({
+    it: "Ciao",
+    en: "Hello",
+    fr: "Bonjour",
+    es: "Hola",
+  })
+);
+```
+
+> Il plugin registra il proprio contesto tramite un `derive` **globale**, che Elysia tipizza come `Partial<{ intlayer: IntlayerContext }>`. A runtime il valore è sempre presente per le route registrate dopo `.use(intlayer())`, quindi usa la non-null assertion (`intlayer!.t`) — oppure l'optional chaining — per soddisfare TypeScript in modalità `strict`.
+
+Gli stessi helper sono disponibili come export autonomi, così puoi richiamarli senza destrutturare il contesto della route:
+
+```ts fileName="src/index.ts"
+import { Elysia } from "elysia";
+import { intlayer, t } from "elysia-intlayer";
+
+const app = new Elysia().use(intlayer()).get("/", () =>
+  t({
+    it: "Ciao",
+    en: "Hello",
+    fr: "Bonjour",
+    es: "Hola",
+  })
+);
+```
+
+## Descrizione
+
+Il plugin esegue le seguenti operazioni:
+
+1. **Rilevamento della locale**: Legge la locale impostata esplicitamente dal client dallo storage (cookie, header), quindi ricade sulla locale negoziata a partire dall'header `Accept-Language`.
+2. **Iniezione nel contesto**: Aggiunge una proprietà `intlayer` al contesto della route di Elysia (vedi la tabella Contesto della route qui sotto).
+3. **Gestione del contesto**: Utilizza `AsyncLocalStorage` per gestire un contesto asincrono, consentendo alle funzioni globali di Intlayer (`t`, `getIntlayer`, `getDictionary`) di accedere alla locale specifica della richiesta senza dover passare l'oggetto di contesto.
+4. **Preparazione dei dizionari**: Richiama `prepareIntlayer` alla creazione del plugin, così i dizionari vengono costruiti all'avvio dell'applicazione.
+
+### Contesto della route
+
+| Proprietà         | Tipo                   | Descrizione                                                                                              |
+| ----------------- | ---------------------- | -------------------------------------------------------------------------------------------------------- |
+| `locale`          | `Locale`               | La locale da usare per questa richiesta, con `locale_storage` che ha la precedenza su `locale_detected`. |
+| `locale_storage`  | `Locale` (opzionale)   | La locale richiesta esplicitamente dal client tramite un cookie o un header.                             |
+| `locale_detected` | `Locale`               | La locale negoziata a partire dagli header della richiesta.                                              |
+| `defaultLocale`   | `Locale`               | La locale configurata come fallback in `intlayer.config.ts`.                                             |
+| `t`               | `TranslateFunction`    | Una funzione di traduzione.                                                                              |
+| `getIntlayer`     | `typeof getIntlayer`   | Una funzione per recuperare i dizionari tramite chiave.                                                  |
+| `getDictionary`   | `typeof getDictionary` | Una funzione per elaborare gli oggetti dizionario.                                                       |
+
+> A differenza dei plugin Intlayer basati su Node, `elysia-intlayer` si affida ad `AsyncLocalStorage` anziché a `cls-hooked`, poiché `cls-hooked` dipende da `async_hooks.createHook`, che Bun non implementa.
+
+Il contesto della richiesta viene rilasciato una volta mappata la risposta, così gli helper autonomi non si risolvono mai su una richiesta già terminata. Quando vengono chiamati al di fuori di una richiesta gestita dal plugin, ricadono sulla locale predefinita configurata.
+
+## Ordine di risoluzione della locale
+
+Per impostazione predefinita, il plugin risolve la locale in questo ordine:
+
+1. Il cookie `INTLAYER_LOCALE`.
+2. L'header `x-intlayer-locale`.
+3. La negoziazione dell'header `Accept-Language`.
+4. La `defaultLocale` configurata.
+
+```bash
+# Negoziata da `Accept-Language`
+curl -H "Accept-Language: fr" http://localhost:3000/
+# Bonjour
+
+# Il cookie ha la precedenza su `Accept-Language`
+curl -H "Accept-Language: fr" -H "Cookie: INTLAYER_LOCALE=es" http://localhost:3000/
+# Hola
+
+# L'header ha la precedenza su `Accept-Language`
+curl -H "Accept-Language: fr" -H "x-intlayer-locale: es" http://localhost:3000/
+# Hola
+```
+
+## Configurazione
+
+Il plugin legge il tuo file `intlayer.config.ts`. Puoi personalizzare il cookie e l'header utilizzati per il rilevamento della locale:
+
+```typescript fileName="intlayer.config.ts" codeFormat={["typescript", "esm", "commonjs"]}
+import { Locales, type IntlayerConfig } from "intlayer";
+
+const config: IntlayerConfig = {
+  internationalization: {
+    locales: [Locales.ENGLISH, Locales.FRENCH, Locales.SPANISH],
+    defaultLocale: Locales.ENGLISH,
+  },
+  routing: {
+    storage: [
+      { type: "header", name: "my-locale-header" },
+      { type: "cookie", name: "my-locale-cookie" },
+    ],
+  },
+};
+
+export default config;
+```
+
+> Per maggiori informazioni sulla configurazione, consulta la [documentazione di configurazione](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/configuration.md).
+
+## Documentazione correlata
+
+- [Documentazione del pacchetto elysia-intlayer](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/packages/elysia-intlayer/exports.md)
+- [Elysia i18n - Guida completa per tradurre la tua app](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/intlayer_with_elysia.md)