@intlayer/docs 9.3.3 → 9.4.0

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

@@ -0,0 +1,197 @@
+---
+createdAt: 2026-08-23
+updatedAt: 2026-08-23
+title: Documentação da Função getIntlayer | intlayer
+description: Veja como usar a função getIntlayer para o pacote intlayer
+keywords:
+  - getIntlayer
+  - dictionary
+  - content
+  - selector
+  - Intlayer
+  - intlayer
+  - Internationalization
+  - Documentation
+  - JavaScript
+  - TypeScript
+slugs:
+  - doc
+  - packages
+  - intlayer
+  - getIntlayer
+history:
+  - version: 9.4.0
+    date: 2026-08-23
+    changes: "Initial documentation"
+author: aymericzip
+---
+
+# Documentação: Função `getIntlayer` em `intlayer`
+
+## Descrição
+
+A função `getIntlayer` seleciona um dicionário pela sua chave e retorna seu conteúdo interpretado para uma determinada localidade. É o equivalente agnóstico de framework do hook `useIntlayer`: mesmo conteúdo, mesmos seletores, mas utilizável em qualquer lugar onde um contexto React não está disponível — scripts Node, funções de servidor, carregadores de rotas, construtores de metadados, manipuladores Express/Fastify, testes.
+
+Ela lê os dicionários gerados pelo Intlayer em `.intlayer/`, então o argumento `key` é digitado e autocompletado a partir de suas próprias declarações de conteúdo, e o objeto retornado é totalmente digitado até cada folha.
+
+**Principais Recursos:**
+
+- Chaves de dicionário digitadas e conteúdo retornado digitado
+- Interpreta cada nó de conteúdo (`t()`, `enu()`, `cond()`, `insert()`, `nest()`, `md()`, `html()`, `file()`, `gender()`)
+- Aceita uma localidade ou um objeto seletor (coleções, variantes)
+- Os resultados são memorizados por `key + locale + selector`
+- Retorna a um proxy seguro em desenvolvimento quando um dicionário está faltando, em vez de travar
+
+---
+
+## Assinatura da Função
+
+```typescript
+getIntlayer(
+  key: DictionaryKeys,                        // Obrigatório
+  localeOrSelector?: LocalesValues | DictionarySelector, // Opcional
+  plugins?: Plugins[]                         // Opcional
+): DeepTransformContent<...>
+```
+
+---
+
+## Parâmetros
+
+- `key: DictionaryKeys`
+  - **Description**: A chave do dicionário a ler, conforme declarado nos seus arquivos de conteúdo.
+  - **Type**: `DictionaryKeys` — uma união de cada chave de dicionário declarada.
+  - **Required**: Yes
+
+- `localeOrSelector: LocalesValues | DictionarySelector`
+  - **Description**: O locale para interpretar o conteúdo, ou um objeto seletor para [dicionários dinâmicos](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/dynamic_dictionaries/index.md).
+    - `'fr'` — um locale
+    - `{ item: 2 }` — um item de [coleção](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/dynamic_dictionaries/collections.md) (omita `item` para obter cada item como um array)
+    - `{ variant: 'black-friday' }` — uma [variante](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/dynamic_dictionaries/variants.md) nomeada (omita para a variante `default`)
+    - `{ variant: { id: 'prod_abc', userId: '123' } }` — uma variante estruturada
+    - Qualquer seletor pode levar um locale: `{ item: 2, locale: 'fr' }`
+  - **Type**: `LocalesValues | DictionarySelector`
+  - **Required**: No (Optional) — padrão para o `defaultLocale` configurado.
+
+- `plugins: Plugins[]`
+  - **Description**: Transformadores de nó personalizados que substituem os plugins do interpretador base. Uso avançado apenas; omita para manter o comportamento padrão.
+  - **Type**: `Plugins[]`
+  - **Required**: No (Optional)
+
+### Retorna
+
+- **Tipo**: O conteúdo interpretado do dicionário, tipado a partir da sua declaração.
+- **Descrição**: Um objeto simples espelhando o campo `content` do seu dicionário, onde cada nó Intlayer foi resolvido para seu valor final para a locale solicitada.
+
+---
+
+## Exemplo de Uso
+
+### Uso Básico
+
+```typescript fileName="src/app.content.ts" codeFormat="typescript"
+import { t, type Dictionary } from "intlayer";
+
+const appContent = {
+  key: "app",
+  content: {
+    title: t({
+      pt: "Olá",
+      en: "Hello",
+      fr: "Bonjour",
+    }),
+  },
+} satisfies Dictionary;
+
+export default appContent;
+```
+
+```typescript codeFormat={["typescript", "esm", "commonjs"]}
+import { getIntlayer } from "intlayer";
+
+const { title } = getIntlayer("app", "pt"); // "Olá"
+```
+
+### Sem um locale
+
+Omitir o locale interpreta o conteúdo com o `defaultLocale` declarado em sua [configuração](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/configuration.md).
+
+```typescript
+import { getIntlayer } from "intlayer";
+
+const { title } = getIntlayer("app"); // Interpretado com o locale padrão
+```
+
+### Dentro de um manipulador de servidor
+
+```typescript fileName="src/routes/greeting.ts" codeFormat="typescript"
+import { getIntlayer, getLocale } from "intlayer";
+
+export const greetingHandler = async (request: Request) => {
+  const locale = await getLocale({
+    getHeader: (name) => request.headers.get(name) ?? undefined,
+  });
+
+  const { title } = getIntlayer("app", locale);
+
+  return Response.json({ title });
+};
+```
+
+### Com um seletor (coleções e variantes)
+
+```typescript
+import { getIntlayer } from "intlayer";
+
+// Um único item da coleção
+const secondPost = getIntlayer("blog-post", { item: 2, locale: "fr" });
+
+// Cada item da coleção, como um array ordenado
+const allPosts = getIntlayer("blog-post", { locale: "fr" });
+
+// Uma variante nomeada
+const banner = getIntlayer("banner", { variant: "black-friday", locale: "fr" });
+```
+
+---
+
+## Notas de Comportamento
+
+### Armazenamento em cache
+
+Os resultados são memoizados em um cache de nível de módulo com chave `key + locale + selector`. Chamar `getIntlayer("app", "fr")` repetidamente interpreta o dicionário uma vez e retorna o mesmo objeto depois.
+
+### Dicionários faltantes
+
+Em desenvolvimento, solicitar uma chave que não possui um dicionário gerado registra um aviso uma vez e retorna um proxy de fallback seguro: ler `content.title` fornece a string `"app.title"` em vez de lançar um erro. Isso mantém uma página utilizável enquanto a declaração faltante é corrigida. Execute a compilação do Intlayer (ou o servidor de desenvolvimento) para que o dicionário seja gerado.
+
+### Tamanho do bundle
+
+`getIntlayer` lê o dicionário mesclado, que contém **todos** os locales. Em bundles de cliente, os [plugins de build](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/bundle_optimization.md) reescrevem a chamada para que apenas o conteúdo necessário seja enviado. Quando você lê conteúdo fora da renderização (metadados, loaders, funções de servidor) e deseja um único locale carregado sob demanda, use [`getIntlayerAsync`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/packages/intlayer/getIntlayerAsync.md) em vez disso.
+
+---
+
+## Funções Relacionadas
+
+- [`getIntlayerAsync`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/packages/intlayer/getIntlayerAsync.md): Contraparte assíncrona que carrega um único chunk de locale.
+- [`getDictionary`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/packages/intlayer/getDictionary.md): Interpreta um objeto de dicionário que você passa você mesmo, em vez de um procurado por chave.
+- [`useIntlayer`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/packages/react-intlayer/useIntlayer.md): O equivalente do React hook, lendo o locale do provider.
+
+---
+
+## TypeScript
+
+```typescript
+function getIntlayer<
+  const T extends DictionaryKeys,
+  const A extends LocalesValues | DictionarySelector = DeclaredLocales,
+>(
+  key: T,
+  localeOrSelector?: A,
+  plugins?: Plugins[]
+): DeepTransformContent<
+  DictionaryRegistryResult<T, A>,
+  IInterpreterPluginState,
+  ExtractSelectorLocale<A>
+>;
+```

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

@@ -0,0 +1,141 @@
+---
+createdAt: 2026-08-23
+updatedAt: 2026-08-23
+title: getIntlayerAsync Function Documentation | intlayer
+description: Veja como usar a função getIntlayerAsync para o pacote intlayer
+keywords:
+  - getIntlayerAsync
+  - dictionary
+  - dynamic import
+  - metadata
+  - bundle optimization
+  - Intlayer
+  - intlayer
+  - Internationalization
+  - Documentation
+  - JavaScript
+  - TypeScript
+slugs:
+  - doc
+  - packages
+  - intlayer
+  - getIntlayerAsync
+history:
+  - version: 9.4.0
+    date: 2026-08-23
+    changes: "Initial documentation"
+author: aymericzip
+---
+
+# Documentação: Função `getIntlayerAsync` em `intlayer`
+
+## Descrição
+
+A função `getIntlayerAsync` seleciona um dicionário pela sua chave e resolve seu conteúdo para uma localidade específica, **carregando apenas essa localidade**.
+
+É o equivalente assíncrono de [`getIntlayer`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/packages/intlayer/getIntlayer.md), destinado aos locais onde um dicionário é lido fora da renderização — construtores de rota `head` / metadados, loaders, funções de servidor.
+
+Enquanto `getIntlayer` carrega o dicionário mesclado contendo cada localidade, os [plugins de build](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/bundle_optimization.md) (`@intlayer/babel`, `@intlayer/swc`) reescrevem esta chamada em `getDictionaryAsync(loaderMap, key, locale)`, apontando para os chunks por localidade em `.intlayer/dynamic_dictionaries/`. O bundle portanto nunca carrega mais do que a localidade realmente solicitada.
+
+Sem esses plugins — uma build não otimizada — a chamada é resolvida através do registro de dicionário síncrono: o mesmo conteúdo, sem a divisão por localidade.
+
+**Principais Funcionalidades:**
+
+- As mesmas chaves digitadas, seletores e conteúdo retornado que `getIntlayer`
+- Carrega apenas o chunk da localidade solicitada em builds otimizadas
+- Chamadas simultâneas para o mesmo chunk compartilham um único carregamento
+- Seguro de usar em construtores de metadados `async`, loaders e funções de servidor
+
+---
+
+## Function Signature
+
+```typescript
+getIntlayerAsync(
+  key: DictionaryKeys,                        // Obrigatório
+  localeOrSelector?: LocalesValues | DictionarySelector, // Opcional
+  plugins?: Plugins[]                         // Opcional
+): Promise<DeepTransformContent<...>>
+```
+
+---
+
+## Parâmetros
+
+- `key: DictionaryKeys`
+  - **Description**: A chave do dicionário a ser lida, conforme declarado em seus arquivos de conteúdo.
+  - **Type**: `DictionaryKeys` — uma união de todas as chaves de dicionário declaradas.
+  - **Required**: Yes
+
+- `localeOrSelector: LocalesValues | DictionarySelector`
+  - **Description**: A localidade para interpretar o conteúdo, ou um objeto seletor para [dicionários dinâmicos](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/dynamic_dictionaries/index.md).
+    - `'fr'` — uma localidade
+    - `{ item: 2 }` — um item de [coleção](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/dynamic_dictionaries/collections.md) (omita `item` para obter todos os itens como um array)
+    - `{ variant: 'black-friday' }` — uma [variante](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/dynamic_dictionaries/variants.md) nomeada (omita para a `default`)
+    - `{ variant: { id: 'prod_abc', userId: '123' } }` — uma variante estruturada
+    - Qualquer seletor pode carregar uma localidade: `{ item: 2, locale: 'fr' }`
+  - **Type**: `LocalesValues | DictionarySelector`
+  - **Required**: No (Optional) — defaults to the configured `defaultLocale`.
+
+- `plugins: Plugins[]`
+  - **Description**: Transformadores de nó customizados que substituem os plugins do interpretador base. Apenas para uso avançado.
+  - **Type**: `Plugins[]`
+  - **Required**: No (Optional)
+
+### Retorna
+
+- **Type**: `Promise<Content>` — uma promessa que resolve para o conteúdo interpretado do dicionário, tipado a partir da sua declaração.
+
+---
+
+## Exemplo de Uso
+
+### Uso Básico
+
+```typescript codeFormat={["typescript", "esm", "commonjs"]}
+import { getIntlayerAsync } from "intlayer";
+
+const { title } = await getIntlayerAsync("app", "fr"); // "Bonjour"
+```
+
+---
+
+## `getIntlayer` vs `getIntlayerAsync`
+
+|                    | [`getIntlayer`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/packages/intlayer/getIntlayer.md) | `getIntlayerAsync`                                        |
+| ------------------ | --------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------- |
+| Returns            | O conteúdo                                                                                                      | Uma promise do conteúdo                                   |
+| Dictionary loaded  | O dicionário mesclado (todos os locales)                                                                        | O chunk do locale solicitado apenas                       |
+| Best suited for    | Renderização, caminhos de código síncronos                                                                      | Metadata, loaders, funções de servidor                    |
+| Requires a plugin? | Não                                                                                                             | Não — a divisão por locale necessita dos plugins de build |
+
+Both accept the same arguments and return the same content: switching from one to the other only changes **when** and **how much** is loaded.
+
+---
+
+## Funções Relacionadas
+
+- [`getIntlayer`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/packages/intlayer/getIntlayer.md): Equivalente síncrono que lê o dicionário mesclado.
+- [`getDictionaryAsync`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/packages/intlayer/getDictionaryAsync.md): A função de nível inferior que os plugins de build reescrevem esta chamada em.
+- [`getLocale`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/packages/intlayer/getLocale.md): Detecta o locale de uma requisição de entrada.
+
+---
+
+## TypeScript
+
+```typescript
+function getIntlayerAsync<
+  const T extends DictionaryKeys,
+  const A extends LocalesValues | DictionarySelector = DeclaredLocales,
+>(
+  key: T,
+  localeOrSelector?: A,
+  plugins?: Plugins[]
+): Promise<
+  DeepTransformContent<
+    DictionaryRegistryResult<T, A>,
+    IInterpreterPluginState,
+    ExtractSelectorLocale<A>
+  >
+>;
+```

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

@@ -31,6 +31,8 @@ author: aymericzip
 
 A função `getLocalizedPath` converte um caminho canônico (caminho interno da aplicação) em seu equivalente localizado com base no locale fornecido e nas regras de reescrita. É particularmente útil para gerar URLs amigáveis para SEO que variam por idioma.
 
+É a contrapartida relativa de [`getLocalizedUrl`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/packages/intlayer/getLocalizedUrl.md) — para uma entrada relativa, ambas retornam o mesmo valor. Ao contrário de `getLocalizedUrl`, nunca retorna uma URL absoluta: a configuração `domains` é ignorada, portanto uma locale servida do seu próprio domínio ainda produz um caminho. Uma entrada absoluta é aceita, mas sua origem é descartada — apenas seu caminho, string de consulta e hash são mantidos.
+
 **Recursos principais:**
 
 - Suporta parâmetros de rota dinâmicos usando a sintaxe `[param]`.
@@ -60,18 +62,23 @@ getLocalizedPath(
   - **Tipo**: `string`
   - **Obrigatório**: Sim
 
-- `locale: Locales`
-  - **Descrição**: O locale alvo para o qual o caminho deve ser localizado.
-  - **Tipo**: `Locales`
-  - **Obrigatório**: Sim
-
 ### Parâmetros Opcionais
 
+- `locale?: Locales`
+  - **Description**: O locale de destino para o qual o caminho deve ser localizado.
+  - **Type**: `Locales`
+  - **Default**: O locale padrão da configuração do seu projeto.
+
 - `rewriteRules?: RoutingConfig['rewrite']`
   - **Descrição**: Um objeto que define regras de reescrita personalizadas. Se não for fornecido, assume por padrão a propriedade `routing.rewrite` da configuração do seu projeto.
   - **Tipo**: `RoutingConfig['rewrite']`
   - **Padrão**: `configuration.routing.rewrite`
 
+  - `options.locales?: Locales[]` — locales suportados. **Padrão**: `configuration.internationalization.locales`
+  - `options.defaultLocale?: Locales` — o locale padrão. **Padrão**: `configuration.internationalization.defaultLocale`
+  - `options.mode?: 'prefix-no-default' | 'prefix-all' | 'no-prefix' | 'search-params'` — como o locale aparece no caminho. **Padrão**: `configuration.routing.mode`
+  - `options.rewrite?: RoutingConfig['rewrite']` — regras de reescrita personalizadas. **Padrão**: `configuration.routing.rewrite`
+
 ---
 
 ## Retorna
@@ -79,6 +86,28 @@ getLocalizedPath(
 - **Tipo**: `string`
 - **Descrição**: O caminho localizado para o locale especificado.
 
+O tipo é estreitado a partir das regras de reescrita declaradas na sua configuração, portanto o editor mostra o caminho resolvido em vez de uma simples `string`:
+
+```typescript codeFormat="typescript"
+// Configuração: modo 'prefix-no-default', defaultLocale 'en',
+//                { '/about': { fr: '/a-propos' }, '/product/[id]': { fr: '/produit/[id]' } }
+const about = getLocalizedPath("/about", Locales.FRENCH);
+//    ^? '/fr/a-propos'
+const product = getLocalizedPath("/product/123", Locales.FRENCH);
+//    ^? '/fr/produit/123'
+const contact = getLocalizedPath("/contact", Locales.FRENCH);
+//    ^? '/fr/contact'  (nenhuma regra de reescrita corresponde, apenas o prefixo é aplicado)
+const home = getLocalizedPath("/", Locales.FRENCH);
+//    ^? '/fr'
+```
+
+O mesmo narrowing flui para [`getLocalizedUrl`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/packages/intlayer/getLocalizedUrl.md), que aplica as regras de rewrite antes de prefixar a locale.
+
+Dois casos permanecem ampliados para `string`, porque não podem ser resolvidos em tempo de compilação:
+
+- um caminho que não é um string literal (por exemplo, um construído a partir de uma variável);
+- um caminho correspondido por uma regra usando um parâmetro multi-segmento ou opcional (`[...slug]`, `[[...slug]]`, `:param?`).
+
 ---
 
 ## Exemplo de Uso
@@ -126,6 +155,18 @@ getLocalizedPath("/contact", Locales.FRENCH, manualRules);
 // Output: "/contactez-nous"
 ```
 
+### Omitindo a Locale
+
+Quando nenhuma locale é fornecida, o caminho é localizado para a locale padrão configurada:
+
+```typescript codeFormat="typescript"
+import { getLocalizedPath } from "intlayer";
+
+// Configuração: defaultLocale = Locales.ENGLISH, { '/about': { en: '/about', fr: '/a-propos' } }
+getLocalizedPath("/about");
+// Saída: "/about"
+```
+
 ---
 
 ## Funções Relacionadas

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

@@ -143,36 +143,6 @@ getLocalizedUrl(
 // Saída: "/about" para o locale padrão (inglês)
 ```
 
-```javascript codeFormat="esm"
-import { getLocalizedUrl, Locales } from "intlayer";
-
-getLocalizedUrl(
-  "/about",
-  Locales.FRENCH,
-  [Locales.ENGLISH, Locales.FRENCH],
-  Locales.ENGLISH,
-  false
-);
-
-// Saída: "/fr/about" para o locale francês
-// Saída: "/about" para o locale padrão (inglês)
-```
-
-```javascript codeFormat="commonjs"
-const { getLocalizedUrl, Locales } = require("intlayer");
-
-getLocalizedUrl(
-  "/about",
-  Locales.FRENCH,
-  [Locales.ENGLISH, Locales.FRENCH],
-  Locales.ENGLISH,
-  false
-);
-
-// Saída: "/fr/about" para o locale francês
-// Saída: "/about" para o locale padrão (inglês)
-```
-
 ### Sobrescrita Parcial de Configuração
 
 Você também pode fornecer apenas alguns dos parâmetros opcionais. A função usará a configuração do seu projeto para qualquer parâmetro que você não especificar:
@@ -249,6 +219,12 @@ getLocalizedUrl(
 - **Locales Não Suportados:**
   - Para locales não listados em `locales`, a função não aplica nenhum prefixo.
 
+- **Modos de Roteamento:**
+  - `'prefix-no-default'`: Local padrão sem prefixo, outros com prefixo (ex: `/about`, `/fr/about`)
+  - `'prefix-all'`: Todos os locais com prefixos (ex: `/en/about`, `/fr/about`)
+  - `'no-prefix'`: Sem prefixos de locale nas URLs (locale tratado em outro lugar)
+  - `'search-params'`: Locale especificado via parâmetro de query (ex: `/about?locale=fr`)
+
 ---
 
 ## Uso em Aplicações

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

@@ -31,6 +31,14 @@ author: aymericzip
 
 A função `getMultilingualUrls` gera um mapeamento de URLs multilíngues prefixando a URL fornecida com cada localidade suportada. Ela pode lidar tanto com URLs absolutas quanto relativas, aplicando o prefixo de localidade apropriado com base na configuração fornecida ou nos padrões.
 
+**Principais Recursos:**
+
+- Apenas 1 parâmetro é obrigatório: `url`
+- Objeto `options` opcional com `locales`, `defaultLocale`, e `mode`
+- Usa a configuração de internacionalização do seu projeto como padrões
+- Suporta múltiplos modos de roteamento: `prefix-no-default`, `prefix-all`, `no-prefix`, e `search-params`
+- Retorna um objeto de mapeamento com todas as locales como chaves e suas URLs correspondentes como valores
+
 ---
 
 ## Assinatura da Função
@@ -139,8 +147,6 @@ getMultilingualUrls(
 // }
 ```
 
----
-
 ### Diferentes Modos de Roteamento
 
 ```typescript
@@ -206,6 +212,12 @@ getMultilingualUrls("/dashboard", {
 - **Localidades Não Suportadas:**
   - Apenas as localidades fornecidas no array `locales` são consideradas para gerar as URLs.
 
+- **Modos de Roteamento:**
+  - `'prefix-no-default'`: Locale padrão sem prefixo, outras com prefixo (ex: `/dashboard`, `/fr/dashboard`)
+  - `'prefix-all'`: Todos os locales com prefixos (ex: `/en/dashboard`, `/fr/dashboard`)
+  - `'no-prefix'`: Sem prefixos de locale nas URLs (todos os locales retornam a mesma URL)
+  - `'search-params'`: Locale especificado via parâmetro de query (ex: `/dashboard?locale=fr`)
+
 ---
 
 ## Uso em Aplicações

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

@@ -31,6 +31,8 @@ author: aymericzip
 
 A função `getTranslationContent` recupera o conteúdo correspondente a um local específico a partir de um conjunto de conteúdo de idioma personalizável. Se o local especificado não for encontrado, ela retorna por padrão o conteúdo do local padrão configurado no projeto.
 
+Para mais detalhes sobre como declarar traduções, consulte a [documentação de Tradução](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/dictionary/translation.md).
+
 ## Parâmetros
 
 - `languageContent: CustomizableLanguageContent<Content>`

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

@@ -102,37 +102,6 @@ export const ServerComponentExample: FC = () => (
 );
 ```
 
-###Traduções Inline em Atributos
-
-A função `t` é particularmente útil para traduções inline em atributos JSX.
-Ao localizar atributos como `alt`, `title`, `href` ou `aria-label`, você pode usar `t` diretamente dentro do atributo.
-
-```jsx
-<button
-  aria-label={t({
-    en: "Submit",
-    fr: "Soumettre",
-    es: "Enviar",
-  })}
->
-  {t({
-    en: "Submit",
-    fr: "Soumettre",
-    es: "Enviar",
-  })}
-  <img
-    src="/path/to/image"
-    alt={t({
-      en: "A beautiful scenery",
-      fr: "Un beau paysage",
-      es: "Un hermoso paisaje",
-    })}
-  />
-</button>
-```
-
----
-
 ### Traduções Inline em Atributos
 
 A função `t` é particularmente útil para traduções inline em atributos JSX.
@@ -192,6 +161,23 @@ No `next-intlayer`, a localidade atual é gerida através de provedores de conte
 
 #### Exemplo:
 
+<Tabs>
+ <Tab label='Intlayer >=9.4' value='>=9.4'>
+
+```tsx codeFormat={["typescript", "esm", "commonjs"]}
+import type { FC, ReactNode } from "react";
+import type { Locales } from "intlayer";
+import { IntlayerProvider } from "next-intlayer/server";
+
+const Page: FC<{ locale: Locales; children: ReactNode }> = ({
+  locale,
+  children,
+}) => <IntlayerProvider locale={locale}>{children}</IntlayerProvider>;
+```
+
+ </Tab>
+ <Tab label='Intlayer <9.4' value='<9.4'>
+
 ```tsx codeFormat={["typescript", "esm", "commonjs"]}
 import type { FC } from "react";
 import type { Locales } from "intlayer";
@@ -207,6 +193,9 @@ const Page: FC<{ locale: Locales }> = ({ locale }) => (
 );
 ```
 
+</Tab>
+</Tabs>
+
 ---
 
 ## Erros Comuns e Solução de Problemas

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

@@ -79,6 +79,34 @@ Instruções para configurar arquivos de declaração de conteúdo estão dispon
 
 Veja como você pode implementar o hook `useIntlayer` dentro de uma página Next.js para carregar dinamicamente conteúdo localizado com base no locale atual da aplicação:
 
+<Tabs>
+ <Tab label='Intlayer >=9.4' value='>=9.4'>
+
+```tsx fileName="src/pages/[locale]/index.tsx" codeFormat={["typescript", "esm"]}
+import { ClientComponentExample } from "@components/ClientComponentExample";
+import { ServerComponentExample } from "@components/ServerComponentExample";
+import { type NextPageIntlayer } from "next-intlayer";
+import { useIntlayer } from "next-intlayer";
+import { IntlayerProvider } from "next-intlayer/server";
+
+const HomePage: NextPageIntlayer = async ({ params }) => {
+  const { locale } = await params;
+
+  const content = useIntlayer("homepage", locale);
+
+  return (
+    <IntlayerProvider locale={locale}>
+      <p>{content.introduction}</p>
+      <ClientComponentExample />
+      <ServerComponentExample />
+    </IntlayerProvider>
+  );
+};
+```
+
+ </Tab>
+ <Tab label='Intlayer <9.4' value='<9.4'>
+
 ```tsx fileName="src/pages/[locale]/index.tsx" codeFormat={["typescript", "esm"]}
 import { ClientComponentExample } from "@components/ClientComponentExample";
 import { ServerComponentExample } from "@components/ServerComponentExample";
@@ -104,6 +132,9 @@ const HomePage: NextPageIntlayer = async ({ params }) => {
 };
 ```
 
+ </Tab>
+</Tabs>
+
 ```tsx fileName="src/components/ClientComponentExample.tsx" codeFormat={["typescript", "esm"]}
 "use-client";
 

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

@@ -104,6 +104,8 @@ O hook `useLocale` aceita os seguintes parâmetros:
 
 ## Valores de Retorno
 
+Quando você invoca o hook `useLocale`, ele retorna um objeto contendo as seguintes propriedades:
+
 - **`locale`**: O local atual definido no contexto do React.
 - **`defaultLocale`**: O local principal definido na configuração.
 - **`availableLocales`**: Uma lista de todos os locais disponíveis conforme definido na configuração.

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

@@ -30,8 +30,6 @@ Esta seção fornece orientações detalhadas sobre o uso do hook `useDictionary
 
 ## Exemplo de Uso no React
 
-Abaixo está um exemplo de como usar o hook `useDictionary` em um componente React:
-
 ```tsx fileName="./ComponentExample.tsx" codeFormat={["typescript", "esm"]}
 import type { FC } from "react";
 import { useDictionary } from "react-intlayer";