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

package/docs/pt/plugins/sync-json.md

@@ -1,6 +1,6 @@
 ---
 createdAt: 2025-03-13
-updatedAt: 2025-12-13
+updatedAt: 2026-06-21
 title: Plugin Sync JSON
 description: Sincronize os dicionários Intlayer com arquivos JSON i18n de terceiros (i18next, next-intl, react-intl, vue-i18n e mais). Mantenha seu i18n existente enquanto usa o Intlayer para gerenciar, traduzir e testar suas mensagens.
 keywords:
@@ -24,6 +24,9 @@ slugs:
   - sync-json
 youtubeVideo: https://www.youtube.com/watch?v=MpGMxniDHNg
 history:
+  - version: 9.0.0
+    date: 2026-06-21
+    changes: "Adiciona a opção splitKeys (um dicionário por chave de namespace de nível superior) para layouts de arquivo único next-intl / react-intl"
   - version: 7.5.0
     date: 2025-12-13
     changes: "Adicionado suporte para formatos ICU e i18next"
@@ -62,7 +65,63 @@ pnpm add -D @intlayer/sync-json-plugin
 npm i -D @intlayer/sync-json-plugin
 ```
 
-## Início rápido
+## Plugins
+
+Este pacote fornece dois plugins:
+
+- `loadJSON`: Carrega arquivos JSON em dicionários Intlayer.
+  - Este plugin é usado para carregar arquivos JSON de uma fonte e será carregado em dicionários Intlayer. Ele pode escanear todo o codebase e procurar por arquivos JSON específicos.
+    Este plugin pode ser usado
+    - se você usa uma biblioteca i18n que impõe um local específico para seus JSONs serem carregados (ex: `next-intl`, `i18next`, `react-intl`, `vue-i18n`, etc.), mas você quer colocar sua declaração de conteúdo onde quiser em seu codebase.
+    - Também pode ser usado se você quiser buscar suas mensagens de uma fonte remota (ex: um CMS, uma API, etc.) e armazenar suas mensagens em arquivos JSON.
+
+  > Por baixo dos panos, este plugin escaneará todo o codebase e procurará por arquivos JSON específicos e os carregará em dicionários Intlayer.
+  > Note que este plugin não escreverá a saída e as traduções de volta para os arquivos JSON.
+
+- `syncJSON`: Sincroniza arquivos JSON com dicionários Intlayer.
+  - Este plugin é usado para sincronizar arquivos JSON com dicionários Intlayer. Ele pode escanear o local fornecido e carregar o JSON que corresponde ao padrão para arquivos JSON específicos. Este plugin é útil se você quiser obter os benefícios do Intlayer enquanto usa outra biblioteca i18n.
+
+## Usando ambos os plugins
+
+```ts fileName="intlayer.config.ts"
+import { Locales, type IntlayerConfig } from "intlayer";
+import { loadJSON, syncJSON } from "@intlayer/sync-json-plugin";
+
+const config: IntlayerConfig = {
+  internationalization: {
+    locales: [Locales.ENGLISH, Locales.FRENCH, Locales.SPANISH],
+    defaultLocale: Locales.ENGLISH,
+  },
+
+  // Mantenha seus arquivos JSON atuais sincronizados com os dicionários Intlayer
+  plugins: [
+    /**
+     * Irá carregar todos os arquivos JSON na src que correspondem ao padrão {key}.i18n json
+     */
+    loadJSON({
+      source: ({ key }) => `./src/**/${key}.i18n.json`,
+      locale: Locales.ENGLISH,
+      priority: 1, // Garante que esses arquivos JSON tenham precedência sobre os arquivos em `./locales/en/${key}.json`
+      format: "intlayer", // Formato do conteúdo JSON
+    }),
+    /**
+     * Irá carregar e escrever a saída e as traduções de volta para os arquivos JSON no diretório de localidades
+     */
+    syncJSON({
+      format: "i18next",
+      source: ({ key, locale }) => `./locales/${locale}/${key}.json`,
+      priority: 0,
+      format: "i18next",
+    }),
+  ],
+};
+
+export default config;
+```
+
+## `syncJSON` plugin
+
+### Início rápido
 
 Adicione o plugin ao seu `intlayer.config.ts` e aponte para sua estrutura JSON existente.
 
@@ -81,6 +140,7 @@ const config: IntlayerConfig = {
     syncJSON({
       // Layout por localidade, por namespace (por exemplo, next-intl, i18next com namespaces)
       source: ({ key, locale }) => `./locales/${locale}/${key}.json`,
+      format: "icu",
     }),
   ],
 };
@@ -91,14 +151,27 @@ export default config;
 Alternativa: arquivo único por localidade (comum em configurações i18next/react-intl):
 
 ```ts fileName="intlayer.config.ts"
-plugins: [
-  syncJSON({
-    source: ({ locale }) => `./locales/${locale}.json`,
-  }),
-];
+import { Locales, type IntlayerConfig } from "intlayer";
+import { syncJSON } from "@intlayer/sync-json-plugin";
+
+const config: IntlayerConfig = {
+  internationalization: {
+    locales: [Locales.ENGLISH, Locales.FRENCH],
+    defaultLocale: Locales.ENGLISH,
+  },
+  plugins: [
+    syncJSON({
+      format: "i18next",
+      source: ({ locale }) => `./locales/${locale}.json`,
+      format: "i18next",
+    }),
+  ],
+};
+
+export default config;
 ```
 
-### Como funciona
+#### Como funciona
 
 - Leitura: o plugin descobre arquivos JSON a partir do seu construtor `source` e os carrega como dicionários Intlayer.
 - Escrita: após builds e preenchimentos, ele grava o JSON localizado de volta nos mesmos caminhos (com uma nova linha final para evitar problemas de formatação).
@@ -112,6 +185,7 @@ syncJSON({
   location?: string, // rótulo opcional, padrão: "plugin"
   priority?: number, // prioridade opcional para resolução de conflitos, padrão: 0
   format?: 'intlayer' | 'icu' | 'i18next', // formatador opcional, usado para compatibilidade com o runtime Intlayer
+  splitKeys?: boolean, // opcional, divide um único arquivo em um dicionário por chave de nível superior (detecção automática)
 });
 ```
 
@@ -136,17 +210,49 @@ syncJSON({
 }),
 ```
 
-## Múltiplas fontes JSON e prioridade
+#### `splitKeys` (boolean)
+
+Controla se um único arquivo JSON cujas **chaves de primeiro nível são namespaces** deve se tornar um dicionário por chave de nível superior, em vez de um único dicionário contendo o arquivo inteiro.
+
+Isso corresponde ao modelo de namespace de bibliotecas como `next-intl` e `react-intl`, onde um arquivo `messages/{locale}.json` agrupa vários namespaces por suas chaves de primeiro nível, cada um endereçado independentemente (por exemplo, `useTranslations('Hero')` resolve para o dicionário `Hero`).
+
+- `undefined` (padrão): **detecção automática** — o arquivo é dividido quando o padrão `source` não possui um segmento `{key}` (um arquivo contém todos os namespaces), e mantido como um único dicionário caso contrário (um arquivo por chave).
+- `true`: sempre divide cada chave de nível superior em seu próprio dicionário.
+- `false`: nunca divide; o arquivo inteiro se torna um único dicionário.
+
+Dado um único arquivo `messages/{locale}.json`:
+
+```json fileName="messages/en.json"
+{
+  "Hero": { "title": "Full-stack developer" },
+  "Nav": { "work": "Work", "about": "About" },
+  "About": { "lead": "I build apps end to end." }
+}
+```
+
+```ts fileName="intlayer.config.ts"
+syncJSON({
+  format: "icu",
+  source: ({ locale }) => `./messages/${locale}.json`,
+  // splitKeys: true, // implícito porque o padrão não possui um segmento `{key}`
+}),
+```
+
+Isso produz três dicionários — `Hero`, `Nav` e `About` — de modo que `useTranslations('Hero')` (next-intl) resolve corretamente. Na gravação de volta, todos os namespaces são remontados no mesmo arquivo por localidade.
+
+> Quando você mantém o segmento `{key}` explícito em sua `source` (por exemplo, `./locales/${locale}/${key}.json`), cada arquivo já é um namespace, então a divisão é desativada por padrão.
+
+### Múltiplas fontes JSON e prioridade
 
 Você pode adicionar múltiplos plugins `syncJSON` para sincronizar diferentes fontes JSON. Isso é útil quando você tem múltiplas bibliotecas i18n ou diferentes estruturas JSON no seu projeto.
 
-### Sistema de prioridade
+#### Sistema de prioridade
 
 Quando múltiplos plugins têm como alvo a mesma chave de dicionário, o parâmetro `priority` determina qual plugin tem precedência:
 
 - Números de prioridade mais altos ganham sobre os mais baixos
 - Prioridade padrão dos arquivos `.content` é `0`
-- Prioridade padrão dos arquivos de conteúdo dos plugins é `-1`
+- Prioridade padrão dos plugins é `0`
 - Plugins com a mesma prioridade são processados na ordem em que aparecem na configuração
 
 ```ts fileName="intlayer.config.ts"
@@ -189,73 +295,140 @@ const config: IntlayerConfig = {
 export default config;
 ```
 
-### Resolução de conflitos
+## Load JSON plugin
 
-Quando a mesma chave de tradução existe em múltiplas fontes JSON:
+### Início rápido
 
-1. O plugin com a maior prioridade determina o valor final
-2. Fontes com prioridade menor são usadas como fallback para chaves ausentes
-3. Isso permite manter traduções legadas enquanto migra gradualmente para novas estruturas
+Adicione o plugin ao seu `intlayer.config.ts` para ingerir arquivos JSON existentes como dicionários Intlayer. Este plugin é somente leitura (não grava em disco):
 
-## Integrações
+```ts fileName="intlayer.config.ts"
+import { Locales, type IntlayerConfig } from "intlayer";
+import { loadJSON } from "@intlayer/sync-json-plugin";
 
-Abaixo estão mapeamentos comuns. Mantenha seu runtime intacto; apenas adicione o plugin.
+const config: IntlayerConfig = {
+  internationalization: {
+    locales: [Locales.ENGLISH, Locales.FRENCH, Locales.SPANISH],
+    defaultLocale: Locales.ENGLISH,
+  },
+
+  plugins: [
+    // Ingerir mensagens JSON localizadas em qualquer lugar da sua árvore de origem
+    loadJSON({
+      source: ({ key }) => `./src/**/${key}.i18n.json`,
+      // Carregar uma única localidade por instância de plugin (padrão para a defaultLocale da configuração)
+      locale: Locales.ENGLISH,
+      priority: 0,
+    }),
+  ],
+};
 
-### i18next
+export default config;
+```
 
-Layout típico de arquivo: `./public/locales/{locale}/{namespace}.json` ou `./locales/{locale}/{namespace}.json`.
+Alternativa: layout por localidade, ainda somente leitura (apenas a localidade selecionada é carregada):
 
 ```ts fileName="intlayer.config.ts"
-import { syncJSON } from "@intlayer/sync-json-plugin";
+import { Locales, type IntlayerConfig } from "intlayer";
+import { loadJSON } from "@intlayer/sync-json-plugin";
 
-export default {
+const config: IntlayerConfig = {
+  internationalization: {
+    locales: [Locales.ENGLISH, Locales.FRENCH],
+    defaultLocale: Locales.ENGLISH,
+  },
   plugins: [
-    syncJSON({
-      format: "i18next",
+    loadJSON({
+      // Apenas arquivos para Locales.FRENCH serão carregados a partir deste padrão
       source: ({ key, locale }) => `./locales/${locale}/${key}.json`,
+      locale: Locales.FRENCH,
     }),
   ],
 };
+
+export default config;
 ```
 
-### next-intl
+### Como funciona
+
+- Descobrir: constrói um glob a partir do seu construtor `source` e coleta arquivos JSON correspondentes.
+- Ingerir: carrega cada arquivo JSON como um dicionário Intlayer com a `locale` fornecida.
+- Somente leitura: não escreve ou formata arquivos de saída; use `syncJSON` se precisar de sincronização de ida e volta.
+- Pronto para auto-preenchimento: define um padrão `fill` para que `intlayer content fill` possa preencher chaves ausentes.
 
-Mensagens JSON por localidade (frequentemente `./messages/{locale}.json`) ou por namespace.
+### API
 
-```ts fileName="intlayer.config.ts"
-plugins: [
-  syncJSON({
-    source: ({ locale, key }) => `./messages/${locale}/${key}.json`,
-  }),
-];
+```ts
+loadJSON({
+  // Constrói caminhos para o seu JSON. `locale` é opcional se sua estrutura não tiver um segmento de localidade
+  source: ({ key, locale }) => string,
+
+  // Localidade de destino para os dicionários carregados por esta instância de plugin
+  // Padrão para configuration.internationalization.defaultLocale
+  locale?: Locale,
+
+  // Rótulo opcional para identificar a fonte
+  location?: string, // padrão: "plugin"
+
+  // Prioridade usada para resolução de conflitos contra outras fontes
+  priority?: number, // padrão: 0
+
+  // Formatador opcional para o conteúdo JSON
+  format?: 'intlayer' | 'icu' | 'i18next', // padrão: 'intlayer'
+
+  // Divide um único arquivo em um dicionário por chave de nível superior (detecção automática)
+  splitKeys?: boolean,
+});
 ```
 
-Veja também: `docs/pt/intlayer_with_next-intl.md`.
+#### `format` ('intlayer' | 'icu' | 'i18next')
 
-### react-intl
+Especifica o formatador a ser usado para o conteúdo do dicionário ao carregar arquivos JSON. Isso permite usar diferentes sintaxes de formatação de mensagens compatíveis com várias bibliotecas i18n.
 
-JSON único por localidade é comum:
+- `'intlayer'`: O formatador Intlayer padrão (padrão).
+- `'icu'`: Usa formatação de mensagens ICU (compatível com bibliotecas como react-intl, vue-i18n).
+- `'i18next'`: Usa formatação de mensagens i18next (compatível com i18next, next-i18next, Solid-i18next).
 
-```ts fileName="intlayer.config.ts"
-plugins: [
-  syncJSON({
-    source: ({ locale }) => `./locales/${locale}.json`,
-  }),
-];
+**Exemplo:**
+
+```ts
+loadJSON({
+  source: ({ key }) => `./src/**/${key}.i18n.json`,
+  locale: Locales.ENGLISH,
+  format: "icu", // Usar formatação ICU para compatibilidade
+}),
 ```
 
-### vue-i18n
+#### `splitKeys` (boolean)
 
-Pode ser um único arquivo por localidade ou por namespace:
+Mesmo comportamento que em [`syncJSON`](#splitkeys-boolean): quando um único arquivo JSON agrupa vários namespaces por suas chaves de primeiro nível, cada chave de nível superior se torna seu próprio dicionário.
 
-```ts fileName="intlayer.config.ts"
-plugins: [
-  syncJSON({
-    source: ({ key, locale }) => `./src/locales/${locale}/${key}.json`,
-  }),
-];
+- `undefined` (padrão): **detecção automática** — divide quando o padrão `source` não possui um segmento `{key}`, dicionário único caso contrário.
+- `true` / `false`: força ou desabilita a divisão.
+
+```ts
+loadJSON({
+  source: ({ locale }) => `./messages/${locale}.json`,
+  format: "icu",
+  // splitKeys auto-enabled: `Hero`, `Nav`, `About`, … cada um se torna um dicionário
+}),
 ```
 
+### Comportamento e convenções
+
+- Se sua máscara `source` incluir um placeholder de localidade, apenas os arquivos para a `locale` selecionada serão ingeridos.
+- Se não houver um segmento `{key}` em sua máscara, cada chave de nível superior do arquivo se torna seu próprio dicionário por padrão (veja [`splitKeys`](#splitkeys-boolean)). Defina `splitKeys: false` para carregar o arquivo inteiro como um único dicionário `index`.
+- As chaves são derivadas dos caminhos dos arquivos substituindo o placeholder `{key}` em seu construtor `source`.
+- O plugin usa apenas arquivos descobertos e não fabrica localidades ou chaves ausentes.
+- O caminho `fill` é inferido de sua `source` e usado para atualizar valores ausentes via CLI quando você opta por isso.
+
+## Resolução de conflitos
+
+Quando a mesma chave de tradução existe em múltiplas fontes JSON:
+
+1. O plugin com a maior prioridade determina o valor final
+2. Fontes com prioridade menor são usadas como fallbacks para chaves ausentes
+3. Isso permite manter traduções legadas enquanto migra gradualmente para novas estruturas
+
 ## CLI
 
 Os arquivos JSON sincronizados serão considerados como outros arquivos `.content`. Isso significa que todos os comandos do intlayer estarão disponíveis para os arquivos JSON sincronizados. Incluindo:

package/docs/pt/releases/v8.md

@@ -1,6 +1,6 @@
 ---
 createdAt: 2025-09-22
-updatedAt: 2026-01-26
+updatedAt: 2026-06-14
 title: Novo Intlayer v8 - O que há de novo?
 description: Descubra as novidades do Intlayer v8. Principais melhorias na experiência do desenvolvedor, validação de esquemas e gestão de dicionários.
 keywords:
@@ -409,6 +409,16 @@ Para mais detalhes, consulte a [Documentação de Conteúdo HTML](https://github
 
 ---
 
+## Ficheiros de Conteúdo YAML & Markdown (v8.10.0)
+
+Agora pode declarar conteúdo diretamente usando as extensões de ficheiro `.content.md` e `.content.yaml`. Isto é perfeito para conteúdos longos, blogs, documentação e políticas de privacidade.
+
+Estes ficheiros são totalmente editáveis a partir do Visual Editor, proporcionando um fluxo de trabalho simplificado para membros não técnicos da equipa.
+
+Para mais detalhes, consulte a [Documentação de Ficheiros de Conteúdo YAML](https://intlayer.org/doc/concept/content#yaml-content-file) e a [Documentação de Ficheiros de Conteúdo Markdown](https://intlayer.org/doc/concept/content/markdown).
+
+---
+
 ## Reescritas de URL Personalizadas
 
 O Intlayer v8 introduz suporte para **Reescritas de URL Personalizadas**, permitindo que você defina caminhos específicos por localidade que diferem da estrutura padrão `/locale/path`. Este é um recurso poderoso para melhorar o local SEO e proporcionar uma experiência de usuário mais natural para usuários que não falam inglês.
@@ -753,6 +763,58 @@ export default {
   </Tab>
 </Tabs>
 
+## Regras de Plural Unicode CLDR (v8.8.0)
+
+Foi introduzido um novo helper de nó `plural` baseado nas regras de plural definidas pelo Projeto Unicode CLDR, melhorando o suporte para idiomas complexos.
+
+```typescript fileName="src/openings.content.ts"
+import { plural, t, type Dictionary } from "intlayer";
+
+const openingsContent = {
+  key: "total_openings",
+  content: {
+    totalOpenings: t({
+      en: plural({
+        one: "{{count}} opening",
+        other: "{{count}} openings",
+      }),
+      fr: plural({
+        one: "{{count}} offre",
+        other: "{{count}} offres",
+      }),
+    }),
+  },
+} satisfies Dictionary;
+
+export default openingsContent;
+```
+
+Você pode então passar a contagem dinamicamente no componente do seu framework:
+
+```tsx
+import type { FC } from "react";
+import { useIntlayer } from "react-intlayer";
+
+const OpeningsComponent: FC<{ count: number }> = ({ count }) => {
+  const { totalOpenings } = useIntlayer("total_openings");
+
+  return (
+    <div>
+      {/* Em Inglês:                                  */}
+      {/*  count=0  → "0 openings"   (other)           */}
+      {/*  count=1  → "1 opening"    (one)             */}
+      {/*  count=2  → "2 openings"   (other)           */}
+      {/*  count=21 → "21 openings"  (other)           */}
+      <p>{totalOpenings(count)}</p>
+    </div>
+  );
+};
+```
+
+Para mais informações, consulte a [Documentação de Pluralização](https://intlayer.org/doc/concept/content/plural).
+
+---
+
 ## Validação de Esquema de Conteúdo
 
 O Intlayer v8 introduz a validação de esquema para dicionários. Agora você pode definir esquemas de validação reutilizáveis em sua configuração usando Zod e aplicá-los aos seus arquivos de conteúdo. Isso garante que seu conteúdo sempre adira à estrutura esperada, capturando erros em tempo de build.
@@ -797,6 +859,34 @@ Se o conteúdo não corresponder ao esquema (por exemplo, o título é muito cur
 
 ---
 
+## TypeScript: Acessores Primitivos IntlayerNode
+
+O tipo `IntlayerNode` foi atualizado para permitir a chamada de métodos JavaScript primitivos diretamente nos nós de conteúdo. Isto torna possível interagir com o seu conteúdo localizado diretamente como se fosse uma primitiva padrão de string, number, boolean ou array.
+
+Suportado em React, Preact, Solid, Svelte, Vue e Angular.
+
+### Exemplo de String
+
+```typescript
+content.placeholder; // Retorna IntlayerNode<string>
+content.placeholder.value; // Retorna string
+content.placeholder.toString(); // Retorna string
+content.placeholder.toLowerCase(); // Retorna string
+String(content.placeholder); // Retorna string
+content.placeholder.toUpperCase(); // Retorna string em maiúsculas
+content.placeholder.replace("a", "b"); // Retorna string modificada
+```
+
+### Exemplo de Array
+
+```typescript
+content.myArrayOfString             // Retorna IntlayerNode<Array<string>>
+content.myArrayOfString.find(...)   // Retorna elemento
+content.myArrayOfString.join(', ')  // Retorna string unida
+```
+
+---
+
 ### Detecção Automática de Conteúdo Aprimorada
 
 Na v8, o Intlayer detecta inteligentemente a sintaxe Markdown, tags HTML e inserções de variáveis em suas strings de conteúdo. Isso significa que muitas vezes você pode omitir funções auxiliares como `md()`, `html()` ou `insert()`.
@@ -1002,6 +1092,17 @@ A extensão Intlayer para VSCode recebe atualizações significativas na v8 para
 
 ---
 
+## Ferramentas: Watcher C++ & LSP baseado em OXC (v8.12.0)
+
+O Intlayer v8.12.0 traz grandes melhorias para a experiência do desenvolvedor:
+
+- **Parcel Watcher**: O watcher de conteúdo foi migrado de `chokidar` para `@parcel/watcher`, aproveitando a monitorização nativa de ficheiros em C++ para fornecer atualizações mais rápidas e um consumo de memória significativamente menor.
+- **Novo Language Server Protocol (LSP)**: Um novo LSP está agora disponível. Construído com análise baseada em OXC, ajuda o seu IDE e agentes de IA a ligar perfeitamente as chamadas `useIntlayer('my-key')` aos seus ficheiros `.content` correspondentes, e vice-versa.
+
+Para mais detalhes, consulte a [Documentação do LSP](https://intlayer.org/doc/lsp).
+
+---
+
 ## Otimizações do Compilador
 
 Intlayer v8 inclui uma nova camada de cache para o compilador Markdown e HTML. Isso garante que strings de conteúdo idênticas com a mesma configuração sejam analisadas apenas uma vez, reduzindo significativamente a sobrecarga durante re-renders ou quando o mesmo conteúdo é usado em vários lugares.
@@ -1057,6 +1158,48 @@ Intlayer v8 inclui uma nova camada de cache para o compilador Markdown e HTML. I
 
 ---
 
+## Otimizações de Build Experimentais: Minify & Purge (v8.7.0)
+
+O Intlayer v8.7.0 introduz novos recursos experimentais de build no seu `intlayer.config.ts` projetados para otimizar o seu bundle de produção:
+
+- **Minimização de Dicionários (Minify)**: Minimiza os ficheiros de dicionário para reduzir o tamanho.
+- **Purga de Chaves Não Utilizadas (Purge)**: Varre e remove chaves de tradução não utilizadas dos dicionários, renomeando as chaves ativas para caracteres curtos (por exemplo, `"products" -> "a"`, `"pricing" -> "b"`). Isto reduz o tamanho do bundle em até 5%.
+- **Desativar Verificações TypeScript**: Acelera as builds desativando a verificação de tipos TypeScript durante a etapa de compilação.
+
+```typescript fileName="intlayer.config.ts"
+import { Locales, type IntlayerConfig } from "intlayer";
+
+const config: IntlayerConfig = {
+  internationalization: {
+    locales: [Locales.ENGLISH, Locales.FRENCH],
+    defaultLocale: Locales.ENGLISH,
+  },
+  dictionary: {
+    importMode: "dynamic",
+  },
+  build: {
+    /**
+     * Minimiza os dicionários para reduzir o tamanho do bundle.
+     */
+    minify: true,
+
+    /**
+     * Purga as chaves não utilizadas nos dicionários
+     */
+    purge: true,
+
+    /**
+     * Indica se a build deve verificar os tipos TypeScript
+     */
+    checkTypes: false,
+  },
+};
+
+export default config;
+```
+
+---
+
 ## Flexibilidade: Modo Unificado de Importação
 
 A propriedade booleana `live` foi descontinuada em favor de uma propriedade mais abrangente `importMode`. Isso permite a definição explícita de como os dicionários devem ser carregados: estaticamente, dinamicamente ou via sincronização ao vivo.
@@ -1204,6 +1347,49 @@ Conteúdo Markdown e HTML no Svelte agora é automaticamente convertido para HTM
 
 ---
 
+## Suporte Angular: Vite Bundler (v8.11.0)
+
+Para utilizadores do Angular, o Intlayer agora suporta nativamente o bundler Vite através de um novo plugin esbuild personalizado, acelerando os tempos de desenvolvimento e build.
+
+Para detalhes sobre a configuração, consulte a [Documentação do Ambiente Angular](https://intlayer.org/doc/environment/angular).
+
+---
+
+## Geração de Sitemap (v8.6.0)
+
+O Intlayer agora gera sitemaps automaticamente com base nas suas localidades e modo de roteamento. Isto é particularmente útil para otimização de SEO em arquiteturas de roteador como o TanStack Router:
+
+```typescript fileName="src/routes/sitemap.xml.ts"
+import { createFileRoute } from "@tanstack/react-router";
+import { generateSitemap } from "intlayer";
+
+const SITE_URL = (
+  import.meta.env.VITE_SITE_URL ?? "http://localhost:3000"
+).replace(/\/$/, "");
+
+export const Route = createFileRoute("/sitemap.xml")({
+  server: {
+    handlers: {
+      GET: async () => {
+        const sitemap = generateSitemap(
+          [
+            { path: "/", changefreq: "daily", priority: 1.0 },
+            { path: "/about", changefreq: "monthly", priority: 0.8 },
+          ],
+          { siteUrl: SITE_URL }
+        );
+
+        return new Response(sitemap, {
+          headers: { "Content-Type": "application/xml" },
+        });
+      },
+    },
+  },
+});
+```
+
+---
+
 ## Notas de migração da v7
 
 ### Alterações na Configuração