next-intlayer 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020-2021 Sébastien Vanvelthem
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/cjs/client/index.cjs

@@ -0,0 +1,48 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if ((from && typeof from === "object") || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, {
+          get: () => from[key],
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable,
+        });
+  }
+  return to;
+};
+var __toCommonJS = (mod) =>
+  __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var client_exports = {};
+__export(client_exports, {
+  LocaleClientContext: () => import_react_intlayer.LocaleClientContext,
+  LocaleClientContextProvider: () =>
+    import_react_intlayer.LocaleClientContextProvider,
+  getTranslation: () => import_react_intlayer.getTranslation,
+  useIntlayer: () => import_react_intlayer.useIntlayer,
+  useLocale: () => import_useLocale.useLocale,
+  useLocaleCookie: () => import_react_intlayer.useLocaleCookie,
+  useTraduction: () => import_react_intlayer.useTraduction,
+});
+module.exports = __toCommonJS(client_exports);
+var import_react_intlayer = require("react-intlayer");
+var import_useLocale = require("./useLocale.cjs");
+// Annotate the CommonJS export names for ESM import in node:
+0 &&
+  (module.exports = {
+    LocaleClientContext,
+    LocaleClientContextProvider,
+    getTranslation,
+    useIntlayer,
+    useLocale,
+    useLocaleCookie,
+    useTraduction,
+  });
+//# sourceMappingURL=index.cjs.map

package/dist/cjs/client/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/client/index.ts"],"sourcesContent":["export {\n  getTranslation,\n  LocaleClientContextProvider,\n  LocaleClientContext,\n  useIntlayer,\n  useTraduction,\n  useLocaleCookie,\n} from 'react-intlayer';\nexport { useLocale } from './useLocale';\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,4BAOO;AACP,uBAA0B;","names":[]}

package/dist/cjs/client/index.d.ts

@@ -0,0 +1,10 @@
+export {
+  LocaleClientContext,
+  LocaleClientContextProvider,
+  getTranslation,
+  useIntlayer,
+  useLocaleCookie,
+  useTraduction,
+} from "react-intlayer";
+export { useLocale } from "./useLocale.js";
+import "intlayer";

package/dist/cjs/client/useLocale.cjs

@@ -0,0 +1,68 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if ((from && typeof from === "object") || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, {
+          get: () => from[key],
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable,
+        });
+  }
+  return to;
+};
+var __toCommonJS = (mod) =>
+  __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var useLocale_exports = {};
+__export(useLocale_exports, {
+  useLocale: () => useLocale,
+});
+module.exports = __toCommonJS(useLocale_exports);
+var import_client = require("@intlayer/config/client");
+var import_navigation = require("next/navigation.js");
+var import_react_intlayer = require("react-intlayer");
+const { prefixDefault } = import_client.intlayerMiddlewareConfiguration;
+const useLocale = () => {
+  const { setLocaleCookie } = (0, import_react_intlayer.useLocaleCookie)();
+  const reactLocaleHook = (0, import_react_intlayer.useLocale)();
+  const router = (0, import_navigation.useRouter)();
+  const pathname = (0, import_navigation.usePathname)();
+  const {
+    defaultLocale,
+    availableLocales,
+    locale: currentLocale,
+  } = reactLocaleHook;
+  const setLocale = (locale) => {
+    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,
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 &&
+  (module.exports = {
+    useLocale,
+  });
+//# sourceMappingURL=useLocale.cjs.map

package/dist/cjs/client/useLocale.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/client/useLocale.ts"],"sourcesContent":["import { intlayerMiddlewareConfiguration } from '@intlayer/config/client';\nimport type { Locales } from 'intlayer';\nimport { usePathname, useRouter } from 'next/navigation.js';\nimport { useLocale as useReactLocale, useLocaleCookie } from 'react-intlayer';\n\nconst { prefixDefault } = intlayerMiddlewareConfiguration;\n\nexport const useLocale = () => {\n  const { setLocaleCookie } = useLocaleCookie();\n  const reactLocaleHook = useReactLocale();\n  const router = useRouter();\n  const pathname = usePathname();\n\n  const {\n    defaultLocale,\n    availableLocales,\n    locale: currentLocale,\n  } = reactLocaleHook;\n\n  const setLocale = (locale: Locales) => {\n    if (currentLocale === locale) return;\n\n    if (!availableLocales.includes(locale)) {\n      console.error(`Locale ${locale} is not available`);\n      return;\n    }\n\n    setLocaleCookie(locale);\n\n    const pathWithoutLocale =\n      !prefixDefault && currentLocale === defaultLocale\n        ? pathname\n        : pathname.slice(`/${currentLocale}`.length) || '/';\n\n    if (!prefixDefault && locale === defaultLocale) {\n      return router.push(pathWithoutLocale);\n    }\n\n    return router.push(`/${locale}${pathWithoutLocale}`);\n  };\n\n  return {\n    ...reactLocaleHook,\n    setLocale,\n  };\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAAgD;AAEhD,wBAAuC;AACvC,4BAA6D;AAE7D,MAAM,EAAE,cAAc,IAAI;AAEnB,MAAM,YAAY,MAAM;AAC7B,QAAM,EAAE,gBAAgB,QAAI,uCAAgB;AAC5C,QAAM,sBAAkB,sBAAAA,WAAe;AACvC,QAAM,aAAS,6BAAU;AACzB,QAAM,eAAW,+BAAY;AAE7B,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA,QAAQ;AAAA,EACV,IAAI;AAEJ,QAAM,YAAY,CAAC,WAAoB;AACrC,QAAI,kBAAkB;AAAQ;AAE9B,QAAI,CAAC,iBAAiB,SAAS,MAAM,GAAG;AACtC,cAAQ,MAAM,UAAU,MAAM,mBAAmB;AACjD;AAAA,IACF;AAEA,oBAAgB,MAAM;AAEtB,UAAM,oBACJ,CAAC,iBAAiB,kBAAkB,gBAChC,WACA,SAAS,MAAM,IAAI,aAAa,GAAG,MAAM,KAAK;AAEpD,QAAI,CAAC,iBAAiB,WAAW,eAAe;AAC9C,aAAO,OAAO,KAAK,iBAAiB;AAAA,IACtC;AAEA,WAAO,OAAO,KAAK,IAAI,MAAM,GAAG,iBAAiB,EAAE;AAAA,EACrD;AAEA,SAAO;AAAA,IACL,GAAG;AAAA,IACH;AAAA,EACF;AACF;","names":["useReactLocale"]}

package/dist/cjs/client/useLocale.d.ts

@@ -0,0 +1,12 @@
+import "react-intlayer";
+import { Locales } from "intlayer";
+
+declare const useLocale: () => {
+  setLocale: (locale: Locales) => void;
+  locale: Locales;
+  defaultLocale: Locales;
+  availableLocales: Locales[];
+  localeList: Locales[];
+};
+
+export { useLocale };

package/dist/cjs/generateStaticParams.cjs

@@ -0,0 +1,36 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if ((from && typeof from === "object") || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, {
+          get: () => from[key],
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable,
+        });
+  }
+  return to;
+};
+var __toCommonJS = (mod) =>
+  __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var generateStaticParams_exports = {};
+__export(generateStaticParams_exports, {
+  generateStaticParams: () => generateStaticParams,
+});
+module.exports = __toCommonJS(generateStaticParams_exports);
+var import_client = require("@intlayer/config/client");
+const { locales } = import_client.intlayerIntlConfiguration;
+const generateStaticParams = () => locales.map((locale) => ({ locale }));
+// Annotate the CommonJS export names for ESM import in node:
+0 &&
+  (module.exports = {
+    generateStaticParams,
+  });
+//# sourceMappingURL=generateStaticParams.cjs.map

package/dist/cjs/generateStaticParams.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/generateStaticParams.ts"],"sourcesContent":["import { intlayerIntlConfiguration } from '@intlayer/config/client';\n\nconst { locales } = intlayerIntlConfiguration;\n\nexport const generateStaticParams = () => locales.map((locale) => ({ locale }));\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAA0C;AAE1C,MAAM,EAAE,QAAQ,IAAI;AAEb,MAAM,uBAAuB,MAAM,QAAQ,IAAI,CAAC,YAAY,EAAE,OAAO,EAAE;","names":[]}

package/dist/cjs/generateStaticParams.d.ts

@@ -0,0 +1,7 @@
+import * as _intlayer_config_client from "@intlayer/config/client";
+
+declare const generateStaticParams: () => {
+  locale: _intlayer_config_client.Locales;
+}[];
+
+export { generateStaticParams };

package/dist/cjs/index.cjs

@@ -0,0 +1,51 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if ((from && typeof from === "object") || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, {
+          get: () => from[key],
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable,
+        });
+  }
+  return to;
+};
+var __toCommonJS = (mod) =>
+  __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var src_exports = {};
+__export(src_exports, {
+  LocaleClientContext: () => import_react_intlayer.LocaleClientContext,
+  LocaleClientContextProvider: () =>
+    import_react_intlayer.LocaleClientContextProvider,
+  generateStaticParams: () => import_generateStaticParams.generateStaticParams,
+  getTranslation: () => import_react_intlayer.getTranslation,
+  useIntlayer: () => import_react_intlayer.useIntlayer,
+  useLocale: () => import_useLocale.useLocale,
+  useLocaleCookie: () => import_react_intlayer.useLocaleCookie,
+  useTraduction: () => import_react_intlayer.useTraduction,
+});
+module.exports = __toCommonJS(src_exports);
+var import_react_intlayer = require("react-intlayer");
+var import_generateStaticParams = require("./generateStaticParams.cjs");
+var import_useLocale = require("./client/useLocale.cjs");
+// Annotate the CommonJS export names for ESM import in node:
+0 &&
+  (module.exports = {
+    LocaleClientContext,
+    LocaleClientContextProvider,
+    generateStaticParams,
+    getTranslation,
+    useIntlayer,
+    useLocale,
+    useLocaleCookie,
+    useTraduction,
+  });
+//# sourceMappingURL=index.cjs.map

package/dist/cjs/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/index.ts"],"sourcesContent":["export {\n  getTranslation,\n  LocaleClientContextProvider,\n  LocaleClientContext,\n  useIntlayer,\n  useTraduction,\n  useLocaleCookie,\n} from 'react-intlayer';\nexport { generateStaticParams } from './generateStaticParams';\nexport type { LocalParams, NextPageIntlayer } from './types/index';\nexport { useLocale } from './client/useLocale';\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,4BAOO;AACP,kCAAqC;AAErC,uBAA0B;","names":[]}

package/dist/cjs/index.d.ts

@@ -0,0 +1,15 @@
+export {
+  LocaleClientContext,
+  LocaleClientContextProvider,
+  getTranslation,
+  useIntlayer,
+  useLocaleCookie,
+  useTraduction,
+} from "react-intlayer";
+export { generateStaticParams } from "./generateStaticParams.js";
+export { LocalParams, NextPageIntlayer } from "./types/NextPage.js";
+export { useLocale } from "./client/useLocale.js";
+import "@intlayer/config/client";
+import "intlayer";
+import "next";
+import "react";

package/dist/cjs/middleware/index.cjs

@@ -0,0 +1,35 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if ((from && typeof from === "object") || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, {
+          get: () => from[key],
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable,
+        });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (
+  __copyProps(target, mod, "default"),
+  secondTarget && __copyProps(secondTarget, mod, "default")
+);
+var __toCommonJS = (mod) =>
+  __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var middleware_exports = {};
+module.exports = __toCommonJS(middleware_exports);
+__reExport(
+  middleware_exports,
+  require("./intlayerMiddleware.cjs"),
+  module.exports
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 &&
+  (module.exports = {
+    ...require("./intlayerMiddleware.cjs"),
+  });
+//# sourceMappingURL=index.cjs.map

package/dist/cjs/middleware/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/middleware/index.ts"],"sourcesContent":["export * from './intlayerMiddleware';\n"],"mappings":";;;;;;;;;;;;;;;AAAA;AAAA;AAAA,+BAAc,iCAAd;","names":[]}

package/dist/cjs/middleware/index.d.ts

@@ -0,0 +1,2 @@
+export { intlayerMiddleware } from "./intlayerMiddleware.js";
+import "next/server";

package/dist/cjs/middleware/intlayerMiddleware.cjs

@@ -0,0 +1,230 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if ((from && typeof from === "object") || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, {
+          get: () => from[key],
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable,
+        });
+  }
+  return to;
+};
+var __toCommonJS = (mod) =>
+  __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var intlayerMiddleware_exports = {};
+__export(intlayerMiddleware_exports, {
+  intlayerMiddleware: () => intlayerMiddleware,
+});
+module.exports = __toCommonJS(intlayerMiddleware_exports);
+var import_client = require("@intlayer/config/client");
+var import_server = require("next/server");
+var import_localeDetector = require("./localeDetector.cjs");
+const { internationalization, middleware } =
+  import_client.intlayerConfiguration;
+const { locales, defaultLocale } = internationalization;
+const {
+  headerName,
+  cookieName,
+  prefixDefault,
+  basePath,
+  serverSetCookie,
+  noPrefix,
+} = middleware;
+const intlayerMiddleware = (request) => {
+  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) => {
+  if (!cookieName) return void 0;
+  const cookieValue = request.cookies.get(cookieName)?.value;
+  if (cookieValue && locales.includes(cookieValue)) {
+    return cookieValue;
+  }
+};
+const handleNoPrefix = (
+  request,
+  cookieLocale,
+  pathname,
+  basePathTrailingSlash
+) => {
+  const locale = cookieLocale ?? defaultLocale;
+  const newPath = constructPath(
+    locale,
+    pathname,
+    basePath,
+    basePathTrailingSlash
+  );
+  return rewriteUrl(request, newPath, locale);
+};
+const getPathLocale = (pathname) =>
+  locales.find(
+    (locale) => pathname.startsWith(`/${locale}/`) || pathname === `/${locale}`
+  );
+const handlePrefix = (
+  request,
+  cookieLocale,
+  pathLocale,
+  pathname,
+  basePathTrailingSlash
+) => {
+  if (!pathLocale) {
+    return handleMissingPathLocale(
+      request,
+      cookieLocale,
+      pathname,
+      basePathTrailingSlash
+    );
+  }
+  return handleExistingPathLocale(
+    request,
+    cookieLocale,
+    pathLocale,
+    pathname,
+    basePathTrailingSlash
+  );
+};
+const handleMissingPathLocale = (
+  request,
+  cookieLocale,
+  pathname,
+  basePathTrailingSlash
+) => {
+  let locale =
+    cookieLocale ??
+    (0, import_localeDetector.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,
+  cookieLocale,
+  pathLocale,
+  pathname,
+  basePathTrailingSlash
+) => {
+  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,
+  pathname,
+  pathLocale,
+  cookieLocale,
+  basePath2,
+  basePathTrailingSlash
+) => {
+  const newPath = pathname.replace(`/${pathLocale}`, `/${cookieLocale}`);
+  return constructPath(
+    cookieLocale,
+    newPath,
+    basePath2,
+    basePathTrailingSlash,
+    request.nextUrl.search
+  );
+};
+const handleDefaultLocaleRedirect = (
+  request,
+  pathLocale,
+  pathname,
+  basePathTrailingSlash
+) => {
+  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,
+  path,
+  basePath2,
+  basePathTrailingSlash,
+  search
+) => {
+  let newPath = `${locale}${path}`;
+  newPath = `${basePath2}${basePathTrailingSlash ? "" : "/"}${newPath}`;
+  if (search) {
+    newPath += search;
+  }
+  return newPath;
+};
+const rewriteUrl = (request, newPath, locale) => {
+  const response = import_server.NextResponse.rewrite(
+    new URL(newPath, request.url)
+  );
+  response.headers.set(headerName, locale);
+  return response;
+};
+const redirectUrl = (request, newPath) =>
+  import_server.NextResponse.redirect(new URL(newPath, request.url));
+// Annotate the CommonJS export names for ESM import in node:
+0 &&
+  (module.exports = {
+    intlayerMiddleware,
+  });
+//# sourceMappingURL=intlayerMiddleware.cjs.map

package/dist/cjs/middleware/intlayerMiddleware.cjs.map

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

package/dist/cjs/middleware/intlayerMiddleware.d.ts

@@ -0,0 +1,5 @@
+import { NextRequest, NextResponse } from "next/server";
+
+declare const intlayerMiddleware: (request: NextRequest) => NextResponse;
+
+export { intlayerMiddleware };

package/dist/cjs/middleware/localeDetector.cjs

@@ -0,0 +1,73 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if ((from && typeof from === "object") || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, {
+          get: () => from[key],
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable,
+        });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (
+  (target = mod != null ? __create(__getProtoOf(mod)) : {}),
+  __copyProps(
+    // If the importer is in node compatibility mode or this is not an ESM
+    // file that has been converted to a CommonJS file using a Babel-
+    // compatible transform (i.e. "__esModule" has not been set), then set
+    // "default" to the CommonJS "module.exports" for node compatibility.
+    isNodeMode || !mod || !mod.__esModule
+      ? __defProp(target, "default", { value: mod, enumerable: true })
+      : target,
+    mod
+  )
+);
+var __toCommonJS = (mod) =>
+  __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var localeDetector_exports = {};
+__export(localeDetector_exports, {
+  localeDetector: () => localeDetector,
+});
+module.exports = __toCommonJS(localeDetector_exports);
+var import_intl_localematcher = require("@formatjs/intl-localematcher");
+var import_client = require("@intlayer/config/client");
+var import_negotiator = __toESM(require("negotiator"));
+const { locales, defaultLocale } = (0, import_client.getConfiguration)()
+  .internationalization;
+const localeDetector = (request) => {
+  const negotiatorHeaders = {};
+  request.headers.forEach((value, key) => (negotiatorHeaders[key] = value));
+  const languages = new import_negotiator.default({
+    headers: negotiatorHeaders,
+  }).languages();
+  try {
+    return (0, import_intl_localematcher.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;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 &&
+  (module.exports = {
+    localeDetector,
+  });
+//# sourceMappingURL=localeDetector.cjs.map