Commencer avec l'internationalisation (i18n) avec Intlayer et Next.js 15 App Router

    Qu'est-ce qu'Intlayer ?

    Intlayer est une bibliothèque open-source innovante d'internationalisation (i18n) conçue pour simplifier la prise en charge multilingue dans les applications web modernes. Intlayer s'intègre parfaitement avec le dernier framework Next.js 15, y compris son puissant App Router. Elle est optimisée pour fonctionner avec les Server Components pour un rendu efficace et est entièrement compatible avec Turbopack.

    Avec Intlayer, vous pouvez :

    • Gérer facilement les traductions en utilisant des dictionnaires déclaratifs au niveau des composants.
    • Localiser dynamiquement les métadonnées, les routes et le contenu.
    • Accéder aux traductions dans les composants côté client et côté serveur.
    • Assurer la prise en charge de TypeScript avec des types générés automatiquement, améliorant l'autocomplétion et la détection des erreurs.
    • Bénéficier de fonctionnalités avancées, comme la détection et le changement dynamiques de locale.

    Intlayer est compatible avec Next.js 12, 13, 14 et 15. Si vous utilisez le Page Router de Next.js, vous pouvez consulter ce guide. Pour Next.js 12, 13, 14 avec App Router, consultez ce guide.

    Guide étape par étape pour configurer Intlayer dans une application Next.js

    Étape 1 : Installer les dépendances

    Installez les packages nécessaires en utilisant npm :

    bash
    npm install intlayer next-intlayer

    • intlayer

      Le package principal qui fournit des outils d'internationalisation pour la gestion des configurations, la traduction, la déclaration de contenu, la transpilation et les commandes CLI.

    • next-intlayer

      Le package qui intègre Intlayer avec Next.js. Il fournit des fournisseurs de contexte et des hooks pour l'internationalisation avec Next.js. De plus, il inclut le plugin Next.js pour intégrer Intlayer avec Webpack ou Turbopack, ainsi qu'un middleware pour détecter la locale préférée de l'utilisateur, gérer les cookies et gérer la redirection des URL.

    Étape 2 : Configurer votre projet

    Créez un fichier de configuration pour configurer les langues de votre application :

    intlayer.config.ts
    import { Locales, type IntlayerConfig } from "intlayer";const config: IntlayerConfig = {  internationalization: {    locales: [      Locales.ENGLISH,      Locales.FRENCH,      Locales.SPANISH,      // Vos autres locales    ],    defaultLocale: Locales.ENGLISH,  },};export default config;

    Grâce à ce fichier de configuration, vous pouvez configurer des URL localisées, des redirections middleware, des noms de cookies, l'emplacement et l'extension de vos déclarations de contenu, désactiver les journaux Intlayer dans la console, et bien plus encore. Pour une liste complète des paramètres disponibles, consultez la documentation de configuration.

    Étape 3 : Intégrer Intlayer dans votre configuration Next.js

    Configurez votre projet Next.js pour utiliser Intlayer :

    typescript
    import type { NextConfig } from "next";import { withIntlayer } from "next-intlayer/server";const nextConfig: NextConfig = {  /* options de configuration ici */};export default withIntlayer(nextConfig);

    Le plugin Next.js withIntlayer() est utilisé pour intégrer Intlayer avec Next.js. Il garantit la construction des fichiers de déclaration de contenu et les surveille en mode développement. Il définit les variables d'environnement Intlayer dans les environnements Webpack ou Turbopack. De plus, il fournit des alias pour optimiser les performances et garantir la compatibilité avec les composants serveur.

    Étape 4 : Définir des routes dynamiques pour les locales

    Supprimez tout le contenu de RootLayout et remplacez-le par le code suivant :

    src/app/layout.tsx
    import type { PropsWithChildren, FC } from "react";import "./globals.css";const RootLayout: FC<PropsWithChildren> = ({ children }) => children;export default RootLayout;

    Garder le composant RootLayout vide permet de définir les attributs lang et dir sur la balise <html>.

    Pour implémenter le routage dynamique, fournissez le chemin pour la locale en ajoutant une nouvelle disposition dans votre répertoire [locale] :

    src/app/[locale]/layout.tsx
    import type { NextLayoutIntlayer } from "next-intlayer";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}>{children}</body>    </html>  );};export default LocaleLayout;

    Le segment de chemin [locale] est utilisé pour définir la locale. Exemple : /en-US/about fera référence à en-US et /fr/about à fr.

    Ensuite, implémentez la fonction generateStaticParams dans votre disposition d'application.

    src/app/[locale]/layout.tsx
    export { generateStaticParams } from "next-intlayer"; // Ligne à insérerconst LocaleLayout: NextLayoutIntlayer = async ({ children, params }) => {  /*... Reste du code*/};export default LocaleLayout;

    generateStaticParams garantit que votre application pré-construit les pages nécessaires pour toutes les locales, réduisant ainsi les calculs au moment de l'exécution et améliorant l'expérience utilisateur. Pour plus de détails, consultez la documentation Next.js sur generateStaticParams.

    Étape 5 : Déclarer votre contenu

    Créez et gérez vos déclarations de contenu pour stocker les traductions :

    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;

    Vos déclarations de contenu peuvent être définies n'importe où dans votre application tant qu'elles sont incluses dans le répertoire contentDir (par défaut, ./src). Et correspondent à l'extension de fichier de déclaration de contenu (par défaut, .content.{ts,tsx,js,jsx,mjs,cjs}). Pour plus de détails, consultez la documentation sur les déclarations de contenu.

    Étape 6 : Utiliser le contenu dans votre code

    Accédez à vos dictionnaires de contenu dans toute votre application :

    src/app/[locale]/page.tsx
    import type { FC } from "react";import { ClientComponentExample } from "@components/ClientComponentExample";import { ServerComponentExample } from "@components/ServerComponentExample";import { type NextPageIntlayer, IntlayerClientProvider } from "next-intlayer";import { IntlayerServerProvider, useIntlayer } from "next-intlayer/server";const PageContent: FC = () => {  const { title, 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 />      <IntlayerClientProvider locale={locale}>        <ClientComponentExample />      </IntlayerClientProvider>    </IntlayerServerProvider>  );};export default Page;
    • IntlayerClientProvider est utilisé pour fournir la locale aux composants côté client. Il peut être placé dans n'importe quel composant parent, y compris la disposition. Cependant, il est recommandé de le placer dans une disposition car Next.js partage le code de disposition entre les pages, ce qui le rend plus efficace. En utilisant IntlayerClientProvider dans la disposition, vous évitez de le réinitialiser pour chaque page, améliorant ainsi les performances et maintenant un contexte de localisation cohérent dans toute votre application.

    • IntlayerServerProvider est utilisé pour fournir la locale aux enfants côté serveur. Il ne peut pas être défini dans la disposition.

      La disposition et la page ne peuvent pas partager un contexte serveur commun car le système de contexte serveur est basé sur un magasin de données par requête (via le mécanisme React’s cache), ce qui entraîne la recréation de chaque "contexte" pour différents segments de l'application. Placer le fournisseur dans une disposition partagée briserait cette isolation, empêchant la propagation correcte des valeurs de contexte serveur à vos composants serveur.

    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"); // Créez une déclaration de contenu associée  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/server";export const ServerComponentExample: FC = () => {  const content = useIntlayer("server-component-example"); // Créez une déclaration de contenu associée  return (    <div>      <h2>{content.title} </h2>      <p>{content.content}</p>    </div>  );};

    Si vous souhaitez utiliser votre contenu dans un attribut string, tel que alt, title, href, aria-label, etc., vous devez appeler la valeur de la fonction, comme :

    jsx
    <img src={content.image.src.value} alt={content.image.value} />

    Pour en savoir plus sur le hook useIntlayer, consultez la documentation.

    (Optionnel) Étape 7 : Configurer le middleware pour la détection de la locale

    Configurez le middleware pour détecter la locale préférée de l'utilisateur :

    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).*)",};

    Le intlayerMiddleware est utilisé pour détecter la locale préférée de l'utilisateur et le rediriger vers l'URL appropriée comme spécifié dans la configuration. De plus, il permet d'enregistrer la locale préférée de l'utilisateur dans un cookie.

    (Optionnel) Étape 8 : Internationalisation de vos métadonnées

    Dans le cas où vous souhaitez internationaliser vos métadonnées, comme le titre de votre page, vous pouvez utiliser la fonction generateMetadata fournie par Next.js. À l'intérieur de la fonction, utilisez la fonction getTranslation pour traduire vos métadonnées.

    src/app/[locale]/layout.tsx or src/app/[locale]/page.tsx
    import {  type IConfigLocales,  getTranslation,  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 t = <T>(content: IConfigLocales<T>) => getTranslation(content, locale);  /**   * Génère un objet contenant toutes les URL pour chaque locale.   *   * Exemple :   * ```ts   *  getMultilingualUrls('/about');   *   *  // Retourne   *  // {   *  //   en: '/about',   *  //   fr: '/fr/about',   *  //   es: '/es/about',   *  // }   * ```   */  const multilingualUrls = getMultilingualUrls("/");  return {    title: t<string>({      en: "My title",      fr: "Mon titre",      es: "Mi título",    }),    description: t({      en: "My description",      fr: "Ma description",      es: "Mi descripción",    }),    alternates: {      canonical: "/",      languages: { ...multilingualUrls, "x-default": "/" },    },    openGraph: {      url: multilingualUrls[locale],    },  };};// ... Reste du code

    Pour en savoir plus sur l'optimisation des métadonnées sur la documentation officielle de Next.js.

    (Optionnel) Étape 9 : Internationalisation de votre sitemap.xml et robots.txt

    Pour internationaliser votre sitemap.xml et robots.txt, vous pouvez utiliser la fonction getMultilingualUrls fournie par Intlayer. Cette fonction vous permet de générer des URL multilingues pour votre sitemap.

    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") },    },  },  {    url: "https://example.com/login",    alternates: {      languages: { ...getMultilingualUrls("https://example.com/login") },    },  },  {    url: "https://example.com/register",    alternates: {      languages: { ...getMultilingualUrls("https://example.com/register") },    },  },];export default sitemap;
    src/app/robots.ts
    import type { MetadataRoute } from "next";import { getMultilingualUrls } from "intlayer";const getAllMultilingualUrls = (urls: string[]) =>  urls.flatMap((url) => Object.values(getMultilingualUrls(url)) as string[]);const robots = (): MetadataRoute.Robots => ({  rules: {    userAgent: "*",    allow: ["/"],    disallow: getAllMultilingualUrls(["/login", "/register"]),  },  host: "https://example.com",  sitemap: `https://example.com/sitemap.xml`,});export default robots;

    Pour en savoir plus sur l'optimisation du sitemap sur la documentation officielle de Next.js. Pour en savoir plus sur l'optimisation du robots.txt sur la documentation officielle de Next.js.

    (Optionnel) Étape 10 : Changer la langue de votre contenu

    Pour changer la langue de votre contenu, vous pouvez utiliser la fonction setLocale fournie par le hook useLocale. Cette fonction vous permet de définir la locale de l'application et de mettre à jour le contenu en conséquence.

    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={(e) => {              e.preventDefault();              setLocale(localeItem);            }}          >            <span>              {/* Locale - e.g. FR */}              {localeItem}            </span>            <span>              {/* Langue dans sa propre Locale - e.g. Français */}              {getLocaleName(localeItem, locale)}            </span>            <span dir={getHTMLTextDir(localeItem)} lang={localeItem}>              {/* Langue dans la Locale actuelle - e.g. Francés avec la locale actuelle définie sur Locales.SPANISH */}              {getLocaleName(localeItem)}            </span>            <span dir="ltr" lang={Locales.ENGLISH}>              {/* Langue en anglais - e.g. French */}              {getLocaleName(localeItem, Locales.ENGLISH)}            </span>          </Link>        ))}      </div>    </div>  );};

    Références de documentation :

    (Optionnel) Étape 11 : Création d'un composant de lien localisé

    Pour garantir que la navigation de votre application respecte la locale actuelle, vous pouvez créer un composant Link personnalisé. Ce composant préfixe automatiquement les URL internes avec la langue actuelle, de sorte que, par exemple, lorsqu'un utilisateur francophone clique sur un lien vers la page "À propos", il est redirigé vers /fr/about au lieu de /about.

    Ce comportement est utile pour plusieurs raisons :

    • SEO et expérience utilisateur : Les URL localisées aident les moteurs de recherche à indexer correctement les pages spécifiques à une langue et fournissent aux utilisateurs un contenu dans leur langue préférée.
    • Cohérence : En utilisant un lien localisé dans toute votre application, vous garantissez que la navigation reste dans la locale actuelle, évitant ainsi des changements de langue inattendus.
    • Maintenabilité : Centraliser la logique de localisation dans un seul composant simplifie la gestion des URL, rendant votre base de code plus facile à maintenir et à étendre à mesure que votre application se développe.

    Voici l'implémentation d'un composant Link localisé en TypeScript :

    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";/** * Fonction utilitaire pour vérifier si une URL donnée est externe. * Si l'URL commence par http:// ou https://, elle est considérée comme externe. */export const checkIsExternalLink = (href?: string): boolean =>  /^https?:///.test(href ?? "");/** * Un composant Link personnalisé qui adapte l'attribut href en fonction de la locale actuelle. * Pour les liens internes, il utilise `getLocalizedUrl` pour préfixer l'URL avec la locale (par exemple, /fr/about). * Cela garantit que la navigation reste dans le même contexte de locale. */export const Link: FC<PropsWithChildren<NextLinkProps>> = ({  href,  children,  ...props}) => {  const { locale } = useLocale();  const isExternalLink = checkIsExternalLink(href.toString());  // Si le lien est interne et qu'un href valide est fourni, obtenez l'URL localisée.  const hrefI18n: NextLinkProps["href"] =    href && !isExternalLink ? getLocalizedUrl(href.toString(), locale) : href;  return (    <NextLink href={hrefI18n} {...props}>      {children}    </NextLink>  );};

    Comment cela fonctionne

    • Détection des liens externes :
      La fonction utilitaire checkIsExternalLink détermine si une URL est externe. Les liens externes restent inchangés car ils n'ont pas besoin de localisation.

    • Récupération de la locale actuelle :
      Le hook useLocale fournit la locale actuelle (par exemple, fr pour le français).

    • Localisation de l'URL :
      Pour les liens internes (c'est-à-dire non externes), getLocalizedUrl est utilisé pour préfixer automatiquement l'URL avec la locale actuelle. Cela signifie que si votre utilisateur est en français, passer /about comme href le transformera en /fr/about.

    • Retour du lien :
      Le composant retourne un élément <a> avec l'URL localisée, garantissant que la navigation est cohérente avec la locale.

    En intégrant ce composant Link dans toute votre application, vous maintenez une expérience utilisateur cohérente et respectueuse de la langue tout en bénéficiant d'un SEO et d'une convivialité améliorés.

    Configurer TypeScript

    Intlayer utilise l'augmentation de module pour bénéficier de TypeScript et renforcer votre base de code.

    alt text

    alt text

    Assurez-vous que votre configuration TypeScript inclut les types générés automatiquement.

    tsconfig.json
    {  // ... Vos configurations TypeScript existantes  "include": [    // ... Vos configurations TypeScript existantes    ".intlayer/**/*.ts", // Inclure les types générés automatiquement  ],}

    Configuration Git

    Il est recommandé d'ignorer les fichiers générés par Intlayer. Cela vous permet d'éviter de les ajouter à votre dépôt Git.

    Pour ce faire, vous pouvez ajouter les instructions suivantes à votre fichier .gitignore :

    .gitignore
    # Ignorer les fichiers générés par Intlayer.intlayer

    Aller plus loin

    Pour aller plus loin, vous pouvez implémenter l'éditeur visuel ou externaliser votre contenu en utilisant le CMS.

    Si vous avez une idée d’amélioration pour améliorer cette documentation, n’hésitez pas à contribuer en submitant une pull request sur GitHub.

    Lien GitHub de la documentation
    Fonction FetchingNext.js 14 et App Router