著者:
    Aymeric PINEAU
    作成:2024-12-06最終更新:2026-06-23

    Intlayer を使用した Next.js 15 ウェブサイトの国際化 (i18n)

    目次

    代替手段ではなく Interlayer を使用する理由

    「next-intl」や「i18next」などの主要なソリューションと比較して、Intlayer は次のような統合された最適化を備えたソリューションです。

    Next.js を完全にカバー

    Intlayer は、効率的なレンダリングのために サーバー コンポーネント と連携するように最適化されており、Turbopack と完全に互換性があります。静的レンダリングをブロックせず、ミドルウェアとスケーリング国際化 (i18n) に必要なすべての機能を提供します。

    Intlayer は Next.js 12、13、14、15、および 16 と互換性があります。 Next.js Pages Router を使用している場合は、この ガイド を参照してください。 ロケール ルーティングは、SEO、バンドル サイズ、パフォーマンスに役立ちます。必要ない場合は、このガイドを参照してください。 App Router を使用した Next.js 12、13、14、および 15 については、この ガイド を参照してください。

    バンドルサイズ

    大量の JSON ファイルをページにロードするのではなく、必要なコンテンツのみをロードします。 Intlayer は、バンドルとページのサイズを最大 50% 削減するのに役立ちます。

    保守性

    アプリケーションのコンテンツのスコープを設定すると、大規模なアプリケーションの メンテナンスが容易になります。コンテンツ コードベース全体を確認するという精神的な負担を負うことなく、単一の機能フォルダーを複製または削除できます。さらに、Intlayer は完全に型指定されており、コンテンツの正確性を保証します。

    AI エージェント

    コンテンツを同じ場所に配置すると、大規模言語モデル (LLM) によって 必要なコンテキストが削減されます。 Intlayer には、翻訳の欠落をテストする CLI、LSP、MCP などのツール スイートも付属しています。および agent skills により、AI エージェントの開発者エクスペリエンス (DX) がさらにスムーズになります。

    オートメーション

    AI プロバイダーの費用で、選択した LLM を使用して CI/CD パイプラインで自動化を変換します。 Intlayer は、コンテンツ抽出を自動化する コンパイラー と、バックグラウンドでの翻訳を支援する Web プラットフォーム も提供します。

    パフォーマンス

    大規模なJSONファイルをコンポーネントに接続すると、パフォーマンスと反応性の問題につながる可能性があります。Intlayerはビルド時にコンテンツの読み込みを最適化します。

    大量の JSON ファイルをコンポーネントに接続すると、パフォーマンスと反応性の問題が発生する可能性があります。 Intlayer は、ビルド時のコンテンツの読み込みを最適化します。

    非開発によるスケーリング

    Intlayer は単なる i18n ソリューションではなく、自己ホスト型 ビジュアル エディター と 完全な CMS を提供します。 リアルタイムで多言語コンテンツを管理できるようになり、翻訳者、コピーライター、その他のチーム メンバーとのコラボレーションがシームレスになります。コンテンツはローカルおよび/またはリモートに保存できます。

    </AccordionGroup>

    Next.jsアプリケーションでIntlayerをセットアップするステップバイステップガイド

    www.youtube.com
    ide.intlayer.org
    next-15-intlayer-template-xt83.vercel.app

    Application Template を GitHub で確認してください。

    1. 依存パッケージのインストール

      npmを使って必要なパッケージをインストールします：

      bash
      npx intlayer init --interactive
      --interactive フラグはオプションです。AI エージェントの場合は intlayer-cli init を使用してください。
      このコマンドは環境を検出し、必要なパッケージをインストールします。例えば：
      bash
      npm install intlayer next-intlayer

      • intlayer

        設定管理、翻訳、コンテンツ宣言、トランスパイル、およびCLIコマンドのための国際化ツールを提供するコアパッケージです。

      • next-intlayer

      IntlayerをNext.jsと統合するパッケージです。Next.jsの国際化のためのコンテキストプロバイダーやフックを提供します。さらに、IntlayerをWebpackやTurbopackと統合するためのNext.jsプラグイン、およびユーザーの優先ロケールの検出、クッキー管理、URLリダイレクト処理のためのミドルウェアも含まれています。

    2. プロジェクトの設定

      Here is the final structure that we will make:

      bash
      .
├── src
│   ├── app
│   │   ├── [locale]
│   │   │   ├── layout.tsx            # Locale layout for the Intlayer provider
│   │   │   ├── page.content.ts
│   │   │   └── page.tsx
│   │   └── layout.tsx                # Root layout for style and global providers
│   ├── components
│   │   ├── client-component-example.content.ts
│   │   ├── ClientComponentExample.tsx
│   │   ├── LocaleSwitcher
│   │   │   ├── localeSwitcher.content.ts
│   │   │   └── LocaleSwitcher.tsx
│   │   ├── server-component-example.content.ts
│   │   └── ServerComponentExample.tsx
│   └── middleware.ts
├── intlayer.config.ts
├── next.config.ts
├── package.json
└── tsconfig.json
      If you don't want locale routing, intlayer can be used as a simple provider / hook. See this guide for more details.

      アプリケーションの言語を設定するための設定ファイルを作成します：

      intlayer.config.ts
      import { Locales, type IntlayerConfig } from "intlayer";

const config: IntlayerConfig = {
  internationalization: {
    locales: [
      Locales.ENGLISH,
      Locales.FRENCH,
      Locales.SPANISH,
      // 他のロケール
    ],
    defaultLocale: Locales.ENGLISH,
  },
};

export default config;
      この設定ファイルを通じて、ローカライズされたURLの設定、ミドルウェアのリダイレクト、クッキー名、コンテンツ宣言の場所や拡張子の指定、コンソールでのIntlayerログの無効化などを行うことができます。利用可能なパラメータの完全なリストについては、設定ドキュメントを参照してください。

    3. Next.jsの設定にIntlayerを統合する

      Next.jsのセットアップをIntlayerを使うように設定します:

      next.config.ts
      import type { NextConfig } from "next";
import { withIntlayer } from "next-intlayer/server";

const nextConfig: NextConfig = {/* ここに設定オプションを記述 */};

export default withIntlayer(nextConfig);
      withIntlayer() Next.jsプラグインは、IntlayerをNext.jsと統合するために使用されます。これにより、コンテンツ宣言ファイルのビルドが保証され、開発モードでの監視が行われます。また、WebpackやTurbopack環境内でIntlayerの環境変数を定義します。さらに、パフォーマンス最適化のためのエイリアスを提供し、サーバーコンポーネントとの互換性を確保します。

      withIntlayer() 関数はプロミス関数です。ビルド開始前に intlayer 辞書を準備することができます。他のプラグインと一緒に使用したい場合は、これを await することができます。例：

      tsx
      const nextConfig = await withIntlayer(nextConfig);
const nextConfigWithOtherPlugins = withOtherPlugins(nextConfig);

export default nextConfigWithOtherPlugins;

      同期的に使用したい場合は、withIntlayerSync() 関数を使用できます。例：

      tsx
      const nextConfig = withIntlayerSync(nextConfig);
const nextConfigWithOtherPlugins = withOtherPlugins(nextConfig);

export default nextConfigWithOtherPlugins;

    4. 動的ロケールルートの定義

      RootLayoutの内容をすべて削除し、以下のコードに置き換えます。

      src/app/layout.tsx
      import type { PropsWithChildren, FC } from "react";
import "./globals.css";

const RootLayout: FC<PropsWithChildren> = ({ children }) => children;

export default RootLayout;
      RootLayout コンポーネントを空のままにしておくことで、<html> タグに lang および dir 属性を設定できます。

      動的ルーティングを実装するには、[locale] ディレクトリに新しいレイアウトを追加してロケールのパスを指定します：

      src/app/[locale]/layout.tsx
      import { type NextLayoutIntlayer } from "next-intlayer";
import { IntlayerProvider } from "next-intlayer/server";
import { Inter } from "next/font/google";
import { getHTMLTextDir } from "intlayer";

const inter = Inter({ subsets: ["latin"] });

const LocaleLayout: NextLayoutIntlayer = async ({ children, params }) => {
  const { locale } = await params;
  return (
    <html lang={locale} dir={getHTMLTextDir(locale)}>
      <body className={inter.className}>
        <IntlayerProvider locale={locale}>{children}</IntlayerProvider>
      </body>
    </html>
  );
};

export default LocaleLayout;

      単一の IntlayerProvider がツリーの両方の半分をカバーします。リクエストスコープのサーバーコンテキストにシードを供給し、サーバーフックによって読み取られ、クライアントプロバイダーをマウントして、クライアントコンポーネントが同じロケールを受け取るようにします。

      src/app/[locale]/layout.tsx
      import { type NextLayoutIntlayer, IntlayerClientProvider } from "next-intlayer";
import { Inter } from "next/font/google";
import { getHTMLTextDir } from "intlayer";

const inter = Inter({ subsets: ["latin"] });

// ロケールに基づいてHTMLのlang属性とdir属性を設定するレイアウトコンポーネント
const LocaleLayout: NextLayoutIntlayer = async ({ children, params }) => {
  const { locale } = await params;
  return (
    <html lang={locale} dir={getHTMLTextDir(locale)}>
      <body className={inter.className}>
        <IntlayerClientProvider locale={locale}>
          {children}
        </IntlayerClientProvider>
      </body>
    </html>
  );
};

export default LocaleLayout;
      [locale] パスセグメントはロケールを定義するために使用されます。例：/en-US/about は en-US を指し、/fr/about は fr を指します。
      この段階で、Error: Missing <html> and <body> tags in the root layout. というエラーが発生します。これは予期されたもので、/app/page.tsx ファイルはもはや使用されておらず、削除可能です。代わりに、[locale] パスセグメントが /app/[locale]/page.tsx ページを有効にします。その結果、ブラウザ上で /en、/fr、/es のようなパスでページにアクセスできるようになります。デフォルトのロケールをルートページとして設定するには、ステップ7の middleware 設定を参照してください。

      次に、アプリケーションのレイアウトで generateStaticParams 関数を実装します。

      src/app/[locale]/layout.tsx
      tsx {1} fileName="src/app/[locale]/layout.tsx" codeFormat="typescript"
export { generateStaticParams } from "next-intlayer"; // 挿入する行

const LocaleLayout: NextLayoutIntlayer = async ({ children, params }) => {
  /*... 残りのコード */
};

export default LocaleLayout;
      generateStaticParams は、すべてのロケールに必要なページを事前にビルドすることを保証し、実行時の計算を削減し、ユーザー体験を向上させます。詳細については、Next.js の generateStaticParams に関するドキュメントを参照してください。
      Intlayer は export const dynamic = 'force-static'; で動作し、すべてのロケールに対してページが事前にビルドされることを保証します。

    5. コンテンツの宣言

      翻訳を格納するためのコンテンツ宣言を作成および管理します:

      src/app/[locale]/page.content.ts
      import { t, type Dictionary } from "intlayer";

const pageContent = {
  key: "page",
  content: {
    getStarted: {
      main: t({
        en: "Get started by editing",
        fr: "Commencez par éditer",
        es: "Comience por editar",
      }),
      pageLink: "src/app/page.tsx",
    },
  },
} satisfies Dictionary;

export default pageContent;
      コンテンツ宣言は、contentDir ディレクトリ（デフォルトは ./src）に含まれている限り、アプリケーションのどこにでも定義できます。また、コンテンツ宣言ファイルの拡張子（デフォルトは .content.{json,ts,tsx,js,jsx,mjs,cjs,md,mdx,yaml,yml}）に一致する必要があります。
      詳細については、コンテンツ宣言のドキュメントを参照してください。

    6. コード内でコンテンツを利用する

      アプリケーション全体でコンテンツ辞書にアクセスします：

      src/app/[locale]/page.tsx
      import type { FC } from "react";
import { ClientComponentExample } from "@components/ClientComponentExample";
import { ServerComponentExample } from "@components/ServerComponentExample";
import { type NextPageIntlayer, useIntlayer } from "next-intlayer";

const PageContent: FC = () => {
  // ページコンテンツを取得
  const content = useIntlayer("page");

  return (
    <>
      <p>{content.getStarted.main}</p>
      <code>{content.getStarted.pageLink}</code>
    </>
  );
};

const Page: NextPageIntlayer = () => (
  <>
    <PageContent />
    <ServerComponentExample />

    <ClientComponentExample />
  </>
);

export default Page;
      • IntlayerProvider はロケールレイアウトに一度だけマウントされます。サーバーコンポーネントとクライアントコンポーネント両方にロケールを提供するため、ページ自体がラップされなくなります。
      • サーバーフックはこの順序でロケールを解決します：呼び出しサイトで渡されたロケール、その後プロバイダーによってシードされたサーバーコンテキスト、その後リクエストに含まれるロケール（Intlayerプロキシによって設定された x-intlayer-locale ヘッダー、次にロケールクッキー）。この最後のステップが、レイアウト — とそれに伴うプロバイダー — が再実行されない、ページセグメントのみを再レンダリングするクライアント側のナビゲーション時にコンテンツを正しく保つ理由です。

      アプリケーション全体でコンテンツ辞書にアクセスします：

      src/app/[locale]/page.tsx
      import type { FC } from "react";
import { ClientComponentExample } from "@components/ClientComponentExample";
import { ServerComponentExample } from "@components/ServerComponentExample";
import { type NextPageIntlayer } from "next-intlayer";
import { IntlayerServerProvider, useIntlayer } from "next-intlayer/server";

const PageContent: FC = () => {
  const content = useIntlayer("page");

  return (
    <>
      <p>{content.getStarted.main}</p> {/* コンテンツのメインテキストを表示 */}
      <code>{content.getStarted.pageLink}</code> {/* ページリンクを表示 */}
    </>
  );
};

const Page: NextPageIntlayer = async ({ params }) => {
  const { locale } = await params;

  return (
    <IntlayerServerProvider locale={locale}>
      <PageContent />
      <ServerComponentExample />

      <ClientComponentExample />
    </IntlayerServerProvider>
  );
};

export default Page;
      • IntlayerClientProvider はクライアントサイドのコンポーネントにロケールを提供するために使用されます。レイアウトを含む任意の親コンポーネントに配置できます。ただし、Next.jsはページ間でレイアウトコードを共有するため、レイアウトに配置することが推奨されます。レイアウトで IntlayerClientProvider を使用することで、各ページごとに再初期化する必要がなくなり、パフォーマンスが向上し、アプリケーション全体で一貫したローカリゼーションコンテキストを維持できます。
      • IntlayerServerProvider はサーバー側の子コンポーネントにロケールを提供するために使用されます。レイアウトには設定できません。
      レイアウトとページは共通のサーバーコンテキストを共有できません。なぜなら、サーバーコンテキストシステムはリクエストごとのデータストア（Reactのキャッシュ メカニズムを通じて）に基づいており、アプリケーションの異なるセグメントごとにそれぞれ「コンテキスト」が再作成されるためです。プロバイダーを共有レイアウトに配置すると、この分離が破られ、サーバーコンポーネントへのサーバーコンテキスト値の正しい伝播が妨げられます。
      src/components/ClientComponentExample.tsx
      "use client";

import type { FC } from "react";
import { useIntlayer } from "next-intlayer";

export const ClientComponentExample: FC = () => {
  const content = useIntlayer("client-component-example"); // 関連コンテンツ宣言を作成

  return (
    <div>
      <h2>{content.title}</h2>
      <p>{content.content}</p>
    </div>
  );
};
      src/components/ServerComponentExample.tsx
      import type { FC } from "react";
import { useIntlayer } from "next-intlayer";

export const ServerComponentExample: FC = () => {
  const content = useIntlayer("server-component-example"); // 関連するコンテンツ宣言を作成

  return (
    <div>
      <h2>{content.title}</h2>
      <p>{content.content}</p>
    </div>
  );
};
      next-intlayer は isomorphic import path です：react-server エクスポート条件により、サーバーコンポーネントは ambient-locale 実装を取得し、クライアントコンポーネントは context-backed 実装を取得します。同じ呼び出しが両側で機能します。
      src/components/ServerComponentExample.tsx
      import type { FC } from "react";
import { useIntlayer } from "next-intlayer/server";

export const ServerComponentExample: FC = () => {
  const content = useIntlayer("server-component-example"); // 関連コンテンツ宣言を作成

  return (
    <div>
      <h2>{content.title}</h2>
      <p>{content.content}</p>
    </div>
  );
};
      コンテンツを alt、title、href、aria-label などの string 属性で使用したい場合は、関数の値を使用できます。例：
      html
      <img src="{content.image.src.value}" alt="{content.image.value}" />
<img src="{content.image.src.toString()}" alt="{content.image.toString()}" />
<img src="{String(content.image.src)}" alt="{String(content.image)}" />
      useIntlayer フックの詳細については、ドキュメントを参照してください。

    7. ロケール検出のためのミドルウェア設定

      ユーザーの優先ロケールを検出するミドルウェアを設定します：

      src/middleware.ts
      export { intlayerMiddleware as middleware } from "next-intlayer/middleware";

export const config = {
  matcher:
    "/((?!api|static|assets|robots|sitemap|sw|service-worker|manifest|.*\\..*|_next).*)",
};
      intlayerMiddleware は、ユーザーの優先ロケールを検出し、設定で指定された適切なURLへリダイレクトするために使用されます。さらに、ユーザーの優先ロケールをクッキーに保存することも可能にします。
      Intlayer v9 以降、このミドルウェアは routing.enableProxy オプション（デフォルトで true）を尊重します。このファイルを削除せずにパススルーに変更するには、設定で routing.enableProxy: false を設定してください。v9 リリースノートを参照してください。
      複数のミドルウェアをチェーンする必要がある場合（例えば、認証またはカスタムミドルウェアを含む intlayerMiddleware）、Intlayer は multipleMiddlewares というヘルパーを提供しています。
      ts
      import {
  multipleMiddlewares,
  intlayerMiddleware,
} from "next-intlayer/middleware";
import { customMiddleware } from "@utils/customMiddleware";

export const middleware = multipleMiddlewares([
  intlayerMiddleware,
  customMiddleware,
]);

    8. メタデータの国際化

      ページのタイトルなどのメタデータを国際化したい場合は、Next.jsが提供するgenerateMetadata関数を使用できます。その中で、getIntlayer関数からコンテンツを取得してメタデータを翻訳できます。

      src/app/[locale]/metadata.content.ts
      import { type Dictionary, t } from "intlayer";
import { Metadata } from "next";

const metadataContent = {
  key: "page-metadata",
  content: {
    title: t({
      en: "Create Next App",
      fr: "Créer une application Next.js",
      es: "Crear una aplicación Next.js",
    }),
    description: t({
      en: "Generated by create next app",
      fr: "Généré par create next app",
      es: "Generado por create next app",
    }),
  },
} satisfies Dictionary<Metadata>;

export default metadataContent;
      src/app/[locale]/layout.tsx or src/app/[locale]/page.tsx
      import { getIntlayer, getMultilingualUrls } from "intlayer";
import type { Metadata } from "next";
import type { LocalPromiseParams } from "next-intlayer";

export const generateMetadata = async ({
  params,
}: LocalPromiseParams): Promise<Metadata> => {
  const { locale } = await params;

  const metadata = getIntlayer("page-metadata", locale);

  /**
   * 各ロケールのすべてのURLを含むオブジェクトを生成します。
   *
   * 例:
   * ```ts
   *  getMultilingualUrls('/about');
   *
   *  // 戻り値
   *  // {
   *  //   en: '/about',
   *  //   fr: '/fr/about',
   *  //   es: '/es/about',
   *  // }
   * ```
   */
  const multilingualUrls = getMultilingualUrls("/");
  const localizedUrl =
    multilingualUrls[locale as keyof typeof multilingualUrls];

  return {
    ...metadata,
    alternates: {
      canonical: localizedUrl,
      languages: { ...multilingualUrls, "x-default": "/" },
    },
    openGraph: {
      url: localizedUrl,
    },
  };
};

// ... 残りのコード
      next-intlayer からインポートされた getIntlayer 関数は、コンテンツを IntlayerNode でラップして返し、ビジュアルエディタとの統合を可能にします。一方、intlayer からインポートされた getIntlayer 関数は、追加のプロパティなしで直接コンテンツを返します。
      メタデータの最適化について詳しくは、公式の Next.js ドキュメントをご覧ください。

    9. sitemap.xml と robots.txt の国際化

      sitemap.xml と robots.txt を国際化するには、Intlayer が提供する getMultilingualUrls 関数を使用できます。この関数を使うことで、サイトマップ用の多言語 URL を生成できます。

      src/app/sitemap.ts
      import { getMultilingualUrls } from "intlayer";
import type { MetadataRoute } from "next";

const sitemap = (): MetadataRoute.Sitemap => [
  {
    url: "https://example.com",
    alternates: {
      languages: {
        ...getMultilingualUrls("https://example.com"),
        "x-default": "https://example.com",
      },
    },
  },
  {
    url: "https://example.com/login",
    alternates: {
      languages: {
        ...getMultilingualUrls("https://example.com/login"),
        "x-default": "https://example.com/login",
      },
    },
  },
  {
    url: "https://example.com/register",
    alternates: {
      languages: {
        ...getMultilingualUrls("https://example.com/register"),
        "x-default": "https://example.com/register",
      },
    },
  },
];

export default sitemap;
      src/app/robots.ts
      import type { MetadataRoute } from "next";
import { getMultilingualUrls } from "intlayer";

// すべての多言語URLを取得する関数
const getAllMultilingualUrls = (urls: string[]) =>
  urls.flatMap((url) => Object.values(getMultilingualUrls(url)) as string[]);

// robots.txtのメタデータを定義
const robots = (): MetadataRoute.Robots => ({
  rules: {
    userAgent: "*", // すべてのユーザーエージェントに適用
    allow: ["/"], // ルートパスは許可
    disallow: getAllMultilingualUrls(["/login", "/register"]), // ログインと登録ページの多言語URLはアクセス禁止
  },
  host: "https://example.com",
  sitemap: `https://example.com/sitemap.xml`,
});

export default robots;
      サイトマップの最適化については、公式の Next.js ドキュメントをご覧ください。robots.txt の最適化については、公式の Next.js ドキュメントをご覧ください。

    10. コンテンツの言語を変更する

      Next.js でコンテンツの言語を変更するには、推奨される方法として Link コンポーネントを使用して、ユーザーを適切なローカライズされたページにリダイレクトする方法があります。Link コンポーネントはページのプリフェッチを可能にし、完全なページリロードを回避するのに役立ちます。

      src/components/LocaleSwitcher.tsx
      "use client";

import type { FC } from "react";
import {
  Locales,
  getHTMLTextDir,
  getLocaleName,
  getLocalizedUrl,
} from "intlayer";
import { useLocale } from "next-intlayer";
import Link from "next/link";

export const LocaleSwitcher: FC = () => {
  const { locale, pathWithoutLocale, availableLocales, setLocale } =
    useLocale();

  return (
    <div>
      <button popoverTarget="localePopover">{getLocaleName(locale)}</button>
      <div id="localePopover" popover="auto">
        {availableLocales.map((localeItem) => (
          <Link
            href={getLocalizedUrl(pathWithoutLocale, localeItem)}
            hrefLang={localeItem}
            key={localeItem}
            aria-current={locale === localeItem ? "page" : undefined}
            onClick={() => setLocale(localeItem)}
          >
            <span>
              {/* ロケール - 例: FR */}
              {localeItem}
            </span>
            <span>
              {/* 自身のロケールでの言語名 - 例: Français */}
              {getLocaleName(localeItem, locale)}
            </span>
            <span dir={getHTMLTextDir(localeItem)} lang={localeItem}>
              {/* 現在のロケールでの言語名 - 例: Locales.SPANISHに設定された現在のロケールでのFrancés */}
              {getLocaleName(localeItem)}
            </span>
            <span dir="ltr" lang={Locales.ENGLISH}>
              {/* 英語での言語名 - 例: French */}
              {getLocaleName(localeItem, Locales.ENGLISH)}
            </span>
          </Link>
        ))}
      </div>
    </div>
  );
};
      もう一つの方法は、useLocale フックで提供される setLocale 関数を使うことです。この関数はページのプリフェッチを許可せず、ページをリロードします。
      この場合、router.push を使ったリダイレクトなしで、サーバーサイドのコードだけがコンテンツのロケールを変更します。
      src/components/LocaleSwitcher.tsx
      "use client";

import { useRouter } from "next/navigation";
import { useLocale } from "next-intlayer";
import { getLocalizedUrl } from "intlayer";

// ... 残りのコード

const router = useRouter();
const { setLocale } = useLocale({
  onLocaleChange: (locale) => {
    router.push(getLocalizedUrl(pathWithoutLocale, locale));
  },
});

return (
  <button onClick={() => setLocale(Locales.FRENCH)}>フランス語に変更</button>
);

      ドキュメント参照:

    11. ローカライズされたリンクコンポーネントの作成

      アプリケーションのナビゲーションが現在のロケールを尊重するようにするために、カスタムの Link コンポーネントを作成できます。このコンポーネントは内部のURLに自動的に現在の言語をプレフィックスとして付加します。例えば、フランス語を話すユーザーが「About」ページへのリンクをクリックすると、/about ではなく /fr/about にリダイレクトされます。

      この動作は以下の理由で有用です：

      • SEOとユーザーエクスペリエンス：ローカライズされたURLは、検索エンジンが言語別のページを正しくインデックスし、ユーザーに好みの言語でコンテンツを提供するのに役立ちます。
      • 一貫性：アプリケーション全体でローカライズされたリンクを使用することで、ナビゲーションが現在のロケール内に留まり、予期しない言語の切り替えを防ぎます。
      • 保守性: ローカリゼーションのロジックを単一のコンポーネントに集約することで、URLの管理が簡素化され、アプリケーションの成長に伴いコードベースの保守や拡張が容易になります。

      以下は、TypeScriptで実装したローカライズされたLinkコンポーネントの例です。

      src/components/Link.tsx
      "use client";

import { getLocalizedUrl } from "intlayer";
import NextLink, { type LinkProps as NextLinkProps } from "next/link";
import { useLocale } from "next-intlayer";
import type { PropsWithChildren, FC } from "react";

/**
 * 指定されたURLが外部リンクかどうかを判定するユーティリティ関数。
 * URLが http:// または https:// で始まる場合、外部リンクとみなします。
 */
export const checkIsExternalLink = (href?: string): boolean =>
  /^https?:\/\//.test(href ?? "");

/**
 * 現在のロケールに基づいて href 属性を適応させるカスタム Link コンポーネントです。
 * 内部リンクの場合、`getLocalizedUrl` を使用して URL の先頭にロケールを付加します（例：/fr/about）。
 * これにより、ナビゲーションが同じロケールのコンテキスト内に留まることを保証します。
 */
export const Link: FC<PropsWithChildren<NextLinkProps>> = ({
  href,
  children,
  ...props
}) => {
  const { locale } = useLocale();
  const isExternalLink = checkIsExternalLink(href.toString());

  // リンクが内部リンクで有効な href が提供されている場合、ローカライズされた URL を取得します。
  const hrefI18n: NextLinkProps["href"] =
    href && !isExternalLink ? getLocalizedUrl(href.toString(), locale) : href;

  return (
    <NextLink href={hrefI18n} {...props}>
      {children}
    </NextLink>
  );
};

      動作の仕組み

      • 外部リンクの検出:

      • 外部リンクの検出:
        ヘルパー関数 checkIsExternalLink は、URLが外部リンクかどうかを判定します。外部リンクはローカライズの必要がないため、そのまま変更されません。

      • 現在のロケールの取得:
        useLocale フックは現在のロケール（例：フランス語の場合は fr）を提供します。

      • URLのローカライズ:
        内部リンク（すなわち外部リンクでない場合）には、getLocalizedUrl を使ってURLの先頭に現在のロケールを自動的に付加します。つまり、ユーザーがフランス語環境にいる場合、href に /about を渡すと /fr/about に変換されます。

      • リンクの返却:
        コンポーネントはローカライズされたURLを持つ <a> 要素を返し、ナビゲーションがロケールに沿って一貫するようにします。

      この Link コンポーネントをアプリケーション全体に統合することで、一貫性があり言語に対応したユーザー体験を維持しつつ、SEOや使いやすさの向上も実現できます。

    12. バンドルサイズの最適化

      next-intlayer を使用すると、辞書がデフォルトで全ページのバンドルに含まれます。バンドルサイズを最適化するために、Intlayer はマクロを使用して useIntlayer の呼び出しを賢く置き換えるオプションの SWC プラグインを提供しています。これにより、辞書は実際に使用されているページのバンドルにのみ含まれるようになります。

      src/app/actions/getLocale.ts
      "use server";

import { getLocale } from "next-intlayer/server";

export const myServerAction = async () => {
  const locale = await getLocale();

  // localeで何かを実行する
};

      getLocale 関数は、ユーザーのロケールを決定するためにカスケード戦略に従います:

      1. まず、リクエストヘッダーをチェックして、ミドルウェアによって設定されたロケール値を探します
      2. ヘッダーにロケールが見つからない場合、クッキーに保存されたロケールを探します
      3. クッキーが見つからない場合、ブラウザ設定からユーザーの優先言語を検出しようとします
      4. 最後の手段として、アプリケーションの設定されたデフォルトロケールにフォールバックします

      これにより、利用可能なコンテキストに基づいて最も適切なロケールが選択されることを保証します。

    13. バンドルサイズを最適化する

      オプション

      next-intlayerを使用する場合、デフォルトではすべてのページに対して辞書がバンドルに含まれます。バンドルサイズを最適化するために、Intlayerは、マクロを使用してuseIntlayer呼び出しをインテリジェントに置き換えるオプションのSWCプラグインを提供します。これにより、辞書は実際に使用するページのバンドルにのみ含まれるようになります。

      この最適化を有効にするには、@intlayer/swc パッケージをインストールしてください。インストール後、next-intlayer は自動的にプラグインを検出して使用します。

      bash
      npm install @intlayer/swc --save-dev
      注意: この最適化は Next.js 13 以降でのみ利用可能です。

      注意: SWC プラグインは Next.js ではまだ実験的な機能のため、このパッケージはデフォルトでインストールされていません。将来的に変更される可能性があります。

      14. 注意: importMode: 'dynamic' または importMode: 'fetch' オプションを設定した場合（dictionary 設定内）、Suspense に依存するため、useIntlayer 呼び出しを Suspense boundary でラップする必要があります。つまり、useIntlayer を Page / Layout コンポーネントのトップレベルで直接使用することはできません。 </Step>

    Turbopack での辞書の変更の監視

    next dev --turbopack コマンドを使用して開発サーバーとして Turbopack を使用する場合、デフォルトでは辞書の変更が自动的に検出されません。

    この制限は、Turbopack がコンテンツファイルの変更を監視するために webpack プラグインを並行して実行できないために発生します。これを回避するには、intlayer watch コマンドを使用して、開発サーバーと Intlayer ビルドウォッチャーを同時に実行する必要があります。

    package.json
    {
  // ... 既存の package.json 設定
  "scripts": {
    // ... 既存のスクリプト設定
    "dev": "intlayer watch --with 'next dev --turbopack'",
  },
}

    TypeScript の設定

    Intlayer はモジュール拡張を使用して TypeScript の利点を活かし、コードベースをより強固にします。

    Autocompletion

    Translation error

    TypeScript の設定に自動生成された型を含めていることを確認してください。

    tsconfig.json
    {
  // ... 既存の TypeScript 設定
  "include": [
    // ... 既存の TypeScript 設定
    ".intlayer/**/*.ts", // 自動生成された型を含める
  ],
}

    Git 設定

    Intlayer によって生成されたファイルは無視することを推奨します。これにより、Git リポジトリへのコミットを避けることができます。

    これを行うには、.gitignore ファイルに以下の指示を追加してください。

    .gitignore
    # Intlayer によって生成されたファイルを無視する
.intlayer

    VS Code 拡張機能

    Intlayer での開発体験を向上させるために、公式の Intlayer VS Code 拡張機能 をインストールできます。

    VS Code Marketplace からインストール

    この拡張機能は以下を提供します：

    • 翻訳キーの オートコンプリート
    • 翻訳が不足している場合のリアルタイムエラー検出。
    • 翻訳されたコンテンツのインラインプレビュー。
    • 翻訳を簡単に作成・更新するためのクイックアクション。

    拡張機能の使い方の詳細については、Intlayer VS Code 拡張機能のドキュメントを参照してください。

    さらに進むには

    さらに進むには、ビジュアルエディターを実装するか、CMSを使用してコンテンツを外部化することができます。

    Next.js 14とApp RouterNext.js ロケールなし URL