@intlayer/docs 9.3.1 → 9.3.3

package/docs/pt/configuration.md

@@ -478,6 +478,29 @@ const config: IntlayerConfig = {
      */
     purge: true,
 
+    /**
+     * Agrupar os chunks de dicionário por idioma de acordo com o limite de
+     * code-splitting que os utiliza, para que uma página carregada de forma
+     * preguiçosa obtenha seu conteúdo em uma única requisição.
+     * Padrão: true
+     *
+     * Nota:
+     * - Aplica-se apenas a dicionários que usam `importMode: 'dynamic'`.
+     */
+    chunkGrouping: true,
+
+    /**
+     * Carregar um dicionário junto com o chunk que o utiliza, em vez de buscá-lo
+     * depois que esse chunk renderiza. Os leitores renderizam de forma síncrona em
+     * vez de suspender, então navegar não exibe mais um piscar de carregamento.
+     * Padrão: true
+     *
+     * Nota:
+     * - Apenas o idioma resolvido é aguardado, portanto a página baixa somente o
+     *   idioma que exibe.
+     */
+    dictionariesPreload: true,
+
     /**
      * Formato de saída para os ficheiros de dicionário gerados.
      * Padrão: ['cjs', 'esm']
@@ -1057,15 +1080,17 @@ As opções de build aplicam-se aos plugins `@intlayer/babel` e `@intlayer/swc`.
 
 > Durante a otimização, o Intlayer substituirá as chamadas aos dicionários para otimizar o chunking, de forma a que o bundle final importe apenas os dicionários efetivamente utilizados.
 
-| Campo             | Descrição                                                              | Tipo                             | Padrão                                                                                                                                                                            | Exemplo                                                                       | Nota                                                                                                                                                                                                                                                                                               |
-| ----------------- | ---------------------------------------------------------------------- | -------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `mode`            | Controla o modo de build.                                              | `'auto'` &#124; <br/> `'manual'` | `'auto'`                                                                                                                                                                          | `'manual'`                                                                    | • `'auto'`: build acionada automaticamente durante a build da app.<br/>• `'manual'`: executada apenas quando o comando de build é explicitamente chamado.<br/>• Pode ser usado para desativar builds de dicionários (ex: para evitar a execução em ambientes Node.js).                             |
-| `optimize`        | Controla se a build deve ser otimizada.                                | `boolean`                        | `undefined`                                                                                                                                                                       | `process.env.NODE_ENV === 'production'`                                       | • Se não definido, a otimização é acionada na build da framework (Vite/Next.js).<br/>• `true` força a otimização mesmo no modo dev.<br/>• `false` desativa-a.<br/>• Se ativo, substitui chamadas a dicionários para otimizar o chunking.<br/>• Requer plugins `@intlayer/babel` e `@intlayer/swc`. |
-| `minify`          | Minifica os dicionários para reduzir o tamanho do bundle.              | `boolean`                        | `false`                                                                                                                                                                           |                                                                               | • Indica se o bundle deve ser minificado.<br/>• Padrão: `true` em produção.<br/>• Esta opção será ignorada se `optimize` estiver desativada.<br/>• Esta opção será ignorada se `editor.enabled` for true.                                                                                          |
-| `purge`           | Purga as chaves não utilizadas nos dicionários.                        | `boolean`                        | `false`                                                                                                                                                                           |                                                                               | • Indica se o bundle deve ser limpo.<br/>• Padrão: `true` em produção.<br/>• Esta opção será ignorada se `optimize` estiver desativada.                                                                                                                                                            |
-| `checkTypes`      | Indica se a build deve verificar os tipos TypeScript e registar erros. | `boolean`                        | `false`                                                                                                                                                                           |                                                                               | Pode tornar o processo de build mais lento.                                                                                                                                                                                                                                                        |
-| `outputFormat`    | Controla o formato de saída dos dicionários.                           | `('esm' &#124; 'cjs')[]`         | `['esm', 'cjs']`                                                                                                                                                                  | `['cjs']`                                                                     |                                                                                                                                                                                                                                                                                                    |
-| `traversePattern` | Padrões que definem quais ficheiros percorrer durante a otimização.    | `string[]`                       | `['**/*.{tsx,ts,js,mjs,cjs,jsx,vue,svelte,svte}', '!**/node_modules/**', '!**/dist/**', '!**/.intlayer/**', '!**/*.config.*', '!**/*.test.*', '!**/*.spec.*', '!**/*.stories.*']` | `['src/**/*.{ts,tsx}', '../ui-library/**/*.{ts,tsx}', '!**/node_modules/**']` | • Limite a otimização a ficheiros relevantes para melhorar o desempenho da build.<br/>• Ignorado se `optimize` estiver desativado.<br/>• Utiliza padrões glob.                                                                                                                                     |
+| Campo                 | Descrição                                                                                                                          | Tipo                             | Padrão                                                                                                                                                                            | Exemplo                                                                       | Nota                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
+| --------------------- | ---------------------------------------------------------------------------------------------------------------------------------- | -------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `mode`                | Controla o modo de build.                                                                                                          | `'auto'` &#124; <br/> `'manual'` | `'auto'`                                                                                                                                                                          | `'manual'`                                                                    | • `'auto'`: build acionada automaticamente durante a build da app.<br/>• `'manual'`: executada apenas quando o comando de build é explicitamente chamado.<br/>• Pode ser usado para desativar builds de dicionários (ex: para evitar a execução em ambientes Node.js).                                                                                                                                                                                                                                                                                                                            |
+| `optimize`            | Controla se a build deve ser otimizada.                                                                                            | `boolean`                        | `undefined`                                                                                                                                                                       | `process.env.NODE_ENV === 'production'`                                       | • Se não definido, a otimização é acionada na build da framework (Vite/Next.js).<br/>• `true` força a otimização mesmo no modo dev.<br/>• `false` desativa-a.<br/>• Se ativo, substitui chamadas a dicionários para otimizar o chunking.<br/>• Requer plugins `@intlayer/babel` e `@intlayer/swc`.                                                                                                                                                                                                                                                                                                |
+| `minify`              | Minifica os dicionários para reduzir o tamanho do bundle.                                                                          | `boolean`                        | `false`                                                                                                                                                                           |                                                                               | • Indica se o bundle deve ser minificado.<br/>• Padrão: `true` em produção.<br/>• Esta opção será ignorada se `optimize` estiver desativada.<br/>• Esta opção será ignorada se `editor.enabled` for true.                                                                                                                                                                                                                                                                                                                                                                                         |
+| `purge`               | Purga as chaves não utilizadas nos dicionários.                                                                                    | `boolean`                        | `false`                                                                                                                                                                           |                                                                               | • Indica se o bundle deve ser limpo.<br/>• Padrão: `true` em produção.<br/>• Esta opção será ignorada se `optimize` estiver desativada.                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
+| `checkTypes`          | Indica se a build deve verificar os tipos TypeScript e registar erros.                                                             | `boolean`                        | `false`                                                                                                                                                                           |                                                                               | Pode tornar o processo de build mais lento.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
+| `chunkGrouping`       | Indica se os chunks de dicionário por idioma devem ser agrupados de acordo com o limite de code-splitting que os utiliza.          | `boolean`                        | `true`                                                                                                                                                                            |                                                                               | • Sem agrupamento, uma página composta por muitos componentes emite uma requisição por dicionário.<br/>• Dicionários alcançados a partir de vários limites vão para um chunk compartilhado, então nenhuma página entrega o conteúdo de outra.<br/>• Aplica-se apenas a dicionários que usam `importMode: 'dynamic'`.<br/>• Aplica-se apenas à build do cliente, e somente ao empacotar (não em desenvolvimento).                                                                                                                                                                                  |
+| `dictionariesPreload` | Indica se um dicionário deve ser carregado junto com o chunk que o utiliza, em vez de ser buscado depois que esse chunk renderiza. | `boolean`                        | `true`                                                                                                                                                                            |                                                                               | • O ponto de entrada gerado aguarda o idioma de navegação no nível superior, então uma rota carregada de forma preguiçosa não é considerada carregada até que seu conteúdo esteja disponível.<br/>• Os leitores renderizam de forma síncrona em vez de suspender, então navegar não exibe mais um piscar de carregamento.<br/>• Apenas o idioma resolvido é aguardado, portanto a página baixa somente o idioma que exibe.<br/>• Aplica-se apenas a dicionários que usam `importMode: 'dynamic'`, na build do cliente.<br/>• Requer um empacotador com suporte a top-level await (Vite, esbuild). |
+| `outputFormat`        | Controla o formato de saída dos dicionários.                                                                                       | `('esm' &#124; 'cjs')[]`         | `['esm', 'cjs']`                                                                                                                                                                  | `['cjs']`                                                                     |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| `traversePattern`     | Padrões que definem quais ficheiros percorrer durante a otimização.                                                                | `string[]`                       | `['**/*.{tsx,ts,js,mjs,cjs,jsx,vue,svelte,svte}', '!**/node_modules/**', '!**/dist/**', '!**/.intlayer/**', '!**/*.config.*', '!**/*.test.*', '!**/*.spec.*', '!**/*.stories.*']` | `['src/**/*.{ts,tsx}', '../ui-library/**/*.{ts,tsx}', '!**/node_modules/**']` | • Limite a otimização a ficheiros relevantes para melhorar o desempenho da build.<br/>• Ignorado se `optimize` estiver desativado.<br/>• Utiliza padrões glob.                                                                                                                                                                                                                                                                                                                                                                                                                                    |
 
 ---
 

package/docs/pt/dictionary/content_file.md

@@ -533,28 +533,6 @@ Usado em conjunto com as Variantes, este campo define alternativas de conteúdo
 
 > Veja [Variantes](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/dynamic_dictionaries/variants.md) para mais informações.
 
-#### `meta` (`Record<string, string | number | boolean>`)
-
-Usado em conjunto com os Registros Dinâmicos, este campo permite declarar registros gerenciados pelo CMS ou dados arbitrários buscados em tempo de execução por um ID opaco. A identidade do dicionário é definida pelo conjunto arbitrário de pares chave-valor declarados neste campo `meta`.
-
-**Exemplo:**
-
-```typescript
-{
-  key: "product-copy",
-  meta: {
-    id: "prod_abc",
-    userId: "user_123"
-  },
-  content: {
-    name: "Widget Pro",
-    description: "The best widget."
-  }
-}
-```
-
-> Veja [Registros Dinâmicos](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/dynamic_dictionaries/dynamic_content.md) para mais informações.
-
 ### Propriedades do CMS
 
 ##### `version` (string)

package/docs/pt/dictionary/function_fetching.md

@@ -89,6 +89,29 @@ Não é possível buscar conteúdo de um arquivo JSON, use um arquivo .ts ou .js
 
 Neste caso, a função `fakeFetch` simula um atraso para imitar o tempo de resposta do servidor. O Intlayer executa a função assíncrona e usa o resultado como o conteúdo para a chave `text`.
 
+## Buscando Conteúdo Remoto
+
+Você também pode atribuir uma promise diretamente a um campo de conteúdo. O Intlayer a aguarda durante a construção dos dicionários e insere o valor resolvido:
+
+```typescript fileName="**/*.content.ts" contentDeclarationFormat={["typescript", "esm", "commonjs"]}
+import type { Dictionary } from "intlayer";
+
+const remoteContent = {
+  key: "remote_content",
+  content: {
+    externalContent: fetch("https://example.com").then((res) => res.json()),
+  },
+} satisfies Dictionary;
+
+export default remoteContent;
+```
+
+```plaintext fileName="**/*.content.json" contentDeclarationFormat="json"
+Não é possível buscar conteúdo de um arquivo JSON, use um arquivo .ts ou .js em vez disso
+```
+
+> A requisição é executada em tempo de build, portanto os dados buscados são um instantâneo embutido no dicionário. Reconstrua seus dicionários para atualizá-los.
+
 ## Usando Conteúdo Baseado em Função em Componentes React
 
 Para usar conteúdo baseado em função em um componente React, você precisa importar `useIntlayer` de `react-intlayer` e chamá-lo com o ID do conteúdo para recuperar o conteúdo. Aqui está um exemplo:

package/docs/pt/eslint.md

@@ -0,0 +1,336 @@
+---
+createdAt: 2026-08-12
+updatedAt: 2026-08-13
+title: Plugin ESLint | Regras de lint para o Intlayer
+description: Detecte strings codificadas diretamente, chamadas dinâmicas que o compilador do Intlayer não consegue otimizar e conteúdo de dicionário não utilizado com eslint-plugin-intlayer. Compatível com ESLint e oxlint, no React, Vue, Svelte, Angular e Astro.
+keywords:
+  - Intlayer
+  - ESLint
+  - oxlint
+  - Linting
+  - i18n
+  - Internacionalização
+  - no-raw-text
+  - Strings codificadas diretamente
+  - Traduções não utilizadas
+  - Conteúdo morto
+  - React
+  - Vue
+  - Svelte
+  - Angular
+slugs:
+  - doc
+  - eslint
+history:
+  - version: 9.3.1
+    date: 2026-08-12
+    changes: "Histórico inicial"
+author: aymericzip
+---
+
+# Plugin ESLint x OXLint
+
+O `eslint-plugin-intlayer` detecta os tipos de erros de i18n que o TypeScript não consegue identificar:
+
+1. **Texto codificado diretamente (hardcoded)** que nunca chegou a um dicionário.
+2. **Chamadas dinâmicas** que passam na verificação de tipos e são executadas, mas que o compilador do Intlayer não consegue otimizar.
+3. **Conteúdo morto** — dicionários e campos que nada no projeto lê (ativação opcional).
+
+Chaves de dicionário desconhecidas, caminhos de campos desconhecidos e idiomas ausentes já são erros de compilação, portanto o plugin não os repete.
+
+## Instalação
+
+```bash packageManager="npm"
+npm install --save-dev eslint-plugin-intlayer
+```
+
+```bash packageManager="pnpm"
+pnpm add --save-dev eslint-plugin-intlayer
+```
+
+```bash packageManager="yarn"
+yarn add --dev eslint-plugin-intlayer
+```
+
+Requer o ESLint 9 ou superior (flat config). O ESLint 10 é compatível.
+
+## Utilização
+
+O plugin funciona tanto no ESLint quanto no [oxlint](https://oxc.rs) — com as mesmas regras e as mesmas opções.
+
+<Tabs defaultTab="eslint">
+  <Tab label="ESLint" value="eslint">
+
+```javascript fileName="eslint.config.mjs"
+import intlayer from "eslint-plugin-intlayer";
+
+export default [...intlayer.configs.recommended];
+```
+
+Ou espalhe uma configuração e defina você mesmo as severidades:
+
+```javascript fileName="eslint.config.mjs"
+import intlayer from "eslint-plugin-intlayer";
+
+export default [
+  ...intlayer.configs.recommended,
+  {
+    rules: {
+      "intlayer/no-raw-text": "warn",
+      "intlayer/static-dictionary-key": "error",
+      "intlayer/no-dynamic-field-access": "error",
+      "intlayer/enforce-adapter-import": "warn",
+      "intlayer/no-unused-content": "warn",
+    },
+  },
+];
+```
+
+  </Tab>
+  <Tab label="oxlint" value="oxlint">
+
+```json fileName=".oxlintrc.json"
+{
+  "jsPlugins": ["eslint-plugin-intlayer"],
+  "rules": {
+    "intlayer/no-raw-text": "warn",
+    "intlayer/static-dictionary-key": "error",
+    "intlayer/no-dynamic-field-access": "error",
+    "intlayer/enforce-adapter-import": "warn"
+  }
+}
+```
+
+Duas ressalvas: o suporte a plugins JS no oxlint ainda está em versão alfa e o oxlint não suporta parsers customizados — portanto, arquivos `.vue`, `.svelte`, `.astro` e templates do Angular não são verificados lá. Execute o oxlint nos seus arquivos JS/TS/JSX e mantenha o ESLint para o restante.
+
+O `no-unused-content` foi omitido acima de propósito: ele precisa do diretório de trabalho e do caminho do arquivo analisado a partir do contexto da regra, o que a ponte alfa de plugins JS não garante. Execute-o no ESLint.
+
+  </Tab>
+</Tabs>
+
+### Configurações
+
+| Configuração    | `no-raw-text`                  | `static-dictionary-key` | `no-dynamic-field-access` | `enforce-adapter-import` | `no-unused-content` |
+| --------------- | ------------------------------ | ----------------------- | ------------------------- | ------------------------ | ------------------- |
+| `recommended`   | warn                           | error                   | error                     | off                      | off                 |
+| `strict`        | error (+ literais fora de JSX) | error                   | error                     | error                    | off                 |
+| `contract-only` | off                            | error                   | error                     | off                      | off                 |
+
+A configuração `recommended` mantém deliberadamente `no-raw-text` como `warn`: apontá-la para uma base de código existente traz à tona todas as strings não traduzidas de uma só vez, o que não deve quebrar a sua compilação logo no primeiro dia.
+
+O `enforce-adapter-import` fica desativado por padrão — ative-o explicitamente se desejar.
+
+O `no-unused-content` fica desativado em todas as configurações, inclusive na `strict`. É a única regra que lê sua configuração do Intlayer e percorre seus arquivos de código no disco; portanto, ativá-la deve ser uma escolha consciente e não algo imposto por uma predefinição.
+
+## Regras
+
+### `no-raw-text`
+
+Reporta texto voltado ao usuário que não esteja declarado em um dicionário. Ele usa a mesma detecção do `intlayer extract`, portanto nomes de marcas, classes CSS e identificadores técnicos são ignorados.
+
+```jsx
+// ✗ Reportado
+<h1>Welcome to our documentation</h1>
+<input placeholder="Enter your email address" />
+
+// ✓ Correto
+const { title } = useIntlayer("home");
+<h1>{title}</h1>
+```
+
+Arquivos de declaração de conteúdo (`*.content.ts`, …) são ignorados.
+
+Para corrigir um arquivo inteiro de uma só vez, execute `npx intlayer extract` e deixe o compilador mover as strings para um dicionário para você.
+
+**Opções**
+
+```javascript fileName="eslint.config.mjs"
+{
+  "intlayer/no-raw-text": [
+    "warn",
+    {
+      // Atributos cujo valor é texto voltado ao usuário.
+      // Padrão: title, placeholder, alt, aria-label, label
+      attributes: ["title", "placeholder", "alt", "aria-label", "label"],
+
+      // Elementos cujo conteúdo nunca é texto voltado ao usuário.
+      // Padrão: code, pre, script, style
+      ignoreElements: ["code", "pre", "script", "style"],
+
+      // Expressões regulares para textos que nunca devem ser reportados.
+      ignorePatterns: ["^Powered by"],
+
+      // Também reportar literais de string fora do markup. Padrão: false
+      includeStringLiterals: false,
+    },
+  ],
+}
+```
+
+### `static-dictionary-key`
+
+Exige que a chave do dicionário seja uma string literal.
+
+O compilador só consegue pré-carregar um dicionário quando pode ler a chave diretamente no local da chamada. Com uma chave calculada, ele pula silenciosamente a otimização e inclui todos os dicionários no bundle.
+
+```typescript
+// ✗ Reportado
+useIntlayer(dictionaryKey);
+useIntlayer(`home-${suffix}`);
+getTranslations({ namespace: page });
+
+// ✗ Uma variável ainda não é um literal
+const key = "home";
+useIntlayer(key);
+
+// ✓ Correto
+useIntlayer("home");
+getTranslations({ namespace: "home" });
+```
+
+Isso se aplica ao `useIntlayer`, `getIntlayer` e a todos os adaptadores de compatibilidade (`useTranslation`, `useTranslations`, `formatMessage`, `<FormattedMessage id>`, `<Trans i18nKey>`, …).
+
+### `no-dynamic-field-access`
+
+Exige que o campo lido de um dicionário seja conhecido estaticamente.
+
+O compilador remove campos que não são identificados como utilizados. Um acesso computado é invisível para ele, portanto a leitura pode retornar `undefined` em tempo de execução.
+
+```typescript
+// ✗ Reportado
+const content = useIntlayer("home");
+content[fieldName];
+
+const t = useTranslations("home");
+t(messageKey);
+
+// ✓ Correto
+content.title;
+content["title"];
+content.items[0];
+t("hero.title");
+```
+
+### `enforce-adapter-import`
+
+Prefere o adaptador de compatibilidade `@intlayer/*` ao pacote original. O original só é resolvido para o Intlayer quando o alias do empacotador está configurado; o adaptador sempre funciona. Corrigível automaticamente com `--fix`.
+
+```typescript
+// ✗ Reportado
+import { useTranslation } from "react-i18next";
+import { getTranslations } from "next-intl/server";
+
+// ✓ Correto
+import { useTranslation } from "@intlayer/react-i18next";
+import { getTranslations } from "@intlayer/next-intl/server";
+```
+
+### `no-unused-content`
+
+**Desativada por padrão.** Reporta conteúdo que nada em seu projeto lê, além de chaves de dicionário declaradas em mais de um local.
+
+```typescript fileName="src/home.content.ts"
+export default {
+  key: "home", // ✗ Reportado se nenhum chamador no projeto solicitar "home"
+  content: {
+    title: t({ pt: "Título", en: "Title" }),
+
+    // ✗ Reportado se nada ler `hero`
+    hero: {
+      subtitle: t({ pt: "Subtítulo", en: "Subtitle" }),
+    },
+  },
+};
+```
+
+Ao contrário das outras regras, esta não pode responder apenas com base no arquivo analisado — um campo só é considerado não utilizado em relação ao projeto inteiro. Na primeira declaração de conteúdo de uma execução do linter, ela carrega a sua configuração do Intlayer, busca os arquivos de código declarados por essa configuração (`build.traversePattern`, `compiler.transformPattern`) e executa o mesmo analisador de uso que alimenta o `@intlayer/lsp` e o tachado de "não utilizado" na extensão do VS Code. O resultado é armazenado em cache por `cacheTtl` milissegundos, para que a varredura ocorra uma vez por execução e não a cada arquivo.
+
+**Opções**
+
+```javascript fileName="eslint.config.mjs"
+{
+  "intlayer/no-unused-content": [
+    "warn",
+    {
+      // Reportar chaves de dicionário que nada referencia. Padrão: true
+      reportUnusedDictionaries: true,
+
+      // Reportar campos de conteúdo que nada lê. Padrão: true
+      reportUnusedFields: true,
+
+      // Reportar chaves declaradas em mais de um lugar. Padrão: true
+      reportDuplicateKeys: true,
+
+      // Expressões regulares para caminhos de campos que nunca devem ser reportados.
+      ignoreFields: ["^meta"],
+
+      // Raiz do projeto a partir de onde a verificação começa. Padrão: diretório de trabalho do ESLint
+      baseDir: process.cwd(),
+
+      // Tempo de reutilização de uma varredura de projeto, em ms. Padrão: 30000
+      cacheTtl: 30000,
+    },
+  ],
+}
+```
+
+Diminua `cacheTtl` ao executar o lint a partir de um servidor de editor de longa duração e quiser que as alterações apareçam mais rápido; defina `baseDir` quando uma única execução de lint cobrir vários projetos Intlayer em um monorepo.
+
+> **Tende ao silêncio.** Um falso positivo aqui apagaria uma tradução; portanto, nada é reportado quando o dicionário é consumido de uma forma que a análise não consiga rastrear: o objeto de conteúdo passado por completo, uma função de tradução vinculada a partir dele (`const t = useTranslations("home")`), uma declaração acessada por importação direta (`useDictionary(myDictionary)`), um `nest()` de outro dicionário ou uma lista de campos tornada não exaustiva por um spread. Componentes de arquivo único (`.vue`, `.svelte`, `.astro`) são considerados como usuários de todos os campos dos dicionários mencionados, pois seus blocos de script não são analisados aqui.
+
+O `reportDuplicateKeys` lê os dicionários não mesclados que o build grava em `.intlayer/`, portanto permanece em silêncio até que o projeto tenha sido construído pelo menos uma vez. Duas declarações compartilhando uma chave são mescladas, o que é um padrão válido — o aviso existe porque um campo definido em ambos os lados mantém silenciosamente apenas um dos dois valores.
+
+O analisador é carregado a partir do `@intlayer/lsp`, distribuído como ESM. A regra requer, portanto, uma versão do Node compatível com `require()` em módulos ES — Node 20.19+ ou 22.12+. Em versões anteriores, ela não reporta nada em vez de falhar a execução do lint.
+
+## Frameworks
+
+Todas as regras funcionam em todas as integrações do Intlayer, inclusive dentro de templates Vue, Svelte e Angular. Você só precisa informar ao ESLint qual parser lê cada tipo de arquivo.
+
+| Framework                 | Arquivos          | Parser                            |
+| ------------------------- | ----------------- | --------------------------------- |
+| React, Preact, Solid, Lit | `.jsx` `.tsx`     | `typescript-eslint`               |
+| Next.js                   | `.jsx` `.tsx`     | `typescript-eslint`               |
+| Vue, Nuxt                 | `.vue`            | `vue-eslint-parser`               |
+| Svelte, SvelteKit         | `.svelte`         | `svelte-eslint-parser`            |
+| Angular                   | `.ts`             | `typescript-eslint`               |
+| Templates do Angular      | `.component.html` | `@angular-eslint/template-parser` |
+| Astro                     | `.astro`          | `astro-eslint-parser`             |
+
+```javascript fileName="eslint.config.mjs"
+import intlayer from "eslint-plugin-intlayer";
+import tseslint from "typescript-eslint";
+import vueParser from "vue-eslint-parser";
+import svelteParser from "svelte-eslint-parser";
+import angularTemplateParser from "@angular-eslint/template-parser";
+
+export default [
+  ...intlayer.configs.recommended,
+
+  {
+    files: ["**/*.{ts,tsx,jsx}"],
+    languageOptions: { parser: tseslint.parser },
+  },
+  {
+    files: ["**/*.vue"],
+    languageOptions: {
+      parser: vueParser,
+      parserOptions: { parser: tseslint.parser },
+    },
+  },
+  {
+    files: ["**/*.svelte"],
+    languageOptions: {
+      parser: svelteParser,
+      parserOptions: { parser: tseslint.parser },
+    },
+  },
+  {
+    files: ["**/*.component.html"],
+    languageOptions: { parser: angularTemplateParser },
+  },
+];
+```
+
+Instale apenas os parsers de que seu projeto precisa.
+
+> **Limitação conhecida.** Em templates do Vue e Angular, uma expressão como `{{ content[key] }}` não é verificada pelo `no-dynamic-field-access`. Leituras dinâmicas escritas no bloco script são identificadas normalmente.

package/docs/pt/intlayer_with_astro.md

@@ -317,120 +317,7 @@ A integração do Astro adiciona um middleware Vite que ajuda no roteamento sens
 
 </Step>
 
-<Step number={7} title="Continuar usando seus frameworks favoritos">
-
-Continue construindo sua aplicação usando o framework de sua escolha.
-
-- Intlayer + React: [Intlayer com React](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/intlayer_with_vite+react.md)
-- Intlayer + Vue: [Intlayer com Vue](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/intlayer_with_vite+vue.md)
-- Intlayer + Svelte: [Intlayer com Svelte](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/intlayer_with_vite+svelte.md)
-- Intlayer + Solid: [Intlayer com Solid](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/intlayer_with_vite+solid.md)
-- Intlayer + Preact: [Intlayer com Preact](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/intlayer_with_vite+preact.md)
-  </Step>
-
-<Step number={15} 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.
-
-Para configurá-lo, você pode adicionar uma seção `compiler` no seu arquivo `intlayer.config.ts`:
-
-```typescript fileName="intlayer.config.ts" codeFormat={["typescript", "esm", "commonjs"]}
-import { type IntlayerConfig } from "intlayer";
-
-const config: IntlayerConfig = {
-  // ... Resto da sua configuração
-  compiler: {
-    /**
-     * Indica se o compilador deve ser ativado.
-     */
-    enabled: true,
-
-    /**
-     * Define o caminho dos arquivos de saída
-     */
-    output: ({ fileName, extension }) => `./${fileName}${extension}`,
-
-    /**
-     * Indica se os componentes devem ser salvos após serem transformados. Dessa forma, o compilador pode ser executado apenas uma vez para transformar o aplicativo e depois removido.
-     */
-    saveComponents: false,
-
-    /**
-     * Prefixo da chave do dicionário
-     */
-    dictionaryKeyPrefix: "",
-  },
-};
-
-export default config;
-```
-
-<Tabs>
- <Tab value='Comando de extração'>
-
-Execute o extrator para transformar seus componentes e extrair o conteúdo
-
-```bash packageManager="npm"
-npx intlayer extract
-```
-
-```bash packageManager="pnpm"
-pnpm intlayer extract
-```
-
-```bash packageManager="yarn"
-yarn intlayer extract
-```
-
-```bash packageManager="bun"
-bun x intlayer extract
-```
-
- </Tab>
- <Tab value='Compilador Babel'>
-
-> Since v9, the `intlayerCompiler` is included in the `intlayer` plugin. So you don't need to add it manually.
-
-Atualize seu `vite.config.ts` para incluir o plugin `intlayerCompiler`:
-
-```ts fileName="vite.config.ts"
-import { defineConfig } from "vite";
-import { intlayer, intlayerCompiler } from "vite-intlayer";
-
-export default defineConfig({
-  plugins: [
-    intlayer(),
-    intlayerCompiler(), // Adds the compiler plugin
-  ],
-});
-```
-
-```bash packageManager="npm"
-npm run build # Ou npm run dev
-```
-
-```bash packageManager="pnpm"
-pnpm run build # Or pnpm run dev
-```
-
-```bash packageManager="yarn"
-yarn build # Or yarn dev
-```
-
-```bash packageManager="bun"
-bun run build # Or bun run dev
-```
-
- </Tab>
-</Tabs>
-
----
-
-</Step>
-
-</Steps>
+<Step number={8} title="Sitemap e Robots.txt">
 
 #### Sitemap
 

package/docs/ru/bundle_optimization.md

@@ -159,7 +159,7 @@ pnpm add -D webpack-bundle-analyzer
 bun add -d webpack-bundle-analyzer
 ```
 
-```typescript fileName="webpack.config.ts
+```typescript fileName="webpack.config.ts"
 import { BundleAnalyzerPlugin } from "webpack-bundle-analyzer";
 
 export default {