Autor:
    Criação:2025-04-18Última atualização:2026-05-31

    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.