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

package/docs/pt/compat/polyglot.md

@@ -0,0 +1,45 @@
+---
+createdAt: 2026-06-13
+updatedAt: 2026-06-13
+title: "Migrar do Polyglot.js para o Intlayer"
+description: "Aprenda como migrar do Polyglot.js para o Intlayer usando o adaptador de compatibilidade."
+keywords:
+  - polyglot
+  - airbnb
+  - intlayer
+  - migration
+  - compat
+slugs:
+  - doc
+  - compatibility
+  - polyglot
+history:
+  - version: 9.0.0
+    date: 2026-06-13
+    changes: "Init history"
+author: aymericzip
+---
+
+# Migrar do Polyglot.js para Intlayer
+
+Se está a utilizar o Polyglot.js da Airbnb, migrar para Intlayer é extremamente simples usando a camada de compatibilidade.
+
+## O que fazer
+
+Simplesmente execute o comando de inicialização em seu projeto:
+
+```bash
+npx intlayer init
+```
+
+Isso gera `intlayer.config.ts`. Você pode então utilizar o alias do plugin bundler para redirecionar transparentemente as importações do Polyglot para `@intlayer/polyglot`.
+
+## O que faz por trás dos panos
+
+A sintaxe do Polyglot.js normalmente depende de `polyglot.t('key', {name})` com interpolações `%{name}` e plurais `smart_count` separados por `"singular |||| plural"`.
+
+Por trás dos panos:
+
+- **Interpolation:** A camada de compatibilidade manipula placeholders `%{var}` nativamente.
+- **Plurals:** A string é dividida em `||||` e avaliada contra `Intl.PluralRules` nativo de acordo com a locale ativa, espelhando a ordem de bucket própria do Polyglot por locale.
+- **Dictionaries:** Você evita a necessidade de fornecer enormes configurações JSON para `new Polyglot()` – Intlayer manipula os dictionaries dinamicamente e os prune automaticamente.

package/docs/pt/compat/react-i18next.md

@@ -0,0 +1,58 @@
+---
+createdAt: 2026-06-13
+updatedAt: 2026-06-13
+title: "Migrar de react-i18next para Intlayer"
+description: "Aprenda como migrar sua aplicação React de react-i18next para Intlayer usando o adaptador de compatibilidade."
+keywords:
+  - react-i18next
+  - i18next
+  - intlayer
+  - migration
+  - compat
+slugs:
+  - doc
+  - compatibility
+  - react-i18next
+history:
+  - version: 9.0.0
+    date: 2026-06-13
+    changes: "Init history"
+author: aymericzip
+---
+
+# Migrar de react-i18next para Intlayer
+
+Para um tutorial completo e detalhado passo a passo, consulte nosso completo [Guia de Migração react-i18next](../migration_from_react-i18next_to_intlayer.md).
+
+Usar o adaptador de compatibilidade do Intlayer permite que você migre de `react-i18next` sem qualquer alteração nos seus imports de código-fonte.
+
+## O que fazer
+
+Para inicializar o projeto, execute:
+
+```bash
+npx intlayer init
+```
+
+Durante a inicialização, o Intlayer instalará `@intlayer/react-i18next` e criará `intlayer.config.ts`. No seu bundler (como Vite), aplique o plugin do Intlayer:
+
+```typescript fileName="vite.config.ts"
+import { defineConfig } from "vite";
+import react from "@vitejs/plugin-react";
+import { reactI18nextVitePlugin } from "@intlayer/react-i18next/plugin";
+
+export default defineConfig({
+  plugins: [react(), reactI18nextVitePlugin()],
+});
+```
+
+## O que faz sob o capô
+
+O `reactI18nextVitePlugin` envolve o plugin central `vite-intlayer` e injeta aliases de resolução para `react-i18next` e `i18next`, redirecionando-os para `@intlayer/react-i18next` e `@intlayer/i18next`.
+
+Sob o capô:
+
+- **`useTranslation` & `withTranslation`:** Reescritos para usar os hooks nativos do Intlayer, dando-lhe preenchimento automático de TypeScript para suas chaves de dicionário. Oferece suporte contínuo a namespaces (por exemplo, `t('namespace:key')`).
+- **Plurais & Contexto:** Manipula a pluralização baseada em sufixo do i18next (`key_one`, `key_other`) usando `Intl.PluralRules` nativo e sufixos de contexto (`key_male`).
+- **Componente `<Trans>`:** Re-implementado para suportar a prop `components`, formas de objeto e array, e tags numeradas `<1>...</1>` mapeadas diretamente para seus nós React.
+- **Instância `i18n`:** Resolve chaves diretamente do Intlayer sem buscar grandes arquivos JSON, resultando em tamanhos de bundle significativamente menores.

package/docs/pt/compat/react-intl.md

@@ -0,0 +1,55 @@
+---
+createdAt: 2026-06-13
+updatedAt: 2026-06-13
+title: "Migrar de React Intl para Intlayer"
+description: "Aprenda como migrar sua aplicação React de react-intl para Intlayer usando o adaptador de compatibilidade."
+keywords:
+  - react-intl
+  - formatjs
+  - intlayer
+  - migration
+  - compat
+slugs:
+  - doc
+  - compatibility
+  - react-intl
+history:
+  - version: 9.0.0
+    date: 2026-06-13
+    changes: "Init history"
+author: aymericzip
+---
+
+# Migrar do React Intl para Intlayer
+
+Se sua aplicação React usa `react-intl` (FormatJS), a transição para Intlayer é muito fácil. Nossa camada de compatibilidade lida perfeitamente com ICU MessageFormat e todos os componentes `Formatted*` existentes.
+
+## O que fazer
+
+Comece executando o comando de inicialização em seu projeto:
+
+```bash
+npx intlayer init
+```
+
+Em seguida, configure o plugin Intlayer Vite ou Next.js em sua configuração. Este plugin injeta aliases em tempo de construção para redirecionar as importações de `react-intl` para `@intlayer/react-intl`.
+
+```typescript fileName="vite.config.ts"
+import { defineConfig } from "vite";
+import react from "@vitejs/plugin-react";
+import reactIntlVitePlugin from "@intlayer/react-intl/plugin";
+
+export default defineConfig({
+  plugins: [react(), reactIntlVitePlugin()],
+});
+```
+
+## O que faz sob o capô
+
+O plugin bundler cria um alias de `react-intl` para `@intlayer/react-intl`. Em vez de analisar manualmente arquivos JSON grandes e envolver seu app em um `IntlProvider`, o plugin Intlayer extrai estaticamente chaves e usa dicionários Intlayer em tempo de execução.
+
+Sob o capô:
+
+- **ICU MessageFormat:** Intlayer usa o resolver `resolveMessage(..., 'icu')` que suporta totalmente pluralização ICU, seleção, formatação de data/número e tags de rich text nativamente.
+- **Method & JSX callers:** `intl.formatMessage({ id: 'a.b' })` e `<FormattedMessage id="a.b">` são identificados pelos plugins compilador Intlayer (`@intlayer/babel` / `@intlayer/swc`), convertendo chaves pontilhadas planas para que o primeiro segmento se resolva corretamente para a chave do dicionário Intlayer.
+- **Formatters:** `<FormattedNumber>`, `<FormattedDate>`, etc., fazem ponte para o `core/formatters` nativo usando `Intl`.

package/docs/pt/compat/svelte-i18n.md

@@ -0,0 +1,47 @@
+---
+createdAt: 2026-06-13
+updatedAt: 2026-06-13
+title: "Migrar de Svelte I18n para Intlayer"
+description: "Aprenda como migrar sua aplicação Svelte de svelte-i18n para Intlayer usando o adaptador de compatibilidade."
+keywords:
+  - svelte-i18n
+  - svelte
+  - intlayer
+  - migration
+  - compat
+slugs:
+  - doc
+  - compatibility
+  - svelte-i18n
+history:
+  - version: 9.0.0
+    date: 2026-06-13
+    changes: "Inicializar histórico"
+author: aymericzip
+---
+
+# Migrar de Svelte I18n para Intlayer
+
+Mover sua aplicação Svelte de `svelte-i18n` para Intlayer leva apenas um momento usando o adaptador de compatibilidade.
+
+## O que fazer
+
+Simplesmente execute o comando de inicialização no seu projeto:
+
+```bash
+npx intlayer init
+```
+
+Isso gera `intlayer.config.ts`. Certifique-se de que seus plugins SvelteKit / Vite estão envolvidos com o plugin de alias do Intlayer para mapear perfeitamente `svelte-i18n` para `@intlayer/svelte-i18n`.
+
+## O que acontece nos bastidores
+
+Svelte-i18n depende de stores intensamente usadas (`$_`, `$t`, `$format`, etc.) e ICU MessageFormat.
+
+Nos bastidores:
+
+- **Stores:** Intlayer faz proxy dos stores do `svelte-i18n`. `$_` torna-se uma derived store da locale atual retornando um resolver do Intlayer.
+- **Keys:** Suas chaves planas (ex. `$_('home.title')`) são avaliadas de forma que o primeiro segmento de caminho represente o dicionário do Intlayer.
+- **ICU Syntax:** Totalmente gerenciada pelo resolver ICU compartilhado (análise equivalente ao `intl-messageformat`).
+- **Formatters:** As chamadas `$date`, `$time`, `$number` redirecionam com segurança para os formatadores core nativos do Intlayer.
+- **Babel/SWC Analysis:** O analisador do Intlayer lê os callers de store do Svelte (`$_`) dentro de seus arquivos fonte `.svelte` antes da compilação para construir automaticamente os chunks de dicionário relevantes.

package/docs/pt/compat/transloco.md

@@ -0,0 +1,45 @@
+---
+createdAt: 2026-06-13
+updatedAt: 2026-06-13
+title: "Migrar do Transloco para Intlayer"
+description: "Aprenda como migrar sua aplicação Angular do Transloco para Intlayer usando o adaptador de compatibilidade."
+keywords:
+  - transloco
+  - angular
+  - intlayer
+  - migration
+  - compat
+slugs:
+  - doc
+  - compatibility
+  - transloco
+history:
+  - version: 9.0.0
+    date: 2026-06-13
+    changes: "Init history"
+author: aymericzip
+---
+
+# Migrar de Transloco para Intlayer
+
+Se sua aplicação Angular atualmente usa `@jsverse/transloco`, você pode migrar para Intlayer usando nosso adaptador de compatibilidade. Esta transição permite que você mantenha sua sintaxe de template existente enquanto utiliza a poderosa estrutura de dicionário do Intlayer.
+
+## O que fazer
+
+Execute simplesmente o comando de inicialização no seu projeto:
+
+```bash
+npx intlayer init
+```
+
+Isso vai gerar a configuração necessária `intlayer.config.ts`. Você então vai substituir seus imports Transloco com módulos `@intlayer/transloco` ou depender dos aliases de build.
+
+## O que faz sob o capô
+
+Transloco usa scopes e um `TranslocoService` (`translate`, `selectTranslate`), juntamente com diretivas estruturais (`*transloco="let t"`) e pipes (`| transloco`).
+
+Sob o capô:
+
+- **Scopes:** Mapeiam naturalmente para chaves de dicionário do Intlayer, fornecendo uma ótima história de pruning para otimização de bundle.
+- **Service & Directives:** O adaptador Angular do Intlayer substitui perfeitamente os provedores, permitindo que seus pipes e diretivas de template existentes resolvam strings contra dicionários do Intlayer.
+- **Build time parsing:** O analisador TypeScript reconhece chamadas `instant/get`, e fallback pruning garante correção mesmo quando o uso do template não é estaticamente rastreável.

package/docs/pt/compat/vue-i18n.md

@@ -0,0 +1,58 @@
+---
+createdAt: 2026-06-13
+updatedAt: 2026-06-13
+title: "Migrar de Vue I18n para Intlayer"
+description: "Aprenda como migrar sua aplicação Vue de vue-i18n para Intlayer usando o adaptador de compatibilidade."
+keywords:
+  - vue-i18n
+  - vue
+  - intlayer
+  - migration
+  - compat
+slugs:
+  - doc
+  - compatibility
+  - vue-i18n
+history:
+  - version: 9.0.0
+    date: 2026-06-13
+    changes: "Init history"
+author: aymericzip
+---
+
+# Migrar de Vue I18n para Intlayer
+
+Se sua aplicação Vue atualmente usa `vue-i18n`, você pode migrar para Intlayer sem reescrever seus componentes ou traduzir hooks. Intlayer fornece um adaptador de compatibilidade que espelha perfeitamente a API do `vue-i18n` enquanto aproveita os poderosos recursos do Intlayer por trás dos panos.
+
+## O que fazer
+
+Para começar, basta executar o comando de inicialização no seu projeto:
+
+```bash
+npx intlayer init
+```
+
+Durante a inicialização, o Intlayer configurará seu arquivo de configuração (`intlayer.config.ts`) e preparará seu projeto para migração. Você só precisará adicionar o plugin Intlayer à sua configuração do Vite para fazer um alias automático das importações `vue-i18n`.
+
+```typescript fileName="vite.config.ts"
+import { defineConfig } from "vite";
+import vue from "@vitejs/plugin-vue";
+import vueI18nVitePlugin from "@intlayer/vue-i18n/plugin";
+
+export default defineConfig({
+  plugins: [vue(), vueI18nVitePlugin()],
+});
+```
+
+## O que faz por baixo
+
+O `vueI18nVitePlugin` injeta um alias de módulo no seu bundler. Qualquer import de `vue-i18n` no seu codebase será redirecionado transparentemente para `@intlayer/vue-i18n`.
+
+**Por baixo, o adapter manipula a sintaxe complexa do `vue-i18n` nativamente:**
+
+- **Interpolação & Plurais:** Resolve interpolações `{name}` e de lista `{0}`. Plurais com pipe (`"car | cars"`) são convertidos em nós de enumeração/plural do Intlayer baseados em semântica posicional.
+- **Formatos:** Funções como `d()` e `n()` envolvem `Intl` por baixo, honrando os `datetimeFormats` e `numberFormats` definidos nas suas opções.
+- **Estado Global & Local:** `global.locale` é mapeado para um `WritableComputedRef` apoiado pelo cliente Intlayer, então a reatividade funciona exatamente como esperado (ex: `locale.value = 'fr'`).
+- **Diretivas:** A diretiva `v-t` é registrada e funciona normalmente.
+
+Sua aplicação continua renderizando exatamente como antes, mas o conteúdo é alimentado pelos seus dicionários Intlayer, oferecendo segurança de tipo, melhor otimização de bundle e integração CMS contínua.

package/docs/pt/compiler.md

@@ -89,7 +89,7 @@ export default defineConfig({
 });
 ```
 
-See complete tutorial: [Intlayer Compiler with Vite+React](https://github.com/aymericzip/intlayer/blob/main/docs/docs/en/intlayer_with_vite+react_compiler.md)
+See complete tutorial: [Intlayer Compiler with Vite+React](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/intlayer_with_vite+react_compiler.md)
 
 #### Suporte a Frameworks
 
@@ -147,7 +147,7 @@ module.exports = {
 
 Esta configuração garante que o conteúdo declarado em seus componentes seja automaticamente extraído e usado para gerar dicionários durante o processo de build.
 
-See complete tutorial: [Intlayer Compiler with Next.js](https://github.com/aymericzip/intlayer/blob/main/docs/docs/en/intlayer_with_nextjs_compiler.md)
+See complete tutorial: [Intlayer Compiler with Next.js](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/intlayer_with_nextjs_compiler.md)
 
  </Tab>
 </Tabs>

package/docs/pt/configuration.md

@@ -677,7 +677,7 @@ Definições que controlam o comportamento do roteamento, incluindo estrutura de
 | `mode`     | Modo de roteamento de URL para a gestão de idiomas.                                                                                                                                                                     | `'prefix-no-default'` &#124; <br/> `'prefix-all'` &#124; <br/> `'no-prefix'` &#124; <br/> `'search-params'`                                                                                                  | `'prefix-no-default'`  | `'prefix-no-default'`: `/dashboard` (en) ou `/fr/dashboard` (fr). `'prefix-all'`: `/en/dashboard`. `'no-prefix'`: idioma gerido por outros meios. `'search-params'`: `/dashboard?locale=fr` | Não afeta a gestão de cookies ou armazenamento de idiomas.                                                                                                                                                                                                                                              |
 | `storage`  | Configuração para o armazenamento do idioma no cliente.                                                                                                                                                                 | `false` &#124; <br/> `'cookie'` &#124; <br/> `'localStorage'` &#124; <br/> `'sessionStorage'` &#124; <br/> `'header'` &#124; <br/> `CookiesAttributes` &#124; <br/> `StorageAttributes` &#124; <br/> `Array` | `['cookie', 'header']` | `'localStorage'` <br/> `[{ type: 'cookie', name: 'custom-locale', secure: true }]`                                                                                                          | Veja a tabela de Opções de Armazenamento abaixo.                                                                                                                                                                                                                                                        |
 | `basePath` | O caminho base para os URLs da aplicação.                                                                                                                                                                               | `string`                                                                                                                                                                                                     | `''`                   | `'/my-app'`                                                                                                                                                                                 | Se a app está em `https://example.com/my-app`, basePath é `'/my-app'` e os URLs tornam-se `https://example.com/my-app/en`.                                                                                                                                                                              |
-| `rewrite`  | Regras de reescrita de URL personalizadas que anulam o modo de roteamento padrão para caminhos específicos. Suporta parâmetros dinâmicos `[param]`.                                                                     | `Record<string, StrictModeLocaleMap<string>>`                                                                                                                                                                | `undefined`            | Veja o exemplo abaixo                                                                                                                                                                       | • Regras de reescrita têm precedência sobre `mode`.<br/>• Funciona com Next.js e Vite.<br/>• `getLocalizedUrl()` aplica as regras correspondentes automaticamente.<br/>• Veja [Reescritas de URL Personalizadas](https://github.com/aymericzip/intlayer/blob/main/docs/docs/en/custom_url_rewrites.md). |
+| `rewrite`  | Regras de reescrita de URL personalizadas que anulam o modo de roteamento padrão para caminhos específicos. Suporta parâmetros dinâmicos `[param]`.                                                                     | `Record<string, StrictModeLocaleMap<string>>`                                                                                                                                                                | `undefined`            | Veja o exemplo abaixo                                                                                                                                                                       | • Regras de reescrita têm precedência sobre `mode`.<br/>• Funciona com Next.js e Vite.<br/>• `getLocalizedUrl()` aplica as regras correspondentes automaticamente.<br/>• Veja [Reescritas de URL Personalizadas](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/custom_url_rewrites.md). |
 | `domains`  | Mapeia idiomas para nomes de host de domínio para roteamento baseado em domínio. Quando definido, as URLs para um idioma usam esse domínio como base (URL absoluta) e nenhum prefixo de idioma é adicionado ao caminho. | `Partial<Record<Locale, string>>`                                                                                                                                                                            | `undefined`            | `{ zh: 'intlayer.zh', fr: 'intlayer.org' }`                                                                                                                                                 | • O protocolo padrão é `https://` quando não incluído no nome do host.<br/>• O próprio domínio identifica o idioma, portanto nenhum prefixo `/zh/` é adicionado.<br/>• `getLocalizedUrl('/', 'zh')` retorna `https://intlayer.zh/`.                                                                     |
 
 **Exemplo de `rewrite`**:
@@ -885,6 +885,21 @@ Definições relacionadas à forma como o conteúdo é gerido dentro da aplicaç
 
 ---
 
+### Configuração do Sistema
+
+Configurações relacionadas a caminhos internos e resultados de saída do Intlayer. Essas configurações são tipicamente internas e não devem precisar ser modificadas pelo usuário.
+
+| Campo                     | Descrição                                                                                      | Tipo     | Padrão                            | Exemplo              | Nota                                                              |
+| ------------------------- | ---------------------------------------------------------------------------------------------- | -------- | --------------------------------- | -------------------- | ----------------------------------------------------------------- |
+| `baseDir`                 | O diretório base para o projeto.                                                               | `string` | `process.cwd()`                   | `'/path/to/project'` | Usado para resolver todos os diretórios relacionados ao Intlayer. |
+| `dictionariesDir`         | O caminho do diretório para armazenar dicionários de localização.                              | `string` | `'.intlayer/dictionary'`          |                      |                                                                   |
+| `moduleAugmentationDir`   | Diretório para aumento de módulo, permitindo melhores sugestões de IDE e verificação de tipos. | `string` | `'.intlayer/types'`               | `'intlayer-types'`   | Certifique-se de incluir isso em `tsconfig.json`.                 |
+| `unmergedDictionariesDir` | O diretório para armazenar dicionários não mesclados.                                          | `string` | `'.intlayer/unmerged_dictionary'` |                      |                                                                   |
+| `typesDir`                | O diretório para armazenar tipos de dicionário.                                                | `string` | `'.intlayer/types'`               |                      |                                                                   |
+| `mainDir`                 | O diretório onde os arquivos principais da aplicação são armazenados.                          | `string` | `'.intlayer/main'`                |                      |                                                                   |
+| `configDir`               | O diretório onde os arquivos de configuração são armazenados.                                  | `string` | `'.intlayer/config'`              |                      |                                                                   |
+| `cacheDir`                | O diretório onde os arquivos de cache são armazenados.                                         | `string` | `'.intlayer/cache'`               |                      |                                                                   |
+
 ### Configuração do Dicionário
 
 Parâmetros que controlam as operações do dicionário, incluindo o comportamento de preenchimento automático (auto-fill) e geração de conteúdo.
@@ -993,22 +1008,6 @@ As opções de build aplicam-se aos plugins `@intlayer/babel` e `@intlayer/swc`.
 
 ---
 
-### Configuração do Sistema
-
-Estas definições são para casos de uso avançados e configuração interna do Intlayer.
-
-| Campo                     | Descrição                                            | Tipo     | Padrão                            | Exemplo | Nota |
-| ------------------------- | ---------------------------------------------------- | -------- | --------------------------------- | ------- | ---- |
-| `dictionariesDir`         | Diretório para dicionários compilados.               | `string` | `'.intlayer/dictionary'`          |         |      |
-| `moduleAugmentationDir`   | Diretório para a augmentation de módulos TypeScript. | `string` | `'.intlayer/types'`               |         |      |
-| `unmergedDictionariesDir` | Diretório para dicionários não fundidos.             | `string` | `'.intlayer/unmerged_dictionary'` |         |      |
-| `typesDir`                | Diretório para tipos gerados.                        | `string` | `'.intlayer/types'`               |         |      |
-| `mainDir`                 | Diretório do ficheiro principal do Intlayer.         | `string` | `'.intlayer/main'`                |         |      |
-| `configDir`               | Diretório dos ficheiros de configuração compilados.  | `string` | `'.intlayer/config'`              |         |      |
-| `cacheDir`                | Diretório dos ficheiros de cache.                    | `string` | `'.intlayer/cache'`               |         |      |
-
----
-
 ### Configuração do Compilador
 
 Configurações que controlam o compilador do Intlayer, que extrai dicionários diretamente das suas componentes.

package/docs/pt/custom_domains.md

@@ -45,12 +45,7 @@ import { Locales, type IntlayerConfig } from "intlayer";
 
 const config: IntlayerConfig = {
   internationalization: {
-    locales: [
-      Locales.ENGLISH,
-      Locales.FRENCH,
-      Locales.SPANISH,
-      Locales.CHINESE,
-    ],
+    locales: [Locales.ENGLISH, Locales.FRENCH, Locales.CHINESE],
     defaultLocale: Locales.ENGLISH,
   },
   routing: {

package/docs/pt/custom_url_rewrites.md

@@ -1,6 +1,6 @@
 ---
 createdAt: 2024-08-13
-updatedAt: 2026-01-26
+updatedAt: 2026-06-23
 title: Reescritas de URL Personalizadas
 description: Saiba como configurar e usar reescritas de URL personalizadas no Intlayer para definir caminhos específicos por locale.
 keywords:

package/docs/pt/dictionary/content_file.md

@@ -579,6 +579,10 @@ Esquema JSON usado para validação da estrutura do dicionário. Adicionado auto
 
 Para dicionários remotos, este é o identificador único do dicionário no servidor remoto. Usado para buscar e gerenciar conteúdo remoto.
 
+##### `projectIds` (string[])
+
+Para dicionários remotos, este array contém os IDs dos projetos que podem usar este dicionário. Um dicionário remoto pode ser compartilhado entre vários projetos.
+
 ##### `localId` (LocalDictionaryId)
 
 Identificador único para dicionários locais. Gerado automaticamente pelo Intlayer para ajudar a identificar o dicionário e determinar se é local ou remoto, junto com sua localização.
@@ -599,13 +603,6 @@ Para dicionários remotos, este array contém todas as versões disponíveis do
 
 Indica se o dicionário foi preenchido automaticamente a partir de fontes externas. Em caso de conflitos, os dicionários base substituirão os dicionários preenchidos automaticamente.
 
-##### `location` ('distant' | 'locale')
-
-Indica a localização do dicionário:
-
-- `'locale'`: Dicionário local (a partir dos arquivos de conteúdo)
-- `'distant'`: Dicionário remoto (a partir de fonte externa)
-
 ## Tipos de Nós de Conteúdo
 
 O Intlayer fornece vários tipos especializados de nós de conteúdo que estendem valores primitivos básicos:

package/docs/pt/dictionary/enumeration.md

@@ -468,199 +468,12 @@ document.getElementById("ranking")!.textContent = content.ordinal(lastDigit)({
   </Tab>
 </Tabs>
 
-## Combining Enumeration with Insert for Ordinal Numbers
-
-<Tabs group="framework">
-  <Tab label="React" value="react">
-
-To use enumeration in a React component, you can leverage the `useIntlayer` hook from the `react-intlayer` package. This hook retrieves the correct content based on the specified ID. Here's an example of how to use it:
-
-```tsx fileName="**/*.tsx" codeFormat={["typescript", "esm"]}
-import type { FC } from "react";
-import { useIntlayer } from "react-intlayer";
-
-const CarComponent: FC = () => {
-  const { numberOfCar } = useIntlayer("car_count");
-
-  return (
-    <div>
-      <p>
-        {
-          numberOfCar(0) // Output: No cars
-        }
-      </p>
-      <p>
-        {
-          numberOfCar(6) // Output: Some cars
-        }
-      </p>
-      <p>
-        {
-          numberOfCar(20) // Output: Many cars
-        }
-      </p>
-      <p>
-        {
-          numberOfCar(0.01) // Output: Fallback value
-        }
-      </p>
-    </div>
-  );
-};
-```
-
-  </Tab>
-  <Tab label="Next.js" value="nextjs">
-
-To use enumeration in Next.js Client Components, retrieve it via the `useIntlayer` hook. Here's an example:
-
-```tsx fileName="**/*.tsx" codeFormat={["typescript", "esm"]}
-"use client";
-
-import type { FC } from "react";
-import { useIntlayer } from "next-intlayer";
-
-const CarComponent: FC = () => {
-  const { numberOfCar } = useIntlayer("car_count");
-
-  return (
-    <div>
-      <p>{numberOfCar(6)}</p>
-    </div>
-  );
-};
-
-export default CarComponent;
-```
-
-  </Tab>
-  <Tab label="Vue" value="vue">
-
-To use enumeration in Vue components, retrieve it via the `useIntlayer` hook. Here's an example:
-
-```vue fileName="**/*.vue"
-<script setup lang="ts">
-import { useIntlayer } from "vue-intlayer";
-
-const { numberOfCar } = useIntlayer("car_count");
-</script>
-
-<template>
-  <div>
-    <p>{{ numberOfCar(6) }}</p>
-  </div>
-</template>
-```
-
-  </Tab>
-  <Tab label="Svelte" value="svelte">
-
-To use enumeration in Svelte components, retrieve it via the `useIntlayer` hook. The store is accessed with `$`. Here's an example:
-
-```svelte fileName="**/*.svelte"
-<script lang="ts">
-import { useIntlayer } from "svelte-intlayer";
-
-const content = useIntlayer("car_count");
-</script>
-
-<div>
-  <p>{$content.numberOfCar(6)}</p>
-</div>
-```
-
-  </Tab>
-  <Tab label="Preact" value="preact">
-
-To use enumeration in Preact components, retrieve it via the `useIntlayer` hook. Here's an example:
-
-```tsx fileName="**/*.tsx" codeFormat={["typescript", "esm"]}
-import type { FC } from "preact";
-import { useIntlayer } from "preact-intlayer";
-
-const CarComponent: FC = () => {
-  const { numberOfCar } = useIntlayer("car_count");
-
-  return (
-    <div>
-      <p>{numberOfCar(6)}</p>
-    </div>
-  );
-};
-
-export default CarComponent;
-```
-
-  </Tab>
-  <Tab label="Solid" value="solid">
-
-To use enumeration in SolidJS components, retrieve it via the `useIntlayer` hook. Here's an example:
-
-```tsx fileName="**/*.tsx" codeFormat={["typescript", "esm"]}
-import type { Component } from "solid-js";
-import { useIntlayer } from "solid-intlayer";
-
-const CarComponent: Component = () => {
-  const { numberOfCar } = useIntlayer("car_count");
-
-  return (
-    <div>
-      <p>{numberOfCar(6)}</p>
-    </div>
-  );
-};
-
-export default CarComponent;
-```
-
-  </Tab>
-  <Tab label="Angular" value="angular">
-
-To use enumeration in Angular components, retrieve it via the `useIntlayer` hook. Here's an example:
-
-```typescript fileName="app.component.ts" codeFormat="typescript"
-import { Component } from "@angular/core";
-import { useIntlayer } from "angular-intlayer";
-
-@Component({
-  selector: "app-car",
-  template: `
-    <div>
-      <p>{{ content().numberOfCar(6) }}</p>
-    </div>
-  `,
-})
-export class CarComponent {
-  content = useIntlayer("car_count");
-}
-```
-
-  </Tab>
-  <Tab label="Vanilla JS" value="vanilla">
-
-To use enumeration with `vanilla-intlayer`, retrieve it via the `useIntlayer` hook. Here's an example:
-
-```typescript fileName="**/*.ts" codeFormat={["typescript", "esm"]}
-import { installIntlayer, useIntlayer } from "vanilla-intlayer";
-
-installIntlayer();
-
-const content = useIntlayer("car_count").onChange((newContent) => {
-  document.getElementById("cars")!.textContent = newContent.numberOfCar(6);
-});
-
-// Initial render
-document.getElementById("cars")!.textContent = content.numberOfCar(6);
-```
-
-  </Tab>
-</Tabs>
 ## Additional Resources
 
 For more detailed information on configuration and usage, refer to the following resources:
 
-- [Intlayer CLI Documentation](https://github.com/aymericzip/intlayer/blob/main/docs/docs/en/cli/index.md)
-- [React Intlayer Documentation](https://github.com/aymericzip/intlayer/blob/main/docs/docs/en/intlayer_with_create_react_app.md)
-- [Next Intlayer Documentation](https://github.com/aymericzip/intlayer/blob/main/docs/docs/en/intlayer_with_nextjs_15.md)
+- [Intlayer CLI Documentation](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/cli/index.md)
+- [React Intlayer Documentation](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/intlayer_with_create_react_app.md)
+- [Next Intlayer Documentation](https://github.com/aymericzip/intlayer/blob/main/docs/docs/pt/intlayer_with_nextjs_15.md)
 
 These resources provide further insights into the setup and usage of Intlayer in different environments and with various frameworks.

package/docs/pt/dictionary/file.md

@@ -256,6 +256,14 @@ export default myMultilingualContent;
 
 Esta configuração permite que o conteúdo seja recuperado dinamicamente com base na preferência de idioma do usuário. Quando usado no Editor Visual Intlayer ou CMS, o sistema reconhecerá que o conteúdo vem dos arquivos Markdown especificados e garantirá que eles permaneçam editáveis.
 
+## Diferentes tipos de caminhos
+
+Ao usar a função `file`, você pode usar diferentes tipos de caminhos para especificar o arquivo a ser incorporado.
+
+- `file("./path/to/file.txt")` - Caminho relativo ao arquivo atual
+- `file("path/to/file.txt")` - Caminho relativo ao diretório raiz do projeto
+- `file("/users/username/path/to/file.txt")` - Caminho absoluto
+
 ## Como o Intlayer Trata o Conteúdo de Arquivos
 
 A função `file` é baseada no módulo `fs` do Node.js para ler o conteúdo do arquivo especificado e inseri-lo no dicionário. Quando usada em conjunto com o Editor Visual Intlayer ou CMS, o Intlayer pode rastrear a relação entre o dicionário e o arquivo. Isso permite que o Intlayer: