@intlayer/docs 8.12.5-canary.0 → 9.0.0-canary.10

package/docs/pt/packages/solid-intlayer/usePathname.md

@@ -0,0 +1,119 @@
+---
+createdAt: 2026-06-22
+updatedAt: 2026-06-22
+title: Documentação do Hook usePathname | solid-intlayer
+description: Veja como utilizar o hook usePathname do pacote solid-intlayer
+keywords:
+  - usePathname
+  - pathname
+  - locale
+  - Intlayer
+  - Internacionalização
+  - Documentação
+  - Solid
+  - Solid.js
+  - JavaScript
+slugs:
+  - doc
+  - packages
+  - solid-intlayer
+  - usePathname
+history:
+  - version: 10.0.0
+    date: 2026-06-23
+    changes: "Adicionar o utilitário usePathname"
+  - version: 8.2.0
+    date: 2026-06-22
+    changes: "Init history"
+author: aymericzip
+---
+
+# Integração com Solid: Documentação do Hook `usePathname`
+
+O hook `usePathname` retorna o pathname do navegador atual com o segmento de locale removido, na forma de um `Accessor<string>` do Solid. É útil para a navegação com reconhecimento de locale — por exemplo, determinar qual item de navegação está ativo — sem a necessidade de remover manualmente o prefixo de locale.
+
+## Importando `usePathname` no Solid
+
+```typescript
+import { usePathname } from "solid-intlayer";
+```
+
+## Visão Geral
+
+O `usePathname` cria um sinal reativo inicializado a partir de `window.location.pathname`, remove o prefixo do locale via `getPathWithoutLocale` e atualiza o sinal sempre que o navegador aciona um evento `popstate` (navegação avançar/voltar). O ouvinte de evento é limpo automaticamente via `onCleanup`.
+
+## Uso
+
+```tsx fileName="src/components/NavItem.tsx"
+import type { Component } from "solid-js";
+import { usePathname } from "solid-intlayer";
+
+type NavItemProps = {
+  href: string;
+  label: string;
+};
+
+const NavItem: Component<NavItemProps> = ({ href, label }) => {
+  const pathname = usePathname();
+
+  return (
+    <a href={href} aria-current={pathname() === href ? "page" : undefined}>
+      {label}
+    </a>
+  );
+};
+
+export default NavItem;
+```
+
+## Valor de Retorno
+
+| Tipo               | Descrição                                                                                |
+| ------------------ | ---------------------------------------------------------------------------------------- |
+| `Accessor<string>` | Accessor do Solid (getter reativo) que retorna o pathname atual sem o prefixo do locale. |
+
+## Comportamento
+
+- **Remoção de Locale**: Remove o segmento inicial do locale (ex. `/pt/dashboard` → `/dashboard`).
+- **Reativo**: Atualiza automaticamente em eventos `popstate` (navegação voltar/avançar no navegador).
+- **Seguro em SSR**: Retorna `""` quando o `window` não está disponível.
+- **Limpeza**: O ouvinte `popstate` é removido automaticamente por meio do `onCleanup` do Solid.
+
+## Exemplo
+
+```tsx fileName="src/components/Sidebar.tsx"
+import type { Component } from "solid-js";
+import { For } from "solid-js";
+import { usePathname } from "solid-intlayer";
+
+const links = [
+  { href: "/dashboard", label: "Dashboard" },
+  { href: "/settings", label: "Configurações" },
+];
+
+const Sidebar: Component = () => {
+  const pathname = usePathname();
+
+  return (
+    <nav>
+      <For each={links}>
+        {({ href, label }) => (
+          <a
+            href={href}
+            style={{ "font-weight": pathname() === href ? "bold" : "normal" }}
+          >
+            {label}
+          </a>
+        )}
+      </For>
+    </nav>
+  );
+};
+
+export default Sidebar;
+```
+
+## Relacionado
+
+- [`useLocale`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/packages/solid-intlayer/useLocale.md) — locale atual + alternador de locale
+- [`getPathWithoutLocale`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/packages/intlayer/getPathWithoutLocale.md) — utilitário subjacente usado por este hook

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

@@ -14,6 +14,9 @@ slugs:
   - svelte-intlayer
   - exports
 history:
+  - version: 10.0.0
+    date: 2026-06-23
+    changes: "Adicionar utilitário usePathname"
   - version: 8.0.0
     date: 2026-01-21
     changes: "Documentação unificada para todas as exportações"
@@ -71,6 +74,7 @@ import "svelte-intlayer";
 | `useDictionaryAsync`   | Mesmo que `useDictionary`, mas lida com dicionários assíncronos.                                                                     | -                                                                                                                        |
 | `useDictionaryDynamic` | Mesmo que `useDictionary`, mas lida com dicionários dinâmicos.                                                                       | -                                                                                                                        |
 | `useLocale`            | Retorna o locale atual e uma função para defini-lo.                                                                                  | -                                                                                                                        |
+| `usePathname`          | Retorna o pathname atual como um store `Readable<string>` com o segmento da locale removido. Reativo a `popstate`.                   | [usePathname](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/packages/svelte-intlayer/usePathname.md)     |
 | `useRewriteURL`        | Função do lado do cliente para gerir reescritas de URL. Atualiza automaticamente a URL se existir uma regra de reescrita localizada. | [useRewriteURL](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/packages/svelte-intlayer/useRewriteURL.md) |
 | `useIntl`              | Retorna o objeto Intl para o locale atual.                                                                                           | -                                                                                                                        |
 

package/docs/pt/packages/svelte-intlayer/usePathname.md

@@ -0,0 +1,103 @@
+---
+createdAt: 2026-06-22
+updatedAt: 2026-06-22
+title: Documentação da Função usePathname | svelte-intlayer
+description: Veja como usar a função usePathname do pacote svelte-intlayer
+keywords:
+  - usePathname
+  - pathname
+  - locale
+  - Intlayer
+  - Internacionalização
+  - Documentação
+  - Svelte
+  - JavaScript
+slugs:
+  - doc
+  - packages
+  - svelte-intlayer
+  - usePathname
+history:
+  - version: 10.0.0
+    date: 2026-06-23
+    changes: "Adicionar utilitário usePathname"
+  - version: 8.2.0
+    date: 2026-06-22
+    changes: "Inicializar histórico"
+author: aymericzip
+---
+
+# Integração com Svelte: Documentação da `usePathname`
+
+A função `usePathname` retorna o pathname atual do navegador com o segmento da locale removido, como um store Svelte `Readable<string>`. É útil para construir navegação com reconhecimento de locale — por exemplo, determinar qual item de navegação está ativo — sem ter que remover o prefixo da locale manualmente.
+
+## Importando `usePathname` no Svelte
+
+```typescript
+import { usePathname } from "svelte-intlayer";
+```
+
+## Visão Geral
+
+`usePathname` cria um store legível Svelte que lê `window.location.pathname`, remove o prefixo da locale através de `getPathWithoutLocale`, e emite um novo valor sempre que o navegador dispara um evento `popstate` (navegação voltar/avançar). Subscreva com a sintaxe de store `$` em componentes.
+
+## Uso
+
+```svelte fileName="src/components/NavItem.svelte"
+<script lang="ts">
+  import { usePathname } from "svelte-intlayer";
+
+  export let href: string;
+  export let label: string;
+
+  const pathname = usePathname();
+</script>
+
+<a {href} aria-current={$pathname === href ? "page" : undefined}>
+  {label}
+</a>
+```
+
+## Valor de Retorno
+
+| Tipo               | Descrição                                                                  |
+| ------------------ | -------------------------------------------------------------------------- |
+| `Readable<string>` | Store legível do Svelte contendo o pathname atual sem o prefixo da locale. |
+
+## Comportamento
+
+- **Remoção da locale**: Remove o segmento inicial da locale (ex: `/pt/dashboard` → `/dashboard`).
+- **Reativo**: Emite um novo valor a cada evento `popstate` (navegação de voltar/avançar do navegador).
+- **Seguro para SSR**: Retorna `""` quando `window` não está disponível.
+- **Limpeza**: O listener de `popstate` é removido automaticamente quando o último subscritor se desinscreve.
+
+## Exemplo
+
+```svelte fileName="src/components/Sidebar.svelte"
+<script lang="ts">
+  import { usePathname } from "svelte-intlayer";
+
+  const links = [
+    { href: "/dashboard", label: "Dashboard" },
+    { href: "/settings", label: "Configurações" },
+  ];
+
+  const pathname = usePathname();
+</script>
+
+<nav>
+  {#each links as link}
+    <a
+      href={link.href}
+      style:font-weight={$pathname === link.href ? "bold" : "normal"}
+    >
+      {link.label}
+    </a>
+  {/each}
+</nav>
+```
+
+## Relacionado
+
+- [`useLocale`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/packages/svelte-intlayer/useLocale.md) — locale atual + seletor de locale
+- [`getPathWithoutLocale`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/packages/intlayer/getPathWithoutLocale.md) — o utilitário subjacente usado por este hook

package/docs/pt/packages/vite-intlayer/intlayerCompiler.md

@@ -0,0 +1,120 @@
+---
+createdAt: 2026-06-25
+updatedAt: 2026-06-25
+title: Documentação do plugin Vite intlayerCompiler | vite-intlayer
+description: Plugin do Vite que extrai declarações de conteúdo embutidas do Intlayer de arquivos de componentes e as grava em arquivos JSON de dicionário no momento da compilação/transformação.
+keywords:
+  - intlayerCompiler
+  - vite
+  - plugin
+  - compilador
+  - conteúdo
+  - dicionário
+  - internacionalização
+  - i18n
+slugs:
+  - doc
+  - packages
+  - vite-intlayer
+  - intlayerCompiler
+history:
+  - version: 9.0.0
+    date: 2026-06-25
+    changes: "Integrado no intlayer(); inicialização da doc"
+author: aymericzip
+---
+
+# intlayerCompiler
+
+O `intlayerCompiler` é um plugin do Vite que varre os arquivos de código-fonte dos componentes em busca de **declarações de conteúdo embutidas do Intlayer** — conteúdo definido diretamente dentro de um componente, em vez de em um arquivo `.content.ts` separado — e as grava em arquivos JSON de dicionário durante a fase de transformação.
+
+> **A partir do Intlayer v9**, o `intlayerCompiler` é incluído automaticamente dentro do plugin principal [`intlayer()`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/packages/vite-intlayer/intlayer.md) quando `compiler.enabled` é `true` e `compiler.output` está configurado nas suas configurações do Intlayer. Você só precisa registrá-lo separadamente quando desejar controle total sobre as configurações específicas do compilador.
+
+## Uso
+
+### Como parte do `intlayer()` (recomendado, v9+)
+
+Ative o compilador através das configurações do Intlayer:
+
+```ts
+// intlayer.config.ts
+import { defineConfig } from "intlayer";
+
+export default defineConfig({
+  compiler: {
+    enabled: true,
+    output: "./src/dictionaries", // onde os dicionários extraídos são gravados
+  },
+});
+```
+
+Em seguida, use o plugin padrão sem nenhum registro adicional:
+
+```ts
+// vite.config.ts
+import { defineConfig } from "vite";
+import { intlayer } from "vite-intlayer";
+
+export default defineConfig({
+  plugins: [intlayer()],
+});
+```
+
+### Standalone (quando necessário)
+
+```ts
+// vite.config.ts
+import { defineConfig } from "vite";
+import { intlayerCompiler } from "vite-intlayer";
+
+export default defineConfig({
+  plugins: [intlayerCompiler()],
+});
+```
+
+## Opções
+
+```ts
+import type { IntlayerCompilerOptions } from "vite-intlayer";
+```
+
+| Opção            | Tipo                      | Descrição                                                                                                   |
+| ---------------- | ------------------------- | ----------------------------------------------------------------------------------------------------------- |
+| `configOptions`  | `GetConfigurationOptions` | Substituições de configuração do Intlayer encaminhadas para `getConfiguration()`.                           |
+| `compilerConfig` | `Partial<CompilerConfig>` | Substituições para a seção de configuração específica do compilador (ex: `enabled`, `output`, `filesList`). |
+
+### Exemplo
+
+```ts
+intlayerCompiler({
+  configOptions: { configFile: "./config/intlayer.config.ts" },
+  compilerConfig: { enabled: true, output: "./src/dictionaries" },
+});
+```
+
+## Como funciona
+
+### Fase de transformação
+
+Para cada arquivo fonte que corresponda a `compiler.filesList`, o plugin do compilador:
+
+1. Passa o conteúdo do arquivo através de `extractContent` do `@intlayer/babel`.
+2. Chama `onExtract` para cada declaração encontrada, gravando o JSON do dicionário resultante em `compiler.output`.
+3. Retorna o código-fonte transformado com as declarações embutidas substituídas por chamadas padrão `useIntlayer('key')` / `getIntlayer('key')`.
+
+Tipos de arquivos suportados: `.ts`, `.tsx`, `.js`, `.jsx`, `.vue`, `.svelte`, `.astro`.
+
+### HMR (Hot Module Replacement)
+
+Quando um arquivo de componente é salvo no modo de desenvolvimento, o compilador:
+
+1. Detecta a alteração do arquivo por meio do gancho (hook) `handleHotUpdate` do Vite.
+2. Extrai novamente o conteúdo do arquivo atualizado.
+3. Grava o JSON do dicionário atualizado.
+4. Dispara uma atualização completa da página (`server.ws.send({ type: 'full-reload' })`).
+
+Um debounce de 500 ms impede que a gravação do dicionário em si (que também dispara um evento de alteração de arquivo) cause um loop infinito de extração.
+
+### Eliminação de duplicatas (Deduplicação)
+
+O `intlayerCompiler` usa o mesmo mecanismo de deduplicação `createPrimaryInstanceGuard` que os outros plugins integrados. Quando tanto `intlayer()` (que empacota o compilador) quanto uma chamada manual ao `intlayerCompiler()` estão presentes, apenas a primeira instância registrada é executada — nenhum dicionário é gravado duas vezes.

package/docs/pt/packages/vite-intlayer/intlayerMinify.md

@@ -0,0 +1,92 @@
+---
+createdAt: 2026-06-25
+updatedAt: 2026-06-25
+title: Documentação do plugin Vite intlayerMinify | vite-intlayer
+description: Plugin do Vite que minifica os arquivos JSON de dicionário compilados do Intlayer e, opcionalmente, ofusca os nomes dos campos de conteúdo para reduzir o tamanho do bundle.
+keywords:
+  - intlayerMinify
+  - vite
+  - plugin
+  - minificar
+  - tamanho do bundle
+  - dicionário
+  - internacionalização
+  - i18n
+slugs:
+  - doc
+  - packages
+  - vite-intlayer
+  - intlayerMinify
+history:
+  - version: 9.0.0
+    date: 2026-06-25
+    changes: "Inicialização da doc"
+author: aymericzip
+---
+
+# intlayerMinify
+
+O `intlayerMinify` é um plugin do Vite que minifica arquivos JSON de dicionário compilados durante um build de produção. Ele remove todos os espaços em branco desnecessários e, quando combinado com o `intlayerPrune`, opcionalmente renomeia os nomes dos campos de conteúdo para apelidos (aliases) alfabéticos curtos (`a`, `b`, `c`, …) para reduzir ainda mais o tamanho do bundle.
+
+> O plugin já está incluído e configurado automaticamente quando você usa o [`intlayer()`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/packages/vite-intlayer/intlayer.md). Você só precisa registrá-lo manualmente se estiver compondo a pilha de plugins por conta própria.
+
+## Uso
+
+```ts
+// vite.config.ts
+import { defineConfig } from "vite";
+import { intlayerMinify, intlayerPrune } from "vite-intlayer";
+import { createPruneContext } from "@intlayer/babel";
+
+const pruneContext = createPruneContext();
+
+export default defineConfig({
+  plugins: [
+    intlayerPrune(intlayerConfig, pruneContext),
+    intlayerMinify(intlayerConfig, pruneContext),
+  ],
+});
+```
+
+## Condições de ativação
+
+O `intlayerMinify` fica ativo **apenas** quando todas as três condições a seguir forem verdadeiras:
+
+1. O comando do Vite é `build` (não `serve` / dev).
+2. `build.optimize` é `true` (ou `undefined`, que assume o padrão `true` para builds).
+3. `build.minify` é `true` na sua configuração do Intlayer.
+
+Ele é desativado automaticamente quando `editor.enabled` é `true` porque o editor precisa do conteúdo do dicionário completo e legível por humanos.
+
+## O que é minificado
+
+O plugin tem como alvo dois locais de dicionário (conforme resolvido a partir de `intlayer.system`):
+
+- `dictionariesDir` — dicionários estáticos de todos os idiomas (ex: `.intlayer/dictionaries/*.json`)
+- `dynamicDictionariesDir` — dicionários dinâmicos por idioma
+
+> Os dicionários no modo fetch (`fetchDictionariesDir`) **nunca** são minificados porque são servidos a partir de uma API remota em tempo de execução usando seus nomes de campo originais. Renomear os campos criaria uma incompatibilidade entre a resposta do servidor e os acessos às propriedades no lado do cliente.
+
+## Ofuscação de nomes de campos (minificação de propriedades)
+
+Quando o `intlayerPrune` analisa o código-fonte e preenche `pruneContext.dictionaryKeyToFieldRenameMap`, o `intlayerMinify` também renomeia os nomes dos campos de conteúdo para aliases curtos. Por exemplo:
+
+```json
+// antes
+{ "key": "myDict", "content": { "title": "Hello", "description": "World" } }
+
+// depois (com ofuscação)
+{ "key": "myDict", "content": { "a": "Hello", "b": "World" } }
+```
+
+Os acessos correspondentes às propriedades do arquivo fonte são renomeados pela passagem do Babel dentro do `intlayerOptimize`, de modo que o comportamento em tempo de execução permanece inalterado.
+
+Campos internos do Intlayer (`nodeType`, `translation`, etc.) nunca são renomeados.
+
+## Dicionários de casos extremos (Edge-cases)
+
+Dicionários sinalizados em `pruneContext.dictionariesWithEdgeCases` (anomalias estruturais detectadas durante a fase de eliminação) são ignorados inteiramente — não são minificados nem ofuscados — para evitar o envio de dados corrompidos.
+
+## Grupos qualificados (coleções / variantes / registros meta)
+
+Para dicionários com uma matriz `qualifierTypes` (coleções, variantes e registros meta), o plugin preserva a matriz `qualifierTypes` e o mapa lateral `meta` literalmente. Apenas as entradas de `content` têm seus nomes de campo ofuscados. As chaves compostas (usadas para correspondência de seletores em tempo de execução) nunca são tocadas.

package/docs/pt/packages/vite-intlayer/intlayerProxy.md

@@ -0,0 +1,172 @@
+---
+createdAt: 2026-06-25
+updatedAt: 2026-06-25
+title: Documentação do plugin Vite intlayerProxy | vite-intlayer
+description: Middleware de roteamento de idioma para servidores dev/preview do Vite e SSR de produção. Lida com detecção de idioma, redirecionamentos de URL e reescritas internas.
+keywords:
+  - intlayerProxy
+  - vite
+  - plugin
+  - middleware
+  - idioma
+  - roteamento
+  - internacionalização
+  - i18n
+  - SSR
+slugs:
+  - doc
+  - packages
+  - vite-intlayer
+  - intlayerProxy
+history:
+  - version: 9.0.0
+    date: 2026-06-25
+    changes: "Mesclado configOptions em um único objeto de opções; proxy empacotado no intlayer()"
+author: aymericzip
+---
+
+# intlayerProxy
+
+O `intlayerProxy` é um plugin do Vite que registra o middleware de roteamento de idioma para **todos os ambientes**: servidor de desenvolvimento (dev server), servidor de visualização (preview server) e SSR de produção (Nitro / TanStack Start).
+
+> **A partir do Intlayer v9**, o `intlayerProxy` é incluído automaticamente dentro do plugin principal [`intlayer()`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/packages/vite-intlayer/intlayer.md) e ativado por padrão via `routing.enableProxy: true`. Você só precisa registrá-lo separadamente se precisar de controle de nível mais baixo ou se estiver usando-o fora da configuração padrão do `intlayer()`.
+
+## Uso
+
+### Como parte do `intlayer()` (recomendado, v9+)
+
+Passe as opções do `proxy` para o plugin principal em vez de registrar o `intlayerProxy` separadamente:
+
+```ts
+// vite.config.ts
+import { defineConfig } from "vite";
+import { intlayer } from "vite-intlayer";
+
+export default defineConfig({
+  plugins: [
+    intlayer({
+      proxy: {
+        ignore: (req) => req.url?.startsWith("/api"),
+      },
+    }),
+  ],
+});
+```
+
+### Standalone (quando necessário)
+
+```ts
+// vite.config.ts
+import { defineConfig } from "vite";
+import { intlayer } from "vite-intlayer";
+
+export default defineConfig({
+  plugins: [intlayer()],
+});
+```
+
+## Opções
+
+```ts
+import type { IntlayerProxyPluginOptions } from "vite-intlayer";
+```
+
+Todas as opções são opcionais e passadas como um único objeto:
+
+| Opção           | Tipo                                | Descrição                                                                                                                                                                          |
+| --------------- | ----------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `ignore`        | `(req: IncomingMessage) => boolean` | Predicado que exclui requisições do roteamento de idioma. Retorne `true` para ignorar uma requisição (ex: rotas de API, verificações de integridade).                              |
+| `configOptions` | `GetConfigurationOptions`           | Substituições de configuração do Intlayer encaminhadas para `getConfiguration()`. Use quando precisar que o proxy leia um arquivo de configuração específico ou substitua valores. |
+
+### Exemplo
+
+```ts
+intlayerProxy({
+  ignore: (req) => req.url?.startsWith("/api"),
+  configOptions: { configFile: "./config/intlayer.config.ts" },
+});
+```
+
+## createIntlayerProxyHandler
+
+O `createIntlayerProxyHandler` cria um middleware Node.js `(req, res, next)` independente de framework que contém toda a lógica de roteamento de idioma. É útil em ambientes onde a API do plugin do Vite não está disponível (ex: um servidor Node.js simples ou um módulo Nitro personalizado).
+
+```ts
+import { createIntlayerProxyHandler } from "vite-intlayer";
+
+const handler = createIntlayerProxyHandler({
+  ignore: (req) => req.url?.startsWith("/api"),
+  configOptions: { configFile: "./config/intlayer.config.ts" },
+});
+
+// Express / Connect
+app.use(handler);
+```
+
+### SSR de Produção (TanStack Start / Nitro via h3)
+
+```ts
+// server/middleware/intlayerProxy.ts
+import { fromNodeMiddleware } from "h3";
+import { createIntlayerProxyHandler } from "vite-intlayer";
+
+export default fromNodeMiddleware(
+  createIntlayerProxyHandler({
+    ignore: (req) => req.url?.startsWith("/api"),
+  })
+);
+```
+
+## Comportamento de roteamento
+
+O middleware espelha a lógica de roteamento do middleware `next-intlayer` e suporta todos os modos de roteamento do Intlayer.
+
+### Modos de roteamento
+
+| Modo            | URL visível no navegador | Comportamento                                                                                                                            |
+| --------------- | ------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------- |
+| `prefix`        | `/pt/about`              | Padrão. Prefixo de idioma na URL. O idioma padrão redireciona para a URL sem prefixo, a menos que `prefix-all` esteja ativo.             |
+| `prefix-all`    | `/en/about`, `/pt/about` | Todos os idiomas — incluindo o padrão — são sempre prefixados.                                                                           |
+| `no-prefix`     | `/about`                 | Sem idioma na URL. O idioma é armazenado apenas em cookies; as reescritas de URL ocorrem internamente.                                   |
+| `search-params` | `/about?locale=pt`       | Idioma passado como um parâmetro de consulta. Redireciona para adicionar/atualizar o parâmetro `locale` quando ausente ou desatualizado. |
+
+### Prioridade de detecção
+
+1. Prefixo do caminho da URL (ex: `/pt/about` → `pt`).
+2. Valor do cookie / localStorage (`intlayer-locale`).
+3. Cabeçalho `Accept-Language`.
+4. `defaultLocale` da configuração.
+
+### Desvio automático (Bypass)
+
+O middleware sempre passa essas requisições diretamente sem manipulação de idioma:
+
+- Requisições que correspondem ao predicado `ignore`.
+- `/node_modules/**`
+- `/@**` – Recursos internos do Vite (`@vite/`, `@fs/`, `@id/`, etc.).
+- `/_**` – Recursos internos do servidor (`__vite_ping`, `__manifest`, etc.).
+- Requisições cujo caminho termina com uma extensão de arquivo (recursos estáticos). Se um prefixo de idioma estiver presente em um caminho de recurso estático (ex: `/pt/logo.png`), ele será removido para que o arquivo possa ser servido corretamente.
+
+### Roteamento por domínio
+
+Quando `routing.domains` está configurado nas suas configurações do Intlayer, o middleware lida com o roteamento de idioma entre domínios:
+
+- Uma requisição para `/zh/about` em `intlayer.org` é redirecionada para `https://intlayer.zh/about` quando `domains.zh = "intlayer.zh"`.
+- Uma requisição para `intlayer.zh/about` é reescrita internamente para `/zh/about` para que o parâmetro de rota `[locale]` seja preenchido.
+
+### Proteção contra loops de redirecionamento
+
+O middleware rastreia as contagens de redirecionamento por par `originalUrl → newUrl` dentro de uma janela deslizante de 2 segundos. Mais de 10 redirecionamentos dentro dessa janela retornam uma resposta `500` com um erro descritivo em vez de entrar em loop eterno.
+
+## Nitro / SSR de produção (injeção automática, v9+)
+
+Quando o `intlayerProxy` é usado como um plugin do Vite, ele carrega uma propriedade `.nitro`. O plugin de compilação `nitro/vite` lê esta propriedade e a insere em `nitroConfig.modules`, de modo que o `intlayerNitroHandler` é registrado como um middleware do servidor Nitro automaticamente — nenhuma configuração manual é necessária para o SSR de produção.
+
+O manipulador Nitro usa o modelo de evento Web Fetch API da h3 v2 (não o `fromNodeMiddleware`), por isso é compatível com todas as predefinições do Nitro: Node, Bun, Deno, runtimes edge.
+
+## Aliases depreciados
+
+| Exportação depreciada      | Substituição    |
+| -------------------------- | --------------- |
+| `intlayerMiddleware`       | `intlayerProxy` |
+| `intLayerMiddlewarePlugin` | `intlayerProxy` |

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

@@ -14,9 +14,12 @@ slugs:
   - vue-intlayer
   - exports
 history:
+  - version: 10.0.0
+    date: 2026-06-23
+    changes: "Adicionar utilitário usePathname"
   - version: 8.0.0
     date: 2026-01-21
-    changes: "Unified documentation for all exports"
+    changes: "Documentação unificada para todas as exportações"
 author: aymericzip
 ---
 
@@ -59,6 +62,7 @@ import "vue-intlayer";
 | `useDictionaryAsync`   | Mesmo que `useDictionary`, mas lida com dicionários assíncronos.                                                                         | -                                                                                                                     |
 | `useDictionaryDynamic` | Mesmo que `useDictionary`, mas lida com dicionários dinâmicos.                                                                           | -                                                                                                                     |
 | `useLocale`            | Retorna a locale atual e uma função para defini-la.                                                                                      | -                                                                                                                     |
+| `usePathname`          | Retorna o pathname atual como uma `ComputedRef<string>` com o segmento da locale removido. É reativo a eventos `popstate`.               | [usePathname](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/packages/vue-intlayer/usePathname.md)     |
 | `useRewriteURL`        | Composable do lado do cliente para gerir reescritas de URL. Atualiza automaticamente a URL se existir uma regra de reescrita localizada. | [useRewriteURL](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/packages/vue-intlayer/useRewriteURL.md) |
 | `useIntl`              | Retorna o objeto Intl para a localidade atual.                                                                                           | -                                                                                                                     |
 | `useLoadDynamic`       | Composable para carregar dicionários dinâmicos.                                                                                          | -                                                                                                                     |