@intlayer/docs 9.4.0-canary.0 → 9.4.1

package/docs/pt/intlayer_with_vite+lit.md

@@ -109,6 +109,8 @@ Mais do que apenas uma solução i18n, o Intlayer fornece um **[editor visual] a
 
 ---
 
+Veja [Application Template](https://github.com/aymericzip/intlayer-vite-lit-template) no GitHub.
+
 ## Guia Passo-a-Passo para Configurar o Intlayer numa Aplicação Vite e Lit
 
 <Steps>
@@ -478,6 +480,8 @@ Primeiro, adicione o `intlayerProxy` à sua configuração Vite:
 
 > Note que para usar o `intlayerProxy` em produção, precisa de mover o `vite-intlayer` de `devDependencies` para `dependencies`.
 
+> Desde o Intlayer v9, `intlayerProxy()` está agrupado diretamente no plugin `intlayer()` e habilitado por padrão através da opção `routing.enableProxy` (`true` por padrão). Registrá-lo separadamente conforme mostrado abaixo agora é opcional — é mantido para compatibilidade com versões anteriores e para configurações que precisam controlar a ordem dos plugins. Defina `routing.enableProxy: false` para desativar. Veja as [notas de lançamento v9](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/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/pt/intlayer_with_vite+preact.md

@@ -514,6 +514,30 @@ const App: FunctionalComponent = () => (
 export default App;
 ```
 
+Em paralelo, você também pode usar o `intlayerProxy` para adicionar roteamento do lado do servidor à sua aplicação. Este plugin detectará automaticamente a localidade atual com base na URL e definirá o cookie de localidade apropriado. Se nenhuma localidade for especificada, o plugin determinará a localidade mais apropriada com base nas preferências de idioma do navegador do usuário. Se nenhuma localidade for detectada, ele redirecionará para a localidade padrão.
+
+> Observe que para usar o `intlayerProxy` em produção, você precisa mudar o pacote `vite-intlayer` de `devDependencies` para `dependencies`.
+
+> Desde Intlayer v9, `intlayerProxy()` é incluído diretamente no plugin `intlayer()` e ativado por padrão através da opção `routing.enableProxy` (`true` por padrão). Registrá-lo separadamente como mostrado abaixo agora é opcional — é mantido para compatibilidade retroativa e para configurações que precisam controlar a ordem dos plugins. Defina `routing.enableProxy: false` para desativar. Veja as [notas de lançamento da v9](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/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="Alterar a URL quando o idioma mudar" isOptional={true}>
@@ -590,6 +614,10 @@ export default LocaleSwitcher;
 >
 > > - [Hook `useLocale`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/packages/react-intlayer/useLocale.md) (API é semelhante para `preact-intlayer`)> - [Hook `getLocaleName`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/packages/intlayer/getLocaleName.md)> - [Hook `getLocalizedUrl`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/packages/intlayer/getLocalizedUrl.md)> - [Hook `getHTMLTextDir`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/packages/intlayer/getHTMLTextDir.md)> - [Atributo `hreflang`](https://developers.google.com/search/docs/specialty/international/localized-versions?hl=fr)> - [Atributo `lang`](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/lang)> - [Atributo `dir`](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/dir)> - [Atributo `aria-current`](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Attributes/aria-current)> - [API Popover](https://developer.mozilla.org/en-US/docs/Web/API/Popover_API)
 
+Abaixo está o **Passo 9** atualizado com explicações adicionadas e exemplos de código refinados:
+
+---
+
 </Step>
 
 <Step number={9} title="Alternar os atributos de idioma e direção do HTML" isOptional={true}>
@@ -659,6 +687,12 @@ const App: FunctionalComponent = () => (
 export default App;
 ```
 
+Ao aplicar essas mudanças, sua aplicação irá:
+
+- Certifique-se de que o atributo **language** (`lang`) reflita corretamente a localidade atual, o que é importante para SEO e comportamento do navegador.
+- Ajuste a **direção do texto** (`dir`) de acordo com a localidade, melhorando a legibilidade e usabilidade para idiomas com ordens de leitura diferentes.
+- Forneça uma experiência mais **acessível**, pois as tecnologias assistivas dependem desses atributos para funcionar otimamente.
+
 </Step>
 
 <Step number={10} title="Criando um componente de link localizado" isOptional={true}>

package/docs/pt/intlayer_with_vite+react.md

@@ -507,6 +507,8 @@ Paralelamente, você também pode usar o `intlayerProxy` para adicionar roteamen
 
 > Observe que para usar o `intlayerProxy` em produção, você precisa mover o pacote `vite-intlayer` de `devDependencies` para `dependencies`.
 
+> Desde o Intlayer v9, `intlayerProxy()` está agrupado diretamente no plugin `intlayer()` e ativado por padrão através da opção `routing.enableProxy` (`true` por padrão). Registrá-lo separadamente conforme mostrado abaixo agora é opcional — é mantido para compatibilidade retroativa e para configurações que precisam controlar a ordem dos plugins. Defina `routing.enableProxy: false` para desativar. Consulte as [notas de versão v9](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/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";

package/docs/pt/intlayer_with_vite+react_compiler.md

@@ -237,6 +237,8 @@ export default defineConfig({
 
 > O plugin Vite `intlayerCompiler()` é usado para extrair conteúdo do componente e escrever os arquivos `.content`.
 
+> Desde Intlayer v9, o compilador está incluído diretamente no plugin `intlayer()` e é ativado automaticamente quando `compiler.enabled` é definido com um caminho `compiler.output`. Registrar `intlayerCompiler()` separadamente, como mostrado abaixo, agora é opcional — ele se deduplica se também for adicionado. Veja as [notas de lançamento v9](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/releases/v9.md).
+
 </Step>
 
 <Step number={4} title="Compilar seu código">

package/docs/pt/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/>
 
-> Este pacote está em desenvolvimento. Veja a [issue](https://github.com/aymericzip/intlayer/issues/117) para mais informações. Demonstre seu interesse pelo Intlayer para Solid curtindo a issue
-
-<!-- Veja o [Modelo de Aplicação](https://github.com/aymericzip/intlayer-solid-template) no GitHub. -->
-
 ## Por que Intlayer em vez de alternativas?
 
 Comparado com soluções principais como `@solid-primitives/i18n` ou `i18next`, Intlayer é uma solução que vem com otimizações integradas como:
@@ -242,8 +249,6 @@ export default appContent;
 
 > As suas declarações de conteúdo podem ser definidas em qualquer lugar da sua aplicação assim que forem incluídas no diretório `contentDir` (por padrão, `./src`). E devem corresponder à extensão do ficheiro de declaração de conteúdo (por padrão, `.content.{json,ts,tsx,js,jsx,mjs,cjs,md,mdx,yaml,yml}`).
 
-> Para mais detalhes, consulte a [documentação de declaração de conteúdo](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/dictionary/content_file.md).
-
 </Step>
 
 <Step number={5} title="Utilize o Intlayer no Seu Código">
@@ -491,29 +496,10 @@ export const Link: ParentComponent<AnchorProps> = (props) => {
 };
 ```
 
-</Step>
-
 <Step number={11} title="Renderizar Markdown" isOptional={true}>
 
 O Intlayer suporta a renderização de conteúdo Markdown diretamente na sua aplicação Solid usando o seu próprio parser interno. Por padrão, o Markdown é tratado como texto simples. Para renderizá-lo como HTML rico, envolva a sua aplicação com o `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!
-);
-```
-
 Depois pode usá-lo nos seus componentes:
 
 ```tsx
@@ -738,19 +724,8 @@ Para melhorar a sua experiência de desenvolvimento com o Intlayer, pode instala
 
 [Instalar a partir do VS Code Marketplace](https://marketplace.visualstudio.com/items?itemName=intlayer.intlayer-vs-code-extension)
 
-Esta extensão fornece:
-
-- **Autocompletar** para chaves de tradução.
-- **Deteção de erros em tempo real** para traduções em falta.
-- **Pré-visualizações inline** do conteúdo traduzido.
-- **Ações rápidas** para criar e atualizar traduções facilmente.
-
-Para mais detalhes sobre como usar a extensão, consulte a [documentação da Extensão Intlayer para VS Code](https://intlayer.org/doc/vs-code-extension).
-
 ---
 
 ### Ir Mais Longe
 
 Para ir mais longe, pode implementar o [editor visual](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/intlayer_visual_editor.md) ou externalizar o seu conteúdo usando o [CMS](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/intlayer_CMS.md).
-
----

package/docs/pt/intlayer_with_vite+svelte.md

@@ -297,6 +297,8 @@ export default appContent;
 > Se a sua aplicação já existe, você pode usar o [Intlayer Compiler](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/compiler.md) em conjunto com o [comando extract](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/cli/extract.md) para converter milhares de componentes em um segundo.
 ```
 
+> Se sua aplicação já existe, você pode usar o [Intlayer Compiler](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/compiler.md), bem como o [comando extract](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/cli/extract.md), para transformar milhares de componentes em um segundo.
+
 </Step>
 
 <Step number={6} title="Alterar o idioma do seu conteúdo" isOptional={true}>
@@ -455,6 +457,8 @@ Paralelamente, você também pode usar o `intlayerProxy` para adicionar roteamen
 
 > Note que para usar o `intlayerProxy` em produção, você precisa mover o pacote `vite-intlayer` de `devDependencies` para `dependencies`.
 
+> Desde o Intlayer v9, `intlayerProxy()` está agrupado diretamente no plugin `intlayer()` e ativado por padrão através da opção `routing.enableProxy` (`true` por padrão). Registrá-lo separadamente conforme mostrado abaixo agora é opcional — é mantido para compatibilidade com versões anteriores e para configurações que precisam controlar a ordem dos plugins. Defina `routing.enableProxy: false` para desativar. Veja as [notas de lançamento v9](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/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";

package/docs/pt/intlayer_with_vite+vanilla.md

@@ -470,6 +470,8 @@ Primeiro, adicione o `intlayerProxy` à sua configuração do Vite:
 
 > Note que para usar o `intlayerProxy` em produção, você precisa mover o `vite-intlayer` de `devDependencies` para `dependencies`.
 
+> Desde o Intlayer v9, `intlayerProxy()` é agrupado diretamente no plugin `intlayer()` e habilitado por padrão através da opção `routing.enableProxy` (`true` por padrão). Registrá-lo separadamente, conforme mostrado abaixo, agora é opcional — é mantido para compatibilidade com versões anteriores e para configurações que precisam controlar a ordem dos plugins. Defina `routing.enableProxy: false` para desabilitar. Veja as [notas de lançamento do v9](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/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/pt/intlayer_with_vite+vue.md

@@ -102,6 +102,17 @@ Mais do que apenas uma solução i18n, o Intlayer fornece um **[editor visual] a
   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>
 
@@ -354,6 +365,13 @@ app.use(intlayer);
 app.mount("#app");
 ```
 
+> Você também pode chamar `installIntlayer(app)` diretamente como uma função se preferir:
+>
+> ```javascript
+> import { intlayer } from "vue-intlayer";
+> app.use(intlayer);
+> ```
+
 Acesse seus dicionários de conteúdo em toda a sua aplicação criando um componente Vue principal e utilizando os composables `useIntlayer`:
 
 ```vue fileName="src/HelloWord.vue"
@@ -407,6 +425,8 @@ const countRef = ref(0);
 </template>
 ```
 
+> Se sua aplicação já existe, você pode usar o [Intlayer Compiler](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/compiler.md), bem como o [comando extract](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/cli/extract.md), para transformar milhares de componentes em um segundo.
+
 #### Acessando Conteúdo no Intlayer
 
 O Intlayer oferece diferentes APIs para acessar seu conteúdo:
@@ -425,8 +445,6 @@ O Intlayer oferece diferentes APIs para acessar seu conteúdo:
   - Use `const content = useIntlayer("myContent");` e `{{ content.myContent }}` / `<content.myContent />`.
   - Ou use `const { myContent } = useIntlayer("myContent");` e `{{ myContent }}` / `<myContent/>` para desestruturar o conteúdo.
 
-> Se a sua aplicação já existe, você pode usar o [Intlayer Compiler](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/compiler.md) em conjunto com o [comando extract](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/cli/extract.md) para converter milhares de componentes em um segundo.
-
 </Step>
 
 <Step number={6} title="Alterar o idioma do seu conteúdo" isOptional={true}>
@@ -614,6 +632,10 @@ import LocaleSwitcher from "@components/LocaleSwitcher.vue";
 
 Paralelamente, você também pode usar o `intlayerProxy` para adicionar roteamento no lado do servidor à sua aplicação. Este plugin detectará automaticamente o idioma atual com base na URL e definirá o cookie de idioma apropriado. Se nenhum idioma for especificado, o plugin determinará o idioma mais adequado com base nas preferências de idioma do navegador do usuário. Se nenhum idioma for detectado, ele redirecionará para o idioma padrão.
 
+> Observe que para usar o `intlayerProxy` em produção, você precisa mover o pacote `vite-intlayer` de `devDependencies` para `dependencies`.
+
+> Desde o Intlayer v9, `intlayerProxy()` está agrupado diretamente no plugin `intlayer()` e ativado por padrão através da opção `routing.enableProxy` (`true` por padrão). Registrá-lo separadamente conforme mostrado abaixo agora é opcional — é mantido para compatibilidade com versões anteriores e para configurações que precisam controlar a ordem dos plugins. Defina `routing.enableProxy: false` para desativar. Veja as [notas de lançamento da v9](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/releases/v9.md).
+
 ```typescript {3,7} fileName="vite.config.ts" codeFormat={["typescript", "esm", "commonjs"]}
 import { defineConfig } from "vite";
 import vue from "@vitejs/plugin-vue";
@@ -895,56 +917,6 @@ import RouterLink from "@components/RouterLink.vue";
 
 <Step number={11} title="Renderizar Markdown" isOptional={true}>
 
-Intlayer suporta a renderização de conteúdo Markdown diretamente na sua aplicação Vue. Por padrão, o Markdown é tratado como texto simples. Para converter Markdown em HTML enriquecido, você pode integrar o [markdown-it](https://github.com/markdown-it/markdown-it), um parser de Markdown.
-
-Isto é particularmente útil quando suas traduções incluem conteúdo formatado como listas, links ou ênfases.
-
-Por padrão, o Intlayer renderiza markdown como string. Mas o Intlayer também fornece uma forma de renderizar markdown em HTML usando a função `installIntlayerMarkdown`.
-
-> Para ver como declarar conteúdo markdown usando o pacote `intlayer`, consulte a [documentação de markdown](https://github.com/aymericzip/intlayer/tree/main/docs/pt/dictionary/markdown.md).
-
-```ts fileName="main.ts"
-import MarkdownIt from "markdown-it";
-import { createApp, h } from "vue";
-import { installIntlayer, installIntlayerMarkdown } from "vue-intlayer";
-
-const app = createApp(App);
-
-app.use(intlayer);
-
-const md = new MarkdownIt({
-  html: true, // permitir tags HTML
-  linkify: true, // auto-linkar URLs
-  typographer: true, // ativar aspas inteligentes, travessões, etc.
-});
-
-// Diga ao Intlayer para usar md.render() sempre que precisar transformar markdown em HTML
-installIntlayerMarkdown(app, (markdown) => {
-  const html = md.render(markdown);
-  return h("div", { innerHTML: html });
-});
-```
-
-Uma vez registrado, você pode usar a sintaxe baseada em componentes para exibir o conteúdo Markdown diretamente:
-
-```vue
-<template>
-  <div>
-    <myMarkdownContent />
-  </div>
-</template>
-
-<script setup lang="ts">
-import { useIntlayer } from "vue-intlayer";
-
-const { myMarkdownContent } = useIntlayer("my-component");
-</script>
-```
-
-</Step>
-
-<Step number={1} title="Extrair o conteúdo dos seus componentes" isOptional={true}>
-
 Se você tiver uma base de código existente, transformar milhares de arquivos pode ser demorado.
 
 Para facilitar esse processo, o Intlayer propõe um [compilador](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/compiler.md) / [extrator](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/cli/extract.md) para transformar seus componentes e extrair o conteúdo.

package/docs/pt/live-sync.md

@@ -42,8 +42,6 @@ A Sincronização ao Vivo permite que a sua aplicação reflita as alterações
 
 ## Ativar a sincronização ao vivo
 
-> A Sincronização ao Vivo requer uma conexão contínua com o servidor e está disponível no plano enterprise.
-
 Ative a Sincronização ao Vivo atualizando a sua configuração Intlayer:
 
 ```typescript fileName="intlayer.config.ts" codeFormat={["typescript", "esm", "commonjs"]}
@@ -85,6 +83,19 @@ export default config;
 
 Inicie o servidor Live Sync para envolver sua aplicação:
 
+Exemplo usando servidor standalone:
+
+```json5 fileName="package.json"
+{
+  "scripts": {
+    // ... outros scripts
+    "live:start": "npx intlayer live",
+  },
+}
+```
+
+Você também pode usar seu servidor de aplicação em paralelo usando o argumento `--process`.
+
 Exemplo usando Next.js:
 
 ```json5 fileName="package.json"

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

@@ -0,0 +1,136 @@
+---
+createdAt: 2026-08-24
+updatedAt: 2026-08-24
+title: Documentação do pacote elysia-intlayer
+description: Plugin Elysia para o Intlayer, fornecendo funções de tradução e detecção de locale.
+keywords:
+  - elysia-intlayer
+  - elysia
+  - plugin
+  - internacionalização
+  - i18n
+slugs:
+  - doc
+  - packages
+  - elysia-intlayer
+  - exports
+history:
+  - version: 9.4.0
+    date: 2026-08-24
+    changes: "Documentação unificada para todas as exportações"
+author: aymericzip
+---
+
+# Pacote elysia-intlayer
+
+O pacote `elysia-intlayer` fornece um plugin para aplicações Elysia para tratar da internacionalização. Ele deteta o locale do utilizador e injeta um objeto `intlayer` no contexto da rota.
+
+## Instalação
+
+```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` é uma peer dependency (`>=1.0.0`). O Elysia tem como alvo o runtime **Bun**.
+
+## Exportações
+
+### Plugin
+
+Importação:
+
+```ts
+import { intlayer } from "elysia-intlayer";
+```
+
+| Função     | Descrição                                                                                                                                                                                                                                                                                                                          | Documento Relacionado                                                                                          |
+| ---------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------- |
+| `intlayer` | Plugin Elysia que integra o Intlayer na sua aplicação Elysia. Trata da deteção do locale a partir do storage (cookies, headers) e depois de `Accept-Language`, injeta um objeto `intlayer` que expõe `locale`, `t`, `getIntlayer` e `getDictionary` no contexto da rota, e configura o contexto de request do `AsyncLocalStorage`. | [intlayer](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/packages/elysia-intlayer/intlayer.md) |
+
+### Funções
+
+Importação:
+
+```ts
+import { t, getIntlayer, getDictionary } from "elysia-intlayer";
+```
+
+| Função          | Descrição                                                                                                                                                                                                                                                           | Documento Relacionado                                                                                  |
+| --------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------ |
+| `t`             | Função de tradução global que obtém o conteúdo para o locale atual no Elysia. Usa `AsyncLocalStorage` para aceder ao contexto de request configurado pelo plugin `intlayer` e recorre ao locale por omissão fora dele. Também acessível através de `intlayer.t`.    | [translation](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/dictionary/translation.md) |
+| `getIntlayer`   | Obtém um dicionário pela sua chave a partir da declaração gerada e devolve o seu conteúdo para o locale atual. Versão otimizada de `getDictionary`. Usa `AsyncLocalStorage` para aceder ao contexto da request. Também acessível através de `intlayer.getIntlayer`. | -                                                                                                      |
+| `getDictionary` | Processa objetos de dicionário e devolve o conteúdo para o locale atual. Processa traduções `t()`, enumerações, markdown, HTML, etc. Usa `AsyncLocalStorage` para aceder ao contexto da request. Também acessível através de `intlayer.getDictionary`.              | -                                                                                                      |
+
+### Tipos
+
+Importação:
+
+```ts
+import type { IntlayerContext, TranslateFunction } from "elysia-intlayer";
+```
+
+| Tipo                | Descrição                                                                                                                                                          |
+| ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `IntlayerContext`   | Forma do objeto `intlayer` injetado em cada contexto de rota: `locale`, `locale_storage`, `locale_detected`, `defaultLocale`, `t`, `getIntlayer`, `getDictionary`. |
+| `TranslateFunction` | Assinatura da função de tradução, que traduz um locale map no conteúdo correspondente ao locale da request atual.                                                  |
+
+## Uso
+
+```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()
+  // Carregue o plugin de internacionalização
+  .use(intlayer())
+  // Ler a locale e os helpers do contexto da rota
+  .get("/", ({ intlayer }) => ({
+    locale: intlayer!.locale,
+    greeting: intlayer!.t({
+      pt: "Olá",
+      en: "Hello",
+      fr: "Bonjour",
+      es: "Hola",
+    }),
+    content: intlayer!.getIntlayer("index").exampleOfContent,
+  }))
+  // Ou usar os helpers standalone, vinculados à requisição atual
+  .get("/t_example", () =>
+    t({
+      pt: "Exemplo de conteúdo retornado em português",
+      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}`
+);
+```
+
+> O plugin registra seu contexto por meio de um `derive` **global**, que o Elysia tipa como `Partial<{ intlayer: IntlayerContext }>`. Em tempo de execução o valor está sempre presente para as rotas registradas após `.use(intlayer())`, portanto use a non-null assertion (`intlayer!.locale`) — ou optional chaining — para satisfazer o TypeScript no modo `strict`.
+
+## Documentação relacionada
+
+- [Elysia i18n - Guia completo para traduzir sua aplicação](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/intlayer_with_elysia.md)
+- [Configuração](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/configuration.md)

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

@@ -0,0 +1,139 @@
+---
+createdAt: 2026-08-24
+updatedAt: 2026-08-24
+title: Documentação do Plugin intlayer para Elysia | elysia-intlayer
+description: Veja como utilizar o plugin intlayer do pacote elysia-intlayer
+keywords:
+  - intlayer
+  - elysia
+  - plugin
+  - Intlayer
+  - Internacionalização
+  - Documentação
+slugs:
+  - doc
+  - packages
+  - elysia-intlayer
+  - intlayer
+history:
+  - version: 9.4.0
+    date: 2026-08-24
+    changes: "Inicialização da documentação"
+author: aymericzip
+---
+
+# Documentação do Plugin intlayer para Elysia
+
+O plugin `intlayer` para Elysia deteta o locale do utilizador e injeta um objeto `intlayer` no contexto da rota. Também permite o uso de funções de tradução globais dentro do contexto da request.
+
+## Uso
+
+```ts fileName="src/index.ts"
+import { Elysia } from "elysia";
+import { intlayer } from "elysia-intlayer";
+
+const app = new Elysia().use(intlayer()).get("/", ({ intlayer }) =>
+  intlayer!.t({
+    pt: "Olá",
+    en: "Hello",
+    fr: "Bonjour",
+    es: "Hola",
+  })
+);
+```
+
+> O plugin registra seu contexto por meio de um `derive` **global**, que o Elysia tipa como `Partial<{ intlayer: IntlayerContext }>`. Em tempo de execução o valor está sempre presente para as rotas registradas após `.use(intlayer())`, portanto use a non-null assertion (`intlayer!.t`) — ou optional chaining — para satisfazer o TypeScript no modo `strict`.
+
+Os mesmos helpers estão disponíveis como exports autónomos, para que possa chamá-los sem desestruturar o contexto da rota:
+
+```ts fileName="src/index.ts"
+import { Elysia } from "elysia";
+import { intlayer, t } from "elysia-intlayer";
+
+const app = new Elysia().use(intlayer()).get("/", () =>
+  t({
+    pt: "Olá",
+    en: "Hello",
+    fr: "Bonjour",
+    es: "Hola",
+  })
+);
+```
+
+## Descrição
+
+O plugin realiza as seguintes tarefas:
+
+1. **Detecção de locale**: Lê o locale definido explicitamente pelo cliente a partir do storage (cookie, header) e, em seguida, recorre ao locale negociado a partir do header `Accept-Language`.
+2. **Injeção no contexto**: Adiciona uma propriedade `intlayer` ao contexto de rota do Elysia (veja a tabela Contexto da rota abaixo).
+3. **Gerenciamento de contexto**: Utiliza `AsyncLocalStorage` para gerir um contexto assíncrono, permitindo que as funções globais do Intlayer (`t`, `getIntlayer`, `getDictionary`) acedam ao locale específico da request sem terem de passar o objeto de contexto.
+4. **Preparação dos dicionários**: Chama `prepareIntlayer` quando o plugin é criado, de modo que os dicionários são construídos na inicialização da aplicação.
+
+### Contexto da rota
+
+| Propriedade       | Tipo                   | Descrição                                                                                      |
+| ----------------- | ---------------------- | ---------------------------------------------------------------------------------------------- |
+| `locale`          | `Locale`               | O locale a usar nesta request, com `locale_storage` a ter precedência sobre `locale_detected`. |
+| `locale_storage`  | `Locale` (opcional)    | O locale explicitamente pedido pelo cliente através de um cookie ou de um header.              |
+| `locale_detected` | `Locale`               | O locale negociado a partir dos headers da request.                                            |
+| `defaultLocale`   | `Locale`               | O locale configurado como fallback no `intlayer.config.ts`.                                    |
+| `t`               | `TranslateFunction`    | Uma função de tradução.                                                                        |
+| `getIntlayer`     | `typeof getIntlayer`   | Uma função para obter dicionários pela sua chave.                                              |
+| `getDictionary`   | `typeof getDictionary` | Uma função para processar objetos de dicionário.                                               |
+
+> Ao contrário dos plugins Intlayer baseados em Node, `elysia-intlayer` apoia-se em `AsyncLocalStorage` em vez de `cls-hooked`, porque `cls-hooked` depende de `async_hooks.createHook`, que o Bun não implementa.
+
+O contexto da request é libertado assim que a resposta é mapeada, para que os helpers autónomos nunca sejam resolvidos contra uma request já terminada. Quando chamados fora de uma request tratada pelo plugin, recorrem ao locale por omissão configurado.
+
+## Ordem de resolução da locale
+
+Por padrão, o plugin resolve a locale nesta ordem:
+
+1. O cookie `INTLAYER_LOCALE`.
+2. O header `x-intlayer-locale`.
+3. A negociação do header `Accept-Language`.
+4. A `defaultLocale` configurada.
+
+```bash
+# Negociada a partir de `Accept-Language`
+curl -H "Accept-Language: fr" http://localhost:3000/
+# Bonjour
+
+# O cookie tem precedência sobre `Accept-Language`
+curl -H "Accept-Language: fr" -H "Cookie: INTLAYER_LOCALE=es" http://localhost:3000/
+# Hola
+
+# O header tem precedência sobre `Accept-Language`
+curl -H "Accept-Language: fr" -H "x-intlayer-locale: es" http://localhost:3000/
+# Hola
+```
+
+## Configuração
+
+O plugin lê o seu ficheiro `intlayer.config.ts`. Pode personalizar o cookie e o header usados para a deteção do 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;
+```
+
+> Para mais informações sobre a configuração, visite a [documentação de configuração](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/configuration.md).
+
+## Documentação relacionada
+
+- [Documentação do pacote elysia-intlayer](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/packages/elysia-intlayer/exports.md)
+- [Elysia i18n - Guia completo para traduzir sua aplicação](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/intlayer_with_elysia.md)