next-intlayer 1.0.0

package/dist/esm/middleware/localeDetector.mjs

@@ -0,0 +1,20 @@
+import { match } from "@formatjs/intl-localematcher";
+import { getConfiguration } from "@intlayer/config/client";
+import Negotiator from "negotiator";
+const { locales, defaultLocale } = getConfiguration().internationalization;
+const localeDetector = (request) => {
+  const negotiatorHeaders = {};
+  request.headers.forEach((value, key) => (negotiatorHeaders[key] = value));
+  const languages = new Negotiator({ headers: negotiatorHeaders }).languages();
+  try {
+    return match(languages, locales, defaultLocale);
+  } catch (e) {
+    console.warn(
+      `No valid locales in accept-language header: ${languages.join(", ")}`
+    );
+    console.warn(`Reverting to using defaultLocale: ${defaultLocale}`);
+    return defaultLocale;
+  }
+};
+export { localeDetector };
+//# sourceMappingURL=localeDetector.mjs.map

package/dist/esm/middleware/localeDetector.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/middleware/localeDetector.ts"],"sourcesContent":["import { match } from '@formatjs/intl-localematcher';\nimport type { Locales } from '@intlayer/config';\nimport { getConfiguration } from '@intlayer/config/client';\nimport Negotiator from 'negotiator';\nimport type { NextRequest } from 'next/server.js';\n\nconst { locales, defaultLocale } = getConfiguration().internationalization;\n\nexport const localeDetector = (request: NextRequest): Locales => {\n  const negotiatorHeaders: Record<string, string> = {};\n\n  request.headers.forEach((value, key) => (negotiatorHeaders[key] = value));\n\n  const languages = new Negotiator({ headers: negotiatorHeaders }).languages();\n\n  // match can only use specifically formatted locales\n  // https://stackoverflow.com/questions/76447732/nextjs-13-i18n-incorrect-locale-information-provided\n  try {\n    return match(languages, locales, defaultLocale) as Locales;\n  } catch (e) {\n    console.warn(\n      `No valid locales in accept-language header: ${languages.join(', ')}`\n    );\n    console.warn(`Reverting to using defaultLocale: ${defaultLocale}`);\n\n    return defaultLocale;\n  }\n};\n"],"mappings":"AAAA,SAAS,aAAa;AAEtB,SAAS,wBAAwB;AACjC,OAAO,gBAAgB;AAGvB,MAAM,EAAE,SAAS,cAAc,IAAI,iBAAiB,EAAE;AAE/C,MAAM,iBAAiB,CAAC,YAAkC;AAC/D,QAAM,oBAA4C,CAAC;AAEnD,UAAQ,QAAQ,QAAQ,CAAC,OAAO,QAAS,kBAAkB,GAAG,IAAI,KAAM;AAExE,QAAM,YAAY,IAAI,WAAW,EAAE,SAAS,kBAAkB,CAAC,EAAE,UAAU;AAI3E,MAAI;AACF,WAAO,MAAM,WAAW,SAAS,aAAa;AAAA,EAChD,SAAS,GAAG;AACV,YAAQ;AAAA,MACN,+CAA+C,UAAU,KAAK,IAAI,CAAC;AAAA,IACrE;AACA,YAAQ,KAAK,qCAAqC,aAAa,EAAE;AAEjE,WAAO;AAAA,EACT;AACF;","names":[]}

package/dist/esm/server/index.d.mts

@@ -0,0 +1,10 @@
+export {
+  LocaleServerContext,
+  LocaleServerContextProvider,
+  getLocaleContent,
+  locale,
+  useIntlayer,
+  useTraduction,
+} from "react-intlayer/server";
+export { withIntlayer } from "./withIntlayer.mjs";
+import "next";

package/dist/esm/server/index.mjs

@@ -0,0 +1,19 @@
+import {
+  getLocaleContent,
+  useTraduction,
+  LocaleServerContext,
+  LocaleServerContextProvider,
+  locale,
+  useIntlayer,
+} from "react-intlayer/server";
+import { withIntlayer } from "./withIntlayer.mjs";
+export {
+  LocaleServerContext,
+  LocaleServerContextProvider,
+  getLocaleContent,
+  locale,
+  useIntlayer,
+  useTraduction,
+  withIntlayer,
+};
+//# sourceMappingURL=index.mjs.map

package/dist/esm/server/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/server/index.ts"],"sourcesContent":["export {\n  getLocaleContent,\n  useTraduction,\n  LocaleServerContext,\n  LocaleServerContextProvider,\n  locale,\n  useIntlayer,\n} from 'react-intlayer/server';\nexport { withIntlayer } from './withIntlayer';\n"],"mappings":"AAAA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,oBAAoB;","names":[]}

package/dist/esm/server/withIntlayer.d.mts

@@ -0,0 +1,9 @@
+import "react-intlayer/server";
+import { NextConfig } from "next";
+
+type PluginOptions = {};
+declare const withIntlayer: (
+  _pluginOptions?: PluginOptions
+) => (nextConfig?: Partial<NextConfig>) => Partial<NextConfig>;
+
+export { withIntlayer };

package/dist/esm/server/withIntlayer.mjs

@@ -0,0 +1,40 @@
+import { resolve, relative, join } from "path";
+import { getConfiguration, formatEnvVariable } from "@intlayer/config";
+const intlayerConfig = getConfiguration({
+  verbose: true,
+});
+const env = formatEnvVariable("NEXT_PUBLIC_INTLAYER_");
+const { mainDir, baseDir } = intlayerConfig.content;
+const mergeEnvVariable = (nextEnv = {}) => Object.assign({}, nextEnv, env);
+const mergeStats = (nextStats = {}) =>
+  Object.assign({}, nextStats, {
+    warnings: false,
+  });
+const withIntlayer =
+  (_pluginOptions = {}) =>
+  (nextConfig = {}) => {
+    if (typeof nextConfig !== "object") nextConfig = {};
+    return Object.assign({}, nextConfig, {
+      env: mergeEnvVariable(nextConfig.env),
+      stats: mergeStats(nextConfig.stats),
+      webpack: (config) => {
+        const dictionariesPath = join(mainDir, "dictionaries.cjs");
+        const relativeDictionariesPath = relative(baseDir, dictionariesPath);
+        config.externals.push({
+          esbuild: "esbuild",
+          module: "module",
+          fs: "fs",
+        });
+        config.resolve.alias["@intlayer/dictionaries-entry"] = resolve(
+          relativeDictionariesPath
+        );
+        config.module.rules.push({
+          test: /\.node$/,
+          loader: "node-loader",
+        });
+        return config;
+      },
+    });
+  };
+export { withIntlayer };
+//# sourceMappingURL=withIntlayer.mjs.map

package/dist/esm/server/withIntlayer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/server/withIntlayer.ts"],"sourcesContent":["import { resolve, relative, join } from 'path';\nimport { getConfiguration, formatEnvVariable } from '@intlayer/config';\nimport type { NextConfig } from 'next';\nimport type { NextJsWebpackConfig } from 'next/dist/server/config-shared';\n\ntype PluginOptions = {\n  // TODO: add options\n};\n\nconst intlayerConfig = getConfiguration({\n  verbose: true,\n});\n\n// Set all configuration values as environment variables\nconst env = formatEnvVariable('NEXT_PUBLIC_INTLAYER_');\nconst { mainDir, baseDir } = intlayerConfig.content;\n\nconst mergeEnvVariable = (\n  nextEnv: Record<string, unknown> | undefined = {}\n): Record<string, string> => Object.assign({}, nextEnv, env);\n\nconst mergeStats = (\n  nextStats: Record<string, unknown> | undefined = {}\n): Record<string, unknown> =>\n  Object.assign({}, nextStats, {\n    warnings: false,\n  });\n\nexport const withIntlayer =\n  (_pluginOptions: PluginOptions = {}) =>\n  (nextConfig: Partial<NextConfig> = {}): Partial<NextConfig> => {\n    if (typeof nextConfig !== 'object') nextConfig = {};\n\n    return Object.assign({}, nextConfig, {\n      env: mergeEnvVariable(nextConfig.env),\n\n      stats: mergeStats(nextConfig.stats),\n\n      webpack: (config: Parameters<NextJsWebpackConfig>['0']) => {\n        const dictionariesPath = join(mainDir, 'dictionaries.cjs');\n        const relativeDictionariesPath = relative(baseDir, dictionariesPath);\n\n        config.externals.push({\n          esbuild: 'esbuild',\n          module: 'module',\n          fs: 'fs',\n        });\n\n        config.resolve.alias['@intlayer/dictionaries-entry'] = resolve(\n          relativeDictionariesPath\n        );\n\n        config.module.rules.push({\n          test: /\\.node$/,\n          loader: 'node-loader',\n        });\n\n        return config;\n      },\n    });\n  };\n"],"mappings":"AAAA,SAAS,SAAS,UAAU,YAAY;AACxC,SAAS,kBAAkB,yBAAyB;AAQpD,MAAM,iBAAiB,iBAAiB;AAAA,EACtC,SAAS;AACX,CAAC;AAGD,MAAM,MAAM,kBAAkB,uBAAuB;AACrD,MAAM,EAAE,SAAS,QAAQ,IAAI,eAAe;AAE5C,MAAM,mBAAmB,CACvB,UAA+C,CAAC,MACrB,OAAO,OAAO,CAAC,GAAG,SAAS,GAAG;AAE3D,MAAM,aAAa,CACjB,YAAiD,CAAC,MAElD,OAAO,OAAO,CAAC,GAAG,WAAW;AAAA,EAC3B,UAAU;AACZ,CAAC;AAEI,MAAM,eACX,CAAC,iBAAgC,CAAC,MAClC,CAAC,aAAkC,CAAC,MAA2B;AAC7D,MAAI,OAAO,eAAe;AAAU,iBAAa,CAAC;AAElD,SAAO,OAAO,OAAO,CAAC,GAAG,YAAY;AAAA,IACnC,KAAK,iBAAiB,WAAW,GAAG;AAAA,IAEpC,OAAO,WAAW,WAAW,KAAK;AAAA,IAElC,SAAS,CAAC,WAAiD;AACzD,YAAM,mBAAmB,KAAK,SAAS,kBAAkB;AACzD,YAAM,2BAA2B,SAAS,SAAS,gBAAgB;AAEnE,aAAO,UAAU,KAAK;AAAA,QACpB,SAAS;AAAA,QACT,QAAQ;AAAA,QACR,IAAI;AAAA,MACN,CAAC;AAED,aAAO,QAAQ,MAAM,8BAA8B,IAAI;AAAA,QACrD;AAAA,MACF;AAEA,aAAO,OAAO,MAAM,KAAK;AAAA,QACvB,MAAM;AAAA,QACN,QAAQ;AAAA,MACV,CAAC;AAED,aAAO;AAAA,IACT;AAAA,EACF,CAAC;AACH;","names":[]}

package/dist/esm/types/NextPage.d.mts

@@ -0,0 +1,13 @@
+import { Locales } from "intlayer";
+import { NextPage } from "next";
+import { PropsWithChildren } from "react";
+
+type LocalParams = {
+  params: {
+    locale: Locales;
+  };
+};
+type NextPageIntlayer = NextPage<LocalParams>;
+type NextLayoutIntlayer = NextPage<PropsWithChildren<LocalParams>>;
+
+export type { LocalParams, NextLayoutIntlayer, NextPageIntlayer };

package/dist/esm/types/NextPage.mjs

@@ -0,0 +1 @@
+//# sourceMappingURL=NextPage.mjs.map

package/dist/esm/types/NextPage.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/esm/types/index.d.mts

@@ -0,0 +1,4 @@
+export { LocalParams, NextPageIntlayer } from "./NextPage.mjs";
+import "intlayer";
+import "next";
+import "react";

package/dist/esm/types/index.mjs

@@ -0,0 +1 @@
+//# sourceMappingURL=index.mjs.map

package/dist/esm/types/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/package.json

@@ -0,0 +1,105 @@
+{
+  "name": "next-intlayer",
+  "version": "1.0.0",
+  "private": false,
+  "description": "Webpack configuration for IntLayer using NextJS",
+  "keywords": [
+    "intlayer",
+    "webpack",
+    "application",
+    "transpile",
+    "nextjs",
+    "typescript",
+    "javascript",
+    "json",
+    "file"
+  ],
+  "homepage": "https://github.com/aypineau/intlayer",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/aypineau/intlayer"
+  },
+  "license": "MIT",
+  "author": {
+    "name": "Aymeric PINEAU",
+    "url": "https://github.com/aypineau"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/esm/index.d.mts",
+      "require": "./dist/cjs/index.cjs",
+      "import": "./dist/esm/index.mjs"
+    },
+    "./client": {
+      "types": "./dist/esm/client/index.d.mts",
+      "require": "./dist/cjs/client/index.cjs",
+      "import": "./dist/esm/client/index.mjs"
+    },
+    "./middleware": {
+      "types": "./dist/esm/middleware/index.d.mts",
+      "require": "./dist/cjs/middleware/index.cjs",
+      "import": "./dist/esm/middleware/index.mjs"
+    },
+    "./server": {
+      "types": "./dist/esm/server/index.d.mts",
+      "require": "./dist/cjs/server/index.cjs",
+      "import": "./dist/esm/server/index.mjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "src/index.ts",
+  "typesVersions": {
+    "*": {
+      "package.json": [
+        "./package.json"
+      ]
+    }
+  },
+  "files": [
+    "./dist",
+    "./src",
+    "./bin",
+    "./package.json"
+  ],
+  "dependencies": {
+    "@formatjs/intl-localematcher": "^0.5.4",
+    "negotiator": "^0.6.3",
+    "next": "14.1.4",
+    "webpack": "^5.91.0",
+    "@intlayer/core": "^1.0.0",
+    "@intlayer/config": "^1.0.0",
+    "intlayer": "^1.0.0",
+    "@intlayer/dictionaries-entry": "^1.0.0",
+    "react-intlayer": "^1.0.0"
+  },
+  "devDependencies": {
+    "@types/negotiator": "^0.6.3",
+    "@types/node": "^20.11.30",
+    "@types/react": "^18.2.78",
+    "react": "^18.2.0",
+    "rimraf": "5.0.5",
+    "tsup": "^8.0.2",
+    "typescript": "^5.4.3",
+    "@utils/eslint-config": "^1.0.0",
+    "@utils/ts-config": "^1.0.0"
+  },
+  "peerDependencies": {
+    "react": "^18.2.0"
+  },
+  "engines": {
+    "node": ">=14.18"
+  },
+  "bug": {
+    "url": "https://github.com/aypineau/intlayer/issues"
+  },
+  "scripts": {
+    "build": "tsup",
+    "clean": "rimraf ./dist",
+    "dev": "tsup --watch",
+    "lint": "eslint . --ext .ts,.tsx,.js,.jsx,.cjs,.mjs",
+    "lint:fix": "eslint . --ext .ts,.tsx,.js,.jsx,.cjs,.mjs --fix",
+    "prettier:fix": "prettier --write src/**/*",
+    "test": "",
+    "typecheck": "tsup--project ./tsconfig.json --noEmit"
+  }
+}

package/src/client/index.ts

@@ -0,0 +1,9 @@
+export {
+  getTranslation,
+  LocaleClientContextProvider,
+  LocaleClientContext,
+  useIntlayer,
+  useTraduction,
+  useLocaleCookie,
+} from 'react-intlayer';
+export { useLocale } from './useLocale';

package/src/client/useLocale.ts

@@ -0,0 +1,46 @@
+import { intlayerMiddlewareConfiguration } from '@intlayer/config/client';
+import type { Locales } from 'intlayer';
+import { usePathname, useRouter } from 'next/navigation.js';
+import { useLocale as useReactLocale, useLocaleCookie } from 'react-intlayer';
+
+const { prefixDefault } = intlayerMiddlewareConfiguration;
+
+export const useLocale = () => {
+  const { setLocaleCookie } = useLocaleCookie();
+  const reactLocaleHook = useReactLocale();
+  const router = useRouter();
+  const pathname = usePathname();
+
+  const {
+    defaultLocale,
+    availableLocales,
+    locale: currentLocale,
+  } = reactLocaleHook;
+
+  const setLocale = (locale: Locales) => {
+    if (currentLocale === locale) return;
+
+    if (!availableLocales.includes(locale)) {
+      console.error(`Locale ${locale} is not available`);
+      return;
+    }
+
+    setLocaleCookie(locale);
+
+    const pathWithoutLocale =
+      !prefixDefault && currentLocale === defaultLocale
+        ? pathname
+        : pathname.slice(`/${currentLocale}`.length) || '/';
+
+    if (!prefixDefault && locale === defaultLocale) {
+      return router.push(pathWithoutLocale);
+    }
+
+    return router.push(`/${locale}${pathWithoutLocale}`);
+  };
+
+  return {
+    ...reactLocaleHook,
+    setLocale,
+  };
+};

package/src/generateStaticParams.ts

@@ -0,0 +1,5 @@
+import { intlayerIntlConfiguration } from '@intlayer/config/client';
+
+const { locales } = intlayerIntlConfiguration;
+
+export const generateStaticParams = () => locales.map((locale) => ({ locale }));

package/src/index.ts

@@ -0,0 +1,11 @@
+export {
+  getTranslation,
+  LocaleClientContextProvider,
+  LocaleClientContext,
+  useIntlayer,
+  useTraduction,
+  useLocaleCookie,
+} from 'react-intlayer';
+export { generateStaticParams } from './generateStaticParams';
+export type { LocalParams, NextPageIntlayer } from './types/index';
+export { useLocale } from './client/useLocale';

package/src/middleware/index.ts

@@ -0,0 +1 @@
+export * from './intlayerMiddleware';

package/src/middleware/intlayerMiddleware.ts

@@ -0,0 +1,215 @@
+import { type Locales, intlayerConfiguration } from '@intlayer/config/client';
+import { type NextRequest, NextResponse } from 'next/server';
+import { localeDetector } from './localeDetector';
+
+const { internationalization, middleware } = intlayerConfiguration;
+const { locales, defaultLocale } = internationalization;
+const {
+  headerName,
+  cookieName,
+  prefixDefault,
+  basePath,
+  serverSetCookie,
+  noPrefix,
+} = middleware;
+
+export const intlayerMiddleware = (request: NextRequest): NextResponse => {
+  const pathname = request.nextUrl.pathname;
+  const cookieLocale = getCookieLocale(request);
+  const basePathTrailingSlash = basePath.endsWith('/');
+
+  if (noPrefix) {
+    return handleNoPrefix(
+      request,
+      cookieLocale,
+      pathname,
+      basePathTrailingSlash
+    );
+  }
+
+  const pathLocale = getPathLocale(pathname);
+  return handlePrefix(
+    request,
+    cookieLocale,
+    pathLocale,
+    pathname,
+    basePathTrailingSlash
+  );
+};
+
+const getCookieLocale = (request: NextRequest): Locales | undefined => {
+  if (!cookieName) return undefined;
+  const cookieValue = request.cookies.get(cookieName)?.value as Locales;
+  if (cookieValue && locales.includes(cookieValue)) {
+    return cookieValue;
+  }
+};
+
+const handleNoPrefix = (
+  request: NextRequest,
+  cookieLocale: Locales | undefined,
+  pathname: string,
+  basePathTrailingSlash: boolean
+): NextResponse => {
+  const locale = cookieLocale ?? defaultLocale;
+  const newPath = constructPath(
+    locale,
+    pathname,
+    basePath,
+    basePathTrailingSlash
+  );
+  return rewriteUrl(request, newPath, locale);
+};
+
+const getPathLocale = (pathname: string): Locales | undefined =>
+  locales.find(
+    (locale) => pathname.startsWith(`/${locale}/`) || pathname === `/${locale}`
+  );
+
+const handlePrefix = (
+  request: NextRequest,
+  cookieLocale: Locales | undefined,
+  pathLocale: Locales | undefined,
+  pathname: string,
+  basePathTrailingSlash: boolean
+): NextResponse => {
+  if (!pathLocale) {
+    return handleMissingPathLocale(
+      request,
+      cookieLocale,
+      pathname,
+      basePathTrailingSlash
+    );
+  }
+  return handleExistingPathLocale(
+    request,
+    cookieLocale,
+    pathLocale,
+    pathname,
+    basePathTrailingSlash
+  );
+};
+
+const handleMissingPathLocale = (
+  request: NextRequest,
+  cookieLocale: Locales | undefined,
+  pathname: string,
+  basePathTrailingSlash: boolean
+): NextResponse => {
+  let locale = cookieLocale ?? localeDetector?.(request) ?? defaultLocale;
+  if (!locales.includes(locale)) {
+    console.warn(
+      'The localeDetector callback must return a locale included in your locales array. Reverting to using defaultLocale.'
+    );
+    locale = defaultLocale;
+  }
+  const newPath = constructPath(
+    locale,
+    pathname,
+    basePath,
+    basePathTrailingSlash
+  );
+  return prefixDefault || locale !== defaultLocale
+    ? redirectUrl(request, newPath)
+    : rewriteUrl(request, newPath, locale);
+};
+
+const handleExistingPathLocale = (
+  request: NextRequest,
+  cookieLocale: Locales | undefined,
+  pathLocale: Locales,
+  pathname: string,
+  basePathTrailingSlash: boolean
+): NextResponse => {
+  if (
+    cookieLocale &&
+    cookieLocale !== pathLocale &&
+    serverSetCookie !== 'always'
+  ) {
+    const newPath = handleCookieLocaleMismatch(
+      request,
+      pathname,
+      pathLocale,
+      cookieLocale,
+      basePath,
+      basePathTrailingSlash
+    );
+    return redirectUrl(request, newPath);
+  }
+
+  return handleDefaultLocaleRedirect(
+    request,
+    pathLocale,
+    pathname,
+    basePathTrailingSlash
+  );
+};
+
+const handleCookieLocaleMismatch = (
+  request: NextRequest,
+
+  pathname: string,
+  pathLocale: Locales,
+  cookieLocale: Locales,
+  basePath: string,
+  basePathTrailingSlash: boolean
+): string => {
+  const newPath = pathname.replace(`/${pathLocale}`, `/${cookieLocale}`);
+  return constructPath(
+    cookieLocale,
+    newPath,
+    basePath,
+    basePathTrailingSlash,
+    request.nextUrl.search
+  );
+};
+
+const handleDefaultLocaleRedirect = (
+  request: NextRequest,
+  pathLocale: Locales,
+  pathname: string,
+  basePathTrailingSlash: boolean
+): NextResponse => {
+  if (!prefixDefault && pathLocale === defaultLocale) {
+    let pathWithoutLocale = pathname.slice(`/${pathLocale}`.length) || '/';
+
+    if (basePathTrailingSlash) {
+      pathWithoutLocale = pathWithoutLocale.slice(1);
+    }
+
+    if (request.nextUrl.search) {
+      pathWithoutLocale += request.nextUrl.search;
+    }
+
+    return rewriteUrl(request, `${basePath}${pathWithoutLocale}`, pathLocale);
+  }
+  return rewriteUrl(request, pathname, pathLocale);
+};
+
+const constructPath = (
+  locale: Locales,
+  path: string,
+  basePath: string,
+  basePathTrailingSlash: boolean,
+  search?: string
+): string => {
+  let newPath = `${locale}${path}`;
+  newPath = `${basePath}${basePathTrailingSlash ? '' : '/'}${newPath}`;
+  if (search) {
+    newPath += search;
+  }
+  return newPath;
+};
+
+const rewriteUrl = (
+  request: NextRequest,
+  newPath: string,
+  locale: Locales
+): NextResponse => {
+  const response = NextResponse.rewrite(new URL(newPath, request.url));
+  response.headers.set(headerName, locale);
+  return response;
+};
+
+const redirectUrl = (request: NextRequest, newPath: string): NextResponse =>
+  NextResponse.redirect(new URL(newPath, request.url));

package/src/middleware/localeDetector.ts

@@ -0,0 +1,28 @@
+import { match } from '@formatjs/intl-localematcher';
+import type { Locales } from '@intlayer/config';
+import { getConfiguration } from '@intlayer/config/client';
+import Negotiator from 'negotiator';
+import type { NextRequest } from 'next/server.js';
+
+const { locales, defaultLocale } = getConfiguration().internationalization;
+
+export const localeDetector = (request: NextRequest): Locales => {
+  const negotiatorHeaders: Record<string, string> = {};
+
+  request.headers.forEach((value, key) => (negotiatorHeaders[key] = value));
+
+  const languages = new Negotiator({ headers: negotiatorHeaders }).languages();
+
+  // match can only use specifically formatted locales
+  // https://stackoverflow.com/questions/76447732/nextjs-13-i18n-incorrect-locale-information-provided
+  try {
+    return match(languages, locales, defaultLocale) as Locales;
+  } catch (e) {
+    console.warn(
+      `No valid locales in accept-language header: ${languages.join(', ')}`
+    );
+    console.warn(`Reverting to using defaultLocale: ${defaultLocale}`);
+
+    return defaultLocale;
+  }
+};

package/src/server/index.ts

@@ -0,0 +1,9 @@
+export {
+  getLocaleContent,
+  useTraduction,
+  LocaleServerContext,
+  LocaleServerContextProvider,
+  locale,
+  useIntlayer,
+} from 'react-intlayer/server';
+export { withIntlayer } from './withIntlayer';

package/src/server/withIntlayer.ts

@@ -0,0 +1,61 @@
+import { resolve, relative, join } from 'path';
+import { getConfiguration, formatEnvVariable } from '@intlayer/config';
+import type { NextConfig } from 'next';
+import type { NextJsWebpackConfig } from 'next/dist/server/config-shared';
+
+type PluginOptions = {
+  // TODO: add options
+};
+
+const intlayerConfig = getConfiguration({
+  verbose: true,
+});
+
+// Set all configuration values as environment variables
+const env = formatEnvVariable('NEXT_PUBLIC_INTLAYER_');
+const { mainDir, baseDir } = intlayerConfig.content;
+
+const mergeEnvVariable = (
+  nextEnv: Record<string, unknown> | undefined = {}
+): Record<string, string> => Object.assign({}, nextEnv, env);
+
+const mergeStats = (
+  nextStats: Record<string, unknown> | undefined = {}
+): Record<string, unknown> =>
+  Object.assign({}, nextStats, {
+    warnings: false,
+  });
+
+export const withIntlayer =
+  (_pluginOptions: PluginOptions = {}) =>
+  (nextConfig: Partial<NextConfig> = {}): Partial<NextConfig> => {
+    if (typeof nextConfig !== 'object') nextConfig = {};
+
+    return Object.assign({}, nextConfig, {
+      env: mergeEnvVariable(nextConfig.env),
+
+      stats: mergeStats(nextConfig.stats),
+
+      webpack: (config: Parameters<NextJsWebpackConfig>['0']) => {
+        const dictionariesPath = join(mainDir, 'dictionaries.cjs');
+        const relativeDictionariesPath = relative(baseDir, dictionariesPath);
+
+        config.externals.push({
+          esbuild: 'esbuild',
+          module: 'module',
+          fs: 'fs',
+        });
+
+        config.resolve.alias['@intlayer/dictionaries-entry'] = resolve(
+          relativeDictionariesPath
+        );
+
+        config.module.rules.push({
+          test: /\.node$/,
+          loader: 'node-loader',
+        });
+
+        return config;
+      },
+    });
+  };

package/src/types/NextPage.ts

@@ -0,0 +1,10 @@
+import type { Locales } from 'intlayer';
+import type { NextPage } from 'next';
+import type { PropsWithChildren } from 'react';
+
+export type LocalParams = {
+  params: { locale: Locales };
+};
+
+export type NextPageIntlayer = NextPage<LocalParams>;
+export type NextLayoutIntlayer = NextPage<PropsWithChildren<LocalParams>>;

package/src/types/index.ts

@@ -0,0 +1 @@
+export type { LocalParams, NextPageIntlayer } from './NextPage';