Autor:
    Criação:2025-04-18Última atualização:2026-08-30

    Traduza seu site Angular 22 (Vite) usando Intlayer | Internacionalização (i18n)

    Índice

    Por que Intlayer em vez de alternativas?

    Comparado com soluções principais como ngx-translate ou angular-l10n, Intlayer é uma solução que vem com otimizações integradas como:

    O Intlayer é otimizado para funcionar perfeitamente com Angular, oferecendo escopo de conteúdo em nível de componente, traduções de carregamento lento e todos os recursos necessários para dimensionar a internacionalização (i18n).

    Em vez de carregar arquivos JSON enormes em suas páginas, carregue apenas o conteúdo necessário. O Intlayer ajuda a reduzir o tamanho do bundle e das páginas em até 50%.

    Definir o escopo do conteúdo do seu aplicativo facilita a manutenção de aplicativos de grande escala. Você pode duplicar ou excluir uma única pasta de recursos sem o fardo mental de revisar toda a base de código de seu conteúdo. Além disso, o Intlayer é totalmente tipado (fully typed) para garantir a precisão do seu conteúdo.

    A co-localização de conteúdo reduz o contexto necessário pelos Large Language Models (LLMs). O Intlayer também vem com um conjunto de ferramentas, como uma CLI para testar traduções ausentes,LSP, MCP, e agent skills, para tornar a experiência do desenvolvedor (DX) ainda mais tranquila para os agentes de IA.

    Use a automação para traduzir seu pipeline de CI/CD usando o LLM de sua escolha às custas de seu provedor de IA. O Intlayer também oferece um compilador para automatizar a extração de conteúdo, bem como uma plataforma web para ajudar a traduzir em segundo plano.

    Conectar arquivos JSON enormes a componentes pode levar a problemas de desempenho e reatividade. O Intlayer otimiza o carregamento do seu conteúdo no momento da construção.

    Mais do que apenas uma solução i18n, o Intlayer fornece um [editor visual] auto-hospedado(/pt/doc/concept/editor) e um CMS completo para ajudá-lo a gerenciar seu conteúdo multilíngue em tempo real, facilitando a colaboração com tradutores, redatores e outros membros da equipe. O conteúdo pode ser armazenado local e/ou remotamente.


    Guia Passo a Passo para Configurar o Intlayer em uma Aplicação Angular

    ide.intlayer.org
    intlayer-angular-22-template.vercel.app

    Veja o Modelo de Aplicação no GitHub.

    1. Instalar Dependências

      Instale os pacotes necessários usando o npm:

      bash
      npx intlayer init --interactive
      
      a flag --interactive é opcional. Use intlayer-cli init se você for um agente de IA.
      Este comando detectará seu ambiente e instalará os pacotes necessários. Por exemplo:
      bash
      npm install intlayer angular-intlayer
      npm install @angular-builders/custom-esbuild --save-dev
      
      • intlayer

        O pacote principal que fornece ferramentas de internacionalização para gerenciamento de configuração, tradução, declaração de conteúdo, transpilação e comandos CLI.

      • angular-intlayer O pacote que integra o Intlayer à aplicação Angular. Ele fornece provedores de contexto e hooks para internacionalização Angular.

      • @angular-builders/custom-esbuild Necessário para personalizar a configuração esbuild da Angular CLI.

    2. Configuração do seu projeto

      Crie um arquivo de configuração para configurar os idiomas da sua aplicação:

      intlayer.config.ts
      import { Locales, type IntlayerConfig } from "intlayer";
      
      const config: IntlayerConfig = {
        internationalization: {
          locales: [
            Locales.ENGLISH,
            Locales.FRENCH,
            Locales.SPANISH,
            // Seus outros idiomas
          ],
          defaultLocale: Locales.ENGLISH,
        },
      };
      
      export default config;
      
      Por meio desse arquivo de configuração, você pode configurar URLs localizadas, redirecionamento de middleware, nomes de cookies, a localização e a extensão de suas declarações de conteúdo, desabilitar os logs do Intlayer no console e muito mais. Para uma lista completa dos parâmetros disponíveis, consulte a documentação de configuração.
    3. Integrar o Intlayer na sua Configuração Angular

      Para integrar o Intlayer com o Angular CLI, você precisa usar um builder personalizado. Este guia assume que você está usando Vite/esbuild (padrão para projetos Angular 22).

      Primeiro, modifique seu angular.json para usar o construtor esbuild personalizado. Atualize as configurações build e serve:

      angular.json
      {
        "projects": {
          "your-app-name": {
            "architect": {
              "build": {
                "builder": "@angular-builders/custom-esbuild:application", // replace "@angular/build:application"
                "options": {
                  "define": {
                    "process.env": "{}",
                  },
                  "plugins": ["./esbuild.plugins.ts"],
                  "browser": "src/main.ts",
                  // ...
                },
              },
              "serve": {
                "builder": "@angular-builders/custom-esbuild:dev-server", // replace "@angular/build:dev-server"
                "options": {
                  "prebundle": {
                    "exclude": [
                      "intlayer",
                      "angular-intlayer",
                      "@intlayer/config/built",
                      "@intlayer/core"
                    ]
                },
              },
            },
          },
        },
      }
      
      Certifique-se de substituir your-app-name pelo nome real do seu projeto em angular.json.

      Em seguida, crie um arquivo esbuild.plugins.ts na raiz do seu projeto:

      esbuild.plugins.ts
      import { intlayerEsbuildPlugin } from "angular-intlayer/esbuild";
      
      export default [intlayerEsbuildPlugin()];
      
      A função intlayerEsbuildPlugin configura o esbuild com o Intlayer. Ela injeta o plugin para gerenciar arquivos de declaração de conteúdo e configura alias para desempenho ideal.

      Usuários do NX: Os construtores Angular do NX carregam arquivos de plug-in por meio da resolução ESM nativa do Node e não compilam arquivos de plug-in TypeScript dinamicamente. Use um arquivo .mjs e atualize a referência plugins no angular.json de acordo:

      esbuild.plugins.mjs
      import { intlayerEsbuildPlugin } from "angular-intlayer/esbuild";
      
      export default [intlayerEsbuildPlugin()];
      

      Em seguida, no angular.json, aponte para "./esbuild.plugins.mjs" em vez de "./esbuild.plugins.ts".

    4. Declare seu Conteúdo

      Crie e gerencie suas declarações de conteúdo para armazenar traduções:

      Suas declarações de conteúdo podem ser definidas em qualquer lugar de sua aplicação, desde que sejam incluídas no diretório contentDir (por padrão, ./src). E que correspondam à extensão do arquivo de declaração de conteúdo (por padrão, .content.{json,ts,tsx,js,jsx,mjs,cjs,md,mdx,yaml,yml}).
      Para mais detalhes, consulte a documentação de declaração de conteúdo.
    5. Utilize o Intlayer no seu Código

      Para utilizar os recursos de internacionalização do Intlayer em toda a sua aplicação Angular, você precisa fornecer o Intlayer na configuração da sua aplicação.

      src/app/app.config.ts
      import { ApplicationConfig } from "@angular/core";
      import { provideRouter } from "@angular/router";
      import { provideIntlayer } from "angular-intlayer";
      import { routes } from "./app.routes";
      
      export const appConfig: ApplicationConfig = {
        providers: [
          provideRouter(routes),
          provideIntlayer(), // Adicione o provedor Intlayer aqui
        ],
      };
      

      Em seguida, você pode usar a função useIntlayer em qualquer componente.

      src/app/app.component.ts
      import { Component } from "@angular/core";
      import { RouterOutlet } from "@angular/router";
      import { useIntlayer } from "angular-intlayer";
      
      @Component({
        selector: "app-root",
        standalone: true,
        imports: [RouterOutlet],
        templateUrl: "./app.component.html",
        styleUrl: "./app.component.css",
      })
      export class AppComponent {
        content = useIntlayer("app");
      }
      

      E no seu template:

      src/app/app.component.html
      <div class="content">
        <h1>{{ content().title }}</h1>
        <p>{{ content().congratulations }}</p>
      </div>
      

      O conteúdo Intlayer é retornado como um Signal, então você acessa os valores chamando o sinal: content().title.

    6. Mude o idioma do seu conteúdo

      Opcional

      Para mudar o idioma do seu conteúdo, você pode usar a função setLocale fornecida pela função useLocale. Isso permite que você defina o idioma do aplicativo e atualize o conteúdo de acordo.

      Crie um componente para alternar entre os idiomas:

      src/app/locale-switcher.component.ts
      import { Component } from "@angular/core";
      import { CommonModule } from "@angular/common";
      import { useLocale } from "angular-intlayer";
      
      @Component({
        selector: "app-locale-switcher",
        standalone: true,
        imports: [CommonModule],
        template: `
          <div class="locale-switcher">
            <select
              [value]="locale()"
              (change)="setLocale($any($event.target).value)"
            >
              @for (loc of availableLocales; track loc) {
                <option [value]="loc">{{ loc }}</option>
              }
            </select>
          </div>
        `,
      })
      export class LocaleSwitcherComponent {
        localeCtx = useLocale();
      
        locale = this.localeCtx.locale;
        availableLocales = this.localeCtx.availableLocales;
        setLocale = this.localeCtx.setLocale;
      }
      

      Em seguida, use este componente no seu app.component.ts:

      src/app/app.component.ts
      import { Component } from "@angular/core";
      import { RouterOutlet } from "@angular/router";
      import { useIntlayer } from "angular-intlayer";
      import { LocaleSwitcherComponent } from "./locale-switcher.component";
      
      @Component({
        selector: "app-root",
        standalone: true,
        imports: [RouterOutlet, LocaleSwitcherComponent],
        templateUrl: "./app.component.html",
        styleUrl: "./app.component.css",
      })
      export class AppComponent {
        content = useIntlayer("app");
      }
      

    Configurar TypeScript

    O Intlayer usa o aumento de módulo para obter os benefícios do TypeScript e tornar sua base de código mais forte.

    Autocompletar

    Erro de tradução

    Certifique-se de que sua configuração do TypeScript inclua os tipos gerados automaticamente.

    tsconfig.json
    {
      // ... Suas configurações TypeScript existentes
      "include": [
        // ... Suas configurações TypeScript existentes
        ".intlayer/**/*.ts", // Incluir os tipos gerados automaticamente
      ],
    }
    

    Configuração do Git

    É recomendável ignorar os arquivos gerados pelo Intlayer. Isso permite que você evite confirmá-los no seu repositório Git.

    Para fazer isso, você pode adicionar as seguintes instruções ao seu arquivo .gitignore:

    bash
    # Ignorar os arquivos gerados pelo Intlayer
    .intlayer
    

    Extensão do VS Code

    Para melhorar sua experiência de desenvolvimento com o Intlayer, você pode instalar a extensão oficial Intlayer VS Code Extension.

    Instalar do VS Code Marketplace

    Esta extensão oferece:

    • Autocompletar para chaves de tradução.
    • Detecção de erros em tempo real para traduções ausentes.
    • Visualizações integradas do conteúdo traduzido.
    • Ações rápidas para criar e atualizar facilmente traduções.

    Para obter mais detalhes sobre como usar a extensão, consulte a documentação da Extensão do VS Code do Intlayer.


    Vá além

    Para ir mais longe, você pode implementar o editor visual ou externalizar o seu conteúdo usando o CMS.


    Perguntas Frequentes

    • @angular/localize, a solução nativa de i18n: as mensagens são extraídas para XLIFF e cada locale é compilado em seu próprio build, gerando um artefato de implantação separado por idioma e impedindo a troca dinâmica de idiomas em tempo de execução sem recarregar a aplicação.
    • ngx-translate e Transloco: catálogos JSON carregados via serviço em tempo de execução, com suporte à troca de idiomas dinâmica, mas sem verificação de tipos em tempo de compilação.
    • Intlayer: a solução mais avançada. O conteúdo pode ser declarado em qualquer lugar da sua base de código (ao lado de cada componente ou centralizado) e compilado em tempo de build, totalmente tipado, com troca de idioma em tempo de execução, tradução por IA, editor visual e CMS.

    O principal motivo para deixar o @angular/localize é o modelo de um build por idioma. O Intlayer mantém uma compilação única e alterna os idiomas em tempo de execução. Consulte por que Intlayer.

    Muito menos do que uma configuração baseada em namespaces, porque uma página nunca baixa um catálogo que não renderiza. O compilador em tempo de build substitui as chamadas useIntlayer pelas entradas exatas que o componente utiliza. Assim, chaves e idiomas não utilizados são descartados, e os dicionários dinâmicos dividem o restante por locale. Comparado às alternativas habituais, o Intlayer reduz o tamanho do bundle e da página em até 50%. Consulte otimização de bundle e o benchmark.

    Em grande parte, sim. Siga o guia de migração do ngx-translate ou o guia de migração do Transloco para migrar o conteúdo. Você também pode migrar gradualmente: o plugin sync JSON mantém seus catálogos JSON existentes como fonte de verdade e gera dicionários Intlayer a partir deles, mantendo ambas as camadas sincronizadas enquanto você migra templates um a um.

    Sim. O plugin sync JSON mantém seus arquivos /messages/{locale}/{namespace}.json como fonte de verdade e gera dicionários Intlayer a partir deles, em ambas as direções. O plugin sync PO faz o mesmo para catálogos gettext, e os arquivos por locale permitem dividir o conteúdo por idioma em vez de agrupar todos os locales em um único arquivo.

    Não. Execute npx intlayer extract e o Intlayer lê seus arquivos fonte, extrai as strings voltadas para o usuário e escreve um arquivo .content ao lado de cada um, para que você revise um diff em vez de copiar strings para um catálogo uma a uma. Consulte o comando extract.

    Para um fluxo de trabalho totalmente automatizado, o Intlayer Compiler faz o mesmo em tempo de build em código JSX, TSX, Vue e Svelte, gerando os dicionários a cada alteração para que não haja necessidade de manter chaves manualmente. Como opera por análise estática, strings criadas exclusivamente em tempo de execução ficam fora de alcance, necessitando de algumas anotações para diferenciar texto do usuário de lógica interna da aplicação.

    Cinco ferramentas, todas opcionais:

    • Extensão VS Code: navegue de uma chave useIntlayer diretamente para o arquivo de conteúdo que a declara, extraia conteúdo de um componente e execute build, fill, test, push e pull pela paleta de comandos ou pela aba dedicada do Intlayer.
    • Servidor LSP: a mesma inteligência em qualquer editor compatível com LSP, com ir para definição, localizar referências, pré-visualizações de valores traduzidos ao passar o mouse, autocompletar e alertas para chaves não declaradas. Também resolve chamadas de i18next, react-i18next, next-intl e use-intl, facilitando a migração.
    • Servidor MCP: expõe a documentação e a CLI do Intlayer para Cursor, VS Code, Claude Desktop, Claude Code e ChatGPT, permitindo que os assistentes respondam com base na documentação atualizada e executem comandos como intlayer fill.
    • Agent Skills: habilidades focadas como intlayer-config, intlayer-cli e intlayer-content, além de uma por framework, ensinando ao agente suas regras de roteamento e tipos de nós.
    • Plugin ESLint: a regra no-raw-text identifica strings hardcoded, com regras adicionais para chaves estáticas e conteúdo não utilizado.