@intlayer/docs 9.0.0-canary.5 → 9.0.0-canary.7

package/docs/pt/intlayer_with_vite+svelte.md

@@ -458,7 +458,7 @@ Paralelamente, você também pode usar o `intlayerProxy` para adicionar roteamen
 ```typescript {3,7} fileName="vite.config.ts" codeFormat={["typescript", "esm", "commonjs"]}
 import { defineConfig } from "vite";
 import { svelte } from "@sveltejs/vite-plugin-svelte";
-import { intlayer, intlayerProxy } from "vite-intlayer";
+import { intlayer } from "vite-intlayer";
 
   plugins: [intlayerProxy(), // should be placed first
  svelte(), intlayer()],
@@ -592,6 +592,8 @@ 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"
@@ -601,7 +603,7 @@ import { intlayer, intlayerCompiler } from "vite-intlayer";
 export default defineConfig({
   plugins: [
     intlayer(),
-    intlayerCompiler(), // Adiciona o plugin do compilador
+    intlayerCompiler(), // Adds the compiler plugin
   ],
 });
 ```

package/docs/pt/intlayer_with_vite+vanilla.md

@@ -205,7 +205,13 @@ import { intlayer } from "vite-intlayer";
 
 // https://vitejs.dev/config/
 export default defineConfig({
-  plugins: [intlayer()],
+  plugins: [
+    intlayer({
+      proxy: {
+        ignore: (req) => req.url?.startsWith("/api"),
+      },
+    }),
+  ],
 });
 ```
 
@@ -466,12 +472,15 @@ Primeiro, adicione o `intlayerProxy` à sua configuração do Vite:
 
 ```typescript {3,7} fileName="vite.config.ts" codeFormat={["typescript", "esm", "commonjs"]}
 import { defineConfig } from "vite";
-import { intlayer, intlayerProxy } from "vite-intlayer";
+import { intlayer } from "vite-intlayer";
 
 export default defineConfig({
   plugins: [
-    intlayerProxy(), // deve ser colocado primeiro
-    intlayer(),
+    intlayer({
+      proxy: {
+        ignore: (req) => req.url?.startsWith("/api"),
+      },
+    }),
   ],
 });
 ```
@@ -603,6 +612,8 @@ 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 o seu `vite.config.ts` para incluir o plugin `intlayerCompiler`:
 
 ```ts fileName="vite.config.ts"
@@ -612,7 +623,7 @@ import { intlayer, intlayerCompiler } from "vite-intlayer";
 export default defineConfig({
   plugins: [
     intlayer(),
-    intlayerCompiler(), // Adiciona o plugin do compilador
+    intlayerCompiler(), // Adds the compiler plugin
   ],
 });
 ```

package/docs/pt/intlayer_with_vite+vue.md

@@ -619,14 +619,17 @@ Paralelamente, você também pode usar o `intlayerProxy` para adicionar roteamen
 ```typescript {3,7} fileName="vite.config.ts" codeFormat={["typescript", "esm", "commonjs"]}
 import { defineConfig } from "vite";
 import vue from "@vitejs/plugin-vue";
-import { intlayer, intlayerProxy } from "vite-intlayer";
+import { intlayer } from "vite-intlayer";
 
 // https://vitejs.dev/config/
 export default defineConfig({
   plugins: [
-    intlayerProxy(), // should be placed first
     vue(),
-    intlayer(),
+    intlayer({
+      proxy: {
+        ignore: (req) => req.url?.startsWith("/api"),
+      },
+    }),
   ],
 });
 ```
@@ -1005,6 +1008,8 @@ 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"
@@ -1014,7 +1019,7 @@ import { intlayer, intlayerCompiler } from "vite-intlayer";
 export default defineConfig({
   plugins: [
     intlayer(),
-    intlayerCompiler(), // Adiciona o plugin do compilador
+    intlayerCompiler(), // Adds the compiler plugin
   ],
 });
 ```

package/docs/pt/packages/@intlayer_babel/export.md

@@ -0,0 +1,131 @@
+---
+createdAt: 2026-06-25
+updatedAt: 2026-06-25
+title: "Documentação do pacote @intlayer/babel"
+description: Plugins do Babel para o Intlayer para lidar com extração de conteúdo, otimização de importação, limpeza de campos não utilizados e ofuscação de nomes de campos durante a compilação.
+keywords:
+  - "@intlayer/babel"
+  - babel
+  - plugin
+  - internacionalização
+  - i18n
+  - compilador
+  - otimizar
+  - limpar
+  - minificar
+slugs:
+  - doc
+  - packages
+  - "@intlayer/babel"
+  - export
+history:
+  - version: 9.0.0
+    date: 2026-06-25
+    changes: "Documentação unificada de todas as exportações"
+author: aymericzip
+---
+
+# Pacote @intlayer/babel
+
+O pacote `@intlayer/babel` fornece um conjunto de plugins especializados do Babel para o Intlayer. Esses plugins cobrem todo o ciclo de build: extração de declarações de conteúdo, reescrita de chamadas `useIntlayer` / `getIntlayer` para importações de dicionário otimizadas, limpeza de campos não utilizados e minificação de nomes de campos.
+
+## Instalação
+
+```bash
+npm install @intlayer/babel
+```
+
+## Exportações
+
+Importar:
+
+```ts
+import { ... } from "@intlayer/babel";
+```
+
+---
+
+### Plugins
+
+| Função / Classe                | Descrição                                                                                                                                                                                                                |
+| ------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `intlayerExtractBabelPlugin`   | Plugin do Babel que extrai conteúdo traduzível de arquivos-fonte e injeta ganchos (hooks) `useIntlayer` / `getIntlayer` automaticamente. Projetado para uso com o Next.js e ferramentas de compilação baseadas em Babel. |
+| `intlayerOptimizeBabelPlugin`  | Plugin do Babel que transforma chamadas `useIntlayer` e `getIntlayer` e reescreve suas importações para importações de dicionário JSON otimizadas (estáticas, dinâmicas ou via fetch).                                   |
+| `intlayerPurgeBabelPlugin`     | Plugin do Babel que analisa arquivos-fonte e reescreve arquivos JSON de dicionário compilados para remover campos não utilizados (`build.purge`) ou renomeá-los para aliases curtos (`build.minify`).                    |
+| `intlayerMinifyBabelPlugin`    | Plugin do Babel que reescreve arquivos-fonte para usar os aliases curtos de campo atribuídos durante a fase de minificação (por exemplo, `content.title` ← `content.a`). Depende do `intlayerPruneBabelPlugin`.          |
+| `makeFieldRenameBabelPlugin`   | Função factory que produz um plugin do Babel para renomear acessos a campos de conteúdo de dicionário em arquivos-fonte de acordo com o `dictionaryKeyToFieldRenameMap` preenchido no `PruneContext`.                    |
+| `makeUsageAnalyzerBabelPlugin` | Função factory que produz um plugin do Babel para analisar o uso de `useIntlayer` / `getIntlayer` no código-fonte e agregar dados de uso de campo no `PruneContext` compartilhado.                                       |
+| `getSharedPruneContext`        | Função auxiliar que retorna o objeto `PruneContext` compartilhado para o diretório base especificado, ou `null` se ainda não tiver sido inicializado.                                                                    |
+
+---
+
+### Utilitários de Configuração de Plugins
+
+| Função                     | Descrição                                                                                                                                              |
+| -------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `getExtractPluginOptions`  | Carrega a configuração do Intlayer e retorna `ExtractPluginOptions` prontas para uso com o `intlayerExtractBabelPlugin`.                               |
+| `getOptimizePluginOptions` | Carrega a configuração do Intlayer e os dicionários compilados e retorna `OptimizePluginOptions` prontas para uso com o `intlayerOptimizeBabelPlugin`. |
+| `getPurgePluginOptions`    | Carrega a configuração do Intlayer e retorna `PurgePluginOptions` prontas para uso com o `intlayerPurgeBabelPlugin`.                                   |
+| `getMinifyPluginOptions`   | Carrega a configuração do Intlayer e retorna `MinifyPluginOptions` prontas para uso com o `intlayerMinifyBabelPlugin`.                                 |
+
+---
+
+### Tipos
+
+| Tipo                    | Descrição                                                                                                                                    |
+| ----------------------- | -------------------------------------------------------------------------------------------------------------------------------------------- |
+| `CompilerMode`          | Modo do compilador: `'dev'` para desenvolvimento com suporte HMR, ou `'build'` para compilações de produção.                                 |
+| `ExtractPluginOptions`  | Opções para o `intlayerExtractBabelPlugin`: lista de arquivos, configuração, callback `onExtract`, etc.                                      |
+| `ExtractResult`         | Resultado da extração: chave do dicionário, caminho do arquivo, conteúdo e idioma.                                                           |
+| `OptimizePluginOptions` | Opções para o `intlayerOptimizeBabelPlugin`: caminhos do dicionário, modo de importação, mapa de modos por dicionário, etc.                  |
+| `PurgePluginOptions`    | Opções para o `intlayerPurgeBabelPlugin`: diretório base, sinalizadores de limpeza/minificação/otimização, lista de arquivos de componentes. |
+| `MinifyPluginOptions`   | Opções para o `intlayerMinifyBabelPlugin`: diretório base, sinalizadores de minificação/otimização/editorEnabled.                            |
+| `PruneContext`          | Estado compartilhado entre plugins de análise e limpeza: mapas de uso de campo, mapas de renomeação, etc.                                    |
+| `DictionaryFieldUsage`  | Resultado do uso do campo para um único dicionário: `Set<string>` ou `'all'` quando a análise estática é inconclusiva.                       |
+| `NestedRenameEntry`     | Nó na árvore de renomeação: o `shortName` e o mapa de filhos.                                                                                |
+| `NestedRenameMap`       | Um nível na árvore de renomeação: `Map<string, NestedRenameEntry>`.                                                                          |
+| `CompatCallerConfig`    | Configuração para um analisador de uso compatível para pacotes compat-adapter (nome do chamador e opções de processamento).                  |
+| `ScriptBlock`           | Bloco de script extraído de um arquivo SFC (Vue ou Svelte): conteúdo, deslocamento de início e deslocamento de fim.                          |
+
+---
+
+### Funções Utilitárias
+
+| Função                            | Descrição                                                                                                                                                                             |
+| --------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `generateShortFieldName`          | Converte um número inteiro (começando do zero) em um identificador alfabético curto: `0` → `'a'`, `25` → `'z'`, `26` → `'aa'`, etc.                                                   |
+| `buildNestedRenameMapFromContent` | Constrói recursivamente um `NestedRenameMap` a partir do valor do conteúdo de um dicionário compilado, respeitando as estruturas de nós do Intlayer (translation, enumeration, etc.). |
+| `createPruneContext`              | Cria um novo objeto `PruneContext` vazio inicializado com valores padrão.                                                                                                             |
+| `extractScriptBlocks`             | Extrai blocos `<script>` de arquivos SFC (Vue / Svelte) para análise subsequente do Babel.                                                                                            |
+| `BABEL_PARSER_OPTIONS`            | Constante que representa as opções do analisador do Babel que cobrem os frameworks suportados (React/Vue/Svelte/Angular/...).                                                         |
+| `INTLAYER_CALLER_NAMES`           | Lista constante de nomes de chamadores originais do Intlayer: `['useIntlayer', 'getIntlayer']`.                                                                                       |
+
+---
+
+## Exemplo de Uso
+
+```js
+// babel.config.js
+const {
+  intlayerExtractBabelPlugin,
+  intlayerPurgeBabelPlugin,
+  intlayerMinifyBabelPlugin,
+  intlayerOptimizeBabelPlugin,
+  getExtractPluginOptions,
+  getPurgePluginOptions,
+  getMinifyPluginOptions,
+  getOptimizePluginOptions,
+} = require("@intlayer/babel");
+
+module.exports = {
+  presets: ["next/babel"],
+  plugins: [
+    [intlayerExtractBabelPlugin, getExtractPluginOptions()],
+    [intlayerPurgeBabelPlugin, getPurgePluginOptions()],
+    [intlayerMinifyBabelPlugin, getMinifyPluginOptions()],
+    [intlayerOptimizeBabelPlugin, getOptimizePluginOptions()],
+  ],
+};
+```
+
+> **Nota:** O plugin `intlayerPurgeBabelPlugin` deve ser declarado **antes** do `intlayerMinifyBabelPlugin`, porque o último lê o mapa de renomeação construído pelo primeiro. Além disso, ambos devem ser precedidos pelo `intlayerOptimizeBabelPlugin` para que ele possa ver as chaves do dicionário antes que as chamadas do `useIntlayer` sejam reescritas.

package/docs/pt/packages/react-native-intlayer/exports.md

@@ -1,8 +1,8 @@
 ---
 createdAt: 2026-01-21
-updatedAt: 2026-01-21
+updatedAt: 2026-06-25
 title: Documentação do pacote react-native-intlayer
-description: Suporte a React Native para o Intlayer, fornecendo providers e polyfills.
+description: Suporte a React Native para o Intlayer, fornecendo providers, hooks, polyfills e configuração Metro.
 keywords:
   - react-native-intlayer
   - react-native
@@ -14,6 +14,9 @@ slugs:
   - react-native-intlayer
   - exports
 history:
+  - version: 9.0.0
+    date: 2026-06-25
+    changes: "Reexportar a API completa do react-intlayer (hooks, utilitários, subcaminhos format/html/markdown) para que um aplicativo React Native dependa apenas de react-native-intlayer"
   - version: 8.0.0
     date: 2026-01-21
     changes: "Documentação unificada para todas as exportações"
@@ -22,7 +25,9 @@ author: aymericzip
 
 # Pacote react-native-intlayer
 
-O pacote `react-native-intlayer` fornece as ferramentas necessárias para integrar o Intlayer em aplicações React Native. Inclui um provider e polyfills para suporte a locale.
+O pacote `react-native-intlayer` fornece as ferramentas necessárias para integrar o Intlayer em aplicações React Native. Reexporta a API completa do `react-intlayer` (hooks e utilitários) com um `IntlayerProvider` pronto para React Native, além dos polyfills e da configuração Metro exigidos pelo React Native.
+
+> Em um aplicativo React Native, importe **tudo** de `react-native-intlayer`. Você não precisa instalar ou importar `react-intlayer` diretamente.
 
 ## Instalação
 
@@ -34,14 +39,30 @@ npm install react-native-intlayer
 
 ### Provider
 
-| Componente         | Descrição                                                                       |
-| ------------------ | ------------------------------------------------------------------------------- |
-| `IntlayerProvider` | Componente Provider que envolve sua aplicação e fornece o contexto do Intlayer. |
+| Componente         | Descrição                                                                                                                        |
+| ------------------ | -------------------------------------------------------------------------------------------------------------------------------- |
+| `IntlayerProvider` | Componente Provider que envolve sua aplicação e fornece o contexto do Intlayer. Aplica automaticamente os polyfills necessários. |
+
+```tsx
+import { IntlayerProvider } from "react-native-intlayer";
+```
+
+### Hooks e utilitários
+
+Estes são reexportados de `react-intlayer`, portanto você pode importá-los diretamente de `react-native-intlayer`:
 
-Import:
+| Exportação                                                                                                        | Descrição                                                |
+| ----------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------- |
+| `useIntlayer`                                                                                                     | Acessa conteúdo localizado para uma chave de dicionário. |
+| `useLocale`                                                                                                       | Lê e altera o locale atual.                              |
+| `useDictionary`, `useDictionaryAsync`, `useDictionaryDynamic`, `useLoadDynamic`                                   | Carrega conteúdo de dicionário de diversas formas.       |
+| `useI18n`                                                                                                         | Hook compatível com i18next.                             |
+| `t`                                                                                                               | Auxiliar de tradução inline.                             |
+| `getIntlayer`, `getDictionary`                                                                                    | Getters imperativos de conteúdo.                         |
+| `localeCookie`, `localeInStorage`, `setLocaleCookie`, `setLocaleInStorage`, `useLocaleCookie`, `useLocaleStorage` | Auxiliares de persistência de locale.                    |
 
 ```tsx
-import "react-native-intlayer";
+import { useIntlayer, useLocale, t } from "react-native-intlayer";
 ```
 
 ### Polyfill
@@ -50,10 +71,25 @@ import "react-native-intlayer";
 | ------------------ | --------------------------------------------------------------------------------------- |
 | `intlayerPolyfill` | Função que aplica os polyfills necessários para o React Native dar suporte ao Intlayer. |
 
-Import:
+```tsx
+import { intlayerPolyfill } from "react-native-intlayer";
+```
+
+> O polyfill é aplicado automaticamente quando você importa `IntlayerProvider`. Chame `intlayerPolyfill` manualmente apenas se precisar dos polyfills antes que o provider seja montado.
+
+### Formatadores
+
+Hooks de formatação numérica, de data e outros baseados em Intl estão disponíveis no subcaminho `/format`:
+
+```tsx
+import { useNumber, useDate } from "react-native-intlayer/format";
+```
+
+### Renderização de Markdown e HTML
 
 ```tsx
-import "react-native-intlayer";
+import { MarkdownProvider } from "react-native-intlayer/markdown";
+import { HTMLProvider } from "react-native-intlayer/html";
 ```
 
 ### Configuração do Metro
@@ -66,8 +102,6 @@ O pacote `react-native-intlayer` fornece utilitários de configuração do Metro
 | `configMetroIntlayerSync` | Função síncrona que mescla a configuração do Metro sem preparar os recursos do Intlayer.     |
 | `exclusionList`           | Cria um padrão RegExp para o blockList do Metro para excluir arquivos de conteúdo do bundle. |
 
-Importação:
-
 ```tsx
-import "react-native-intlayer/metro";
+import { configMetroIntlayer } from "react-native-intlayer/metro";
 ```

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.