next-intlayer 8.4.4 → 8.4.6

package/dist/esm/client/format/index.mjs

@@ -1 +1 @@
-export*from"react-intlayer/format";
+export * from "react-intlayer/format"

package/dist/esm/client/index.mjs

@@ -1 +1,6 @@
-import{IntlayerClientProvider as e}from"./IntlayerClientProvider.mjs";import{useLocale as t}from"./useLocale.mjs";import{useLocalePageRouter as n}from"./useLocalePageRouter.mjs";import{useRewriteURL as r}from"./useRewriteURL.mjs";export{e as IntlayerClientProvider,t as useLocale,n as useLocalePageRouter,r as useRewriteURL};
+import { IntlayerClientProvider } from "./IntlayerClientProvider.mjs";
+import { useLocale } from "./useLocale.mjs";
+import { useLocalePageRouter } from "./useLocalePageRouter.mjs";
+import { useRewriteURL } from "./useRewriteURL.mjs";
+
+export { IntlayerClientProvider, useLocale, useLocalePageRouter, useRewriteURL };

package/dist/esm/client/useLocale.mjs

@@ -1,2 +1,70 @@
-"use client";import{useLocale as e}from"react-intlayer";import{getLocalizedUrl as t,getPathWithoutLocale as n}from"@intlayer/core/localization";import{usePathname as r,useRouter as i}from"next/navigation.js";import{useCallback as a,useEffect as o,useMemo as s,useState as c}from"react";const l=()=>{let e=r(),[t,i]=c(e);return o(()=>{let t=typeof window<`u`?window.location.search:``;i(t?`${e}${t}`:e)},[e]),s(()=>n(t),[t])},u=({onChange:n=`replace`}={})=>{let{replace:r,push:o}=i(),s=l();return{...e({onLocaleChange:a(e=>{if(!n)return;let i=t(s,e);if(typeof n==`function`){n({locale:e,path:i});return}n===`replace`&&r(i),n===`push`&&o(i)},[r,o,s,n])}),pathWithoutLocale:s}};export{u as useLocale};
+'use client';
+
+import { useLocale as useLocale$1 } from "react-intlayer";
+import { getLocalizedUrl, getPathWithoutLocale } from "@intlayer/core/localization";
+import { usePathname, useRouter } from "next/navigation.js";
+import { useCallback, useEffect, useMemo, useState } from "react";
+
+//#region src/client/useLocale.ts
+const usePathWithoutLocale = () => {
+	const pathname = usePathname();
+	const [fullPath, setFullPath] = useState(pathname);
+	useEffect(() => {
+		const search = typeof window !== "undefined" ? window.location.search : "";
+		setFullPath(search ? `${pathname}${search}` : pathname);
+	}, [pathname]);
+	return useMemo(() => getPathWithoutLocale(fullPath), [fullPath]);
+};
+/**
+* Hook to manage the current locale in Next.js App Router.
+*
+* This hook extends the base `useLocale` from `react-intlayer` by adding
+* Next.js-specific navigation logic for locale changes.
+*
+* @param props - Optional properties to configure locale change behavior.
+* @returns An object containing the current locale, path without locale, and functions to update the locale.
+*
+* @example
+* ```tsx
+* 'use client';
+*
+* import { useLocale } from 'next-intlayer';
+*
+* const LocaleSwitcher = () => {
+*   const { setLocale } = useLocale({ onChange: 'push' });
+*
+*   return (
+*     <button onClick={() => setLocale('fr')}>Switch to French</button>
+*   );
+* };
+* ```
+*/
+const useLocale = ({ onChange = "replace" } = {}) => {
+	const { replace, push } = useRouter();
+	const pathWithoutLocale = usePathWithoutLocale();
+	return {
+		...useLocale$1({ onLocaleChange: useCallback((locale) => {
+			if (!onChange) return;
+			const pathWithLocale = getLocalizedUrl(pathWithoutLocale, locale);
+			if (typeof onChange === "function") {
+				onChange({
+					locale,
+					path: pathWithLocale
+				});
+				return;
+			}
+			if (onChange === "replace") replace(pathWithLocale);
+			if (onChange === "push") push(pathWithLocale);
+		}, [
+			replace,
+			push,
+			pathWithoutLocale,
+			onChange
+		]) }),
+		pathWithoutLocale
+	};
+};
+
+//#endregion
+export { useLocale };
 //# sourceMappingURL=useLocale.mjs.map

package/dist/esm/client/useLocale.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"useLocale.mjs","names":["useLocaleReact"],"sources":["../../../src/client/useLocale.ts"],"sourcesContent":["'use client';\n\nimport {\n  getLocalizedUrl,\n  getPathWithoutLocale,\n} from '@intlayer/core/localization';\nimport type { DeclaredLocales } from '@intlayer/types/module_augmentation';\nimport { usePathname, useRouter } from 'next/navigation.js';\nimport { useCallback, useEffect, useMemo, useState } from 'react';\nimport { useLocale as useLocaleReact } from 'react-intlayer';\n\ntype UseLocaleProps = {\n  onChange?:\n    | 'replace'\n    | 'push'\n    | 'none'\n    | ((params: { locale: DeclaredLocales; path: string }) => void);\n};\n\nconst usePathWithoutLocale = () => {\n  const pathname = usePathname(); // updates on client navigations\n  const [fullPath, setFullPath] = useState(pathname);\n\n  useEffect(() => {\n    // Runs only on client; avoids suspense.\n    const search = typeof window !== 'undefined' ? window.location.search : '';\n    setFullPath(search ? `${pathname}${search}` : pathname);\n  }, [pathname]);\n\n  // Your own helper\n  return useMemo(() => getPathWithoutLocale(fullPath), [fullPath]);\n};\n\n/**\n * Hook to manage the current locale in Next.js App Router.\n *\n * This hook extends the base `useLocale` from `react-intlayer` by adding\n * Next.js-specific navigation logic for locale changes.\n *\n * @param props - Optional properties to configure locale change behavior.\n * @returns An object containing the current locale, path without locale, and functions to update the locale.\n *\n * @example\n * ```tsx\n * 'use client';\n *\n * import { useLocale } from 'next-intlayer';\n *\n * const LocaleSwitcher = () => {\n *   const { setLocale } = useLocale({ onChange: 'push' });\n *\n *   return (\n *     <button onClick={() => setLocale('fr')}>Switch to French</button>\n *   );\n * };\n * ```\n */\nexport const useLocale = ({ onChange = 'replace' }: UseLocaleProps = {}) => {\n  const { replace, push } = useRouter();\n  const pathWithoutLocale = usePathWithoutLocale();\n\n  const redirectionFunction = useCallback(\n    (locale: DeclaredLocales) => {\n      if (!onChange) return;\n\n      const pathWithLocale = getLocalizedUrl(pathWithoutLocale, locale);\n\n      if (typeof onChange === 'function') {\n        onChange({ locale, path: pathWithLocale });\n        return;\n      }\n\n      if (onChange === 'replace') {\n        replace(pathWithLocale);\n      }\n      if (onChange === 'push') {\n        push(pathWithLocale);\n      }\n    },\n    [replace, push, pathWithoutLocale, onChange]\n  );\n\n  const reactLocaleHook = useLocaleReact({\n    onLocaleChange: redirectionFunction,\n  });\n\n  return {\n    ...reactLocaleHook,\n    pathWithoutLocale,\n  };\n};\n"],"mappings":"8RAmBA,MAAM,MAA6B,CACjC,IAAM,EAAW,GAAa,CACxB,CAAC,EAAU,GAAe,EAAS,EAAS,CASlD,OAPA,MAAgB,CAEd,IAAM,EAAS,OAAO,OAAW,IAAc,OAAO,SAAS,OAAS,GACxE,EAAY,EAAS,GAAG,IAAW,IAAW,EAAS,EACtD,CAAC,EAAS,CAAC,CAGP,MAAc,EAAqB,EAAS,CAAE,CAAC,EAAS,CAAC,EA2BrD,GAAa,CAAE,WAAW,WAA8B,EAAE,GAAK,CAC1E,GAAM,CAAE,UAAS,QAAS,GAAW,CAC/B,EAAoB,GAAsB,CA2BhD,MAAO,CACL,GALsBA,EAAe,CACrC,eAtB0B,EACzB,GAA4B,CAC3B,GAAI,CAAC,EAAU,OAEf,IAAM,EAAiB,EAAgB,EAAmB,EAAO,CAEjE,GAAI,OAAO,GAAa,WAAY,CAClC,EAAS,CAAE,SAAQ,KAAM,EAAgB,CAAC,CAC1C,OAGE,IAAa,WACf,EAAQ,EAAe,CAErB,IAAa,QACf,EAAK,EAAe,EAGxB,CAAC,EAAS,EAAM,EAAmB,EAAS,CAC7C,CAIA,CAAC,CAIA,oBACD"}
+{"version":3,"file":"useLocale.mjs","names":["useLocaleReact"],"sources":["../../../src/client/useLocale.ts"],"sourcesContent":["'use client';\n\nimport {\n  getLocalizedUrl,\n  getPathWithoutLocale,\n} from '@intlayer/core/localization';\nimport type { DeclaredLocales } from '@intlayer/types/module_augmentation';\nimport { usePathname, useRouter } from 'next/navigation.js';\nimport { useCallback, useEffect, useMemo, useState } from 'react';\nimport { useLocale as useLocaleReact } from 'react-intlayer';\n\ntype UseLocaleProps = {\n  onChange?:\n    | 'replace'\n    | 'push'\n    | 'none'\n    | ((params: { locale: DeclaredLocales; path: string }) => void);\n};\n\nconst usePathWithoutLocale = () => {\n  const pathname = usePathname(); // updates on client navigations\n  const [fullPath, setFullPath] = useState(pathname);\n\n  useEffect(() => {\n    // Runs only on client; avoids suspense.\n    const search = typeof window !== 'undefined' ? window.location.search : '';\n    setFullPath(search ? `${pathname}${search}` : pathname);\n  }, [pathname]);\n\n  // Your own helper\n  return useMemo(() => getPathWithoutLocale(fullPath), [fullPath]);\n};\n\n/**\n * Hook to manage the current locale in Next.js App Router.\n *\n * This hook extends the base `useLocale` from `react-intlayer` by adding\n * Next.js-specific navigation logic for locale changes.\n *\n * @param props - Optional properties to configure locale change behavior.\n * @returns An object containing the current locale, path without locale, and functions to update the locale.\n *\n * @example\n * ```tsx\n * 'use client';\n *\n * import { useLocale } from 'next-intlayer';\n *\n * const LocaleSwitcher = () => {\n *   const { setLocale } = useLocale({ onChange: 'push' });\n *\n *   return (\n *     <button onClick={() => setLocale('fr')}>Switch to French</button>\n *   );\n * };\n * ```\n */\nexport const useLocale = ({ onChange = 'replace' }: UseLocaleProps = {}) => {\n  const { replace, push } = useRouter();\n  const pathWithoutLocale = usePathWithoutLocale();\n\n  const redirectionFunction = useCallback(\n    (locale: DeclaredLocales) => {\n      if (!onChange) return;\n\n      const pathWithLocale = getLocalizedUrl(pathWithoutLocale, locale);\n\n      if (typeof onChange === 'function') {\n        onChange({ locale, path: pathWithLocale });\n        return;\n      }\n\n      if (onChange === 'replace') {\n        replace(pathWithLocale);\n      }\n      if (onChange === 'push') {\n        push(pathWithLocale);\n      }\n    },\n    [replace, push, pathWithoutLocale, onChange]\n  );\n\n  const reactLocaleHook = useLocaleReact({\n    onLocaleChange: redirectionFunction,\n  });\n\n  return {\n    ...reactLocaleHook,\n    pathWithoutLocale,\n  };\n};\n"],"mappings":";;;;;;;;AAmBA,MAAM,6BAA6B;CACjC,MAAM,WAAW,aAAa;CAC9B,MAAM,CAAC,UAAU,eAAe,SAAS,SAAS;AAElD,iBAAgB;EAEd,MAAM,SAAS,OAAO,WAAW,cAAc,OAAO,SAAS,SAAS;AACxE,cAAY,SAAS,GAAG,WAAW,WAAW,SAAS;IACtD,CAAC,SAAS,CAAC;AAGd,QAAO,cAAc,qBAAqB,SAAS,EAAE,CAAC,SAAS,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BlE,MAAa,aAAa,EAAE,WAAW,cAA8B,EAAE,KAAK;CAC1E,MAAM,EAAE,SAAS,SAAS,WAAW;CACrC,MAAM,oBAAoB,sBAAsB;AA2BhD,QAAO;EACL,GALsBA,YAAe,EACrC,gBAtB0B,aACzB,WAA4B;AAC3B,OAAI,CAAC,SAAU;GAEf,MAAM,iBAAiB,gBAAgB,mBAAmB,OAAO;AAEjE,OAAI,OAAO,aAAa,YAAY;AAClC,aAAS;KAAE;KAAQ,MAAM;KAAgB,CAAC;AAC1C;;AAGF,OAAI,aAAa,UACf,SAAQ,eAAe;AAEzB,OAAI,aAAa,OACf,MAAK,eAAe;KAGxB;GAAC;GAAS;GAAM;GAAmB;GAAS,CAC7C,EAIA,CAAC;EAIA;EACD"}

package/dist/esm/client/useLocalePageRouter.mjs

@@ -1,2 +1,44 @@
-"use client";import{useLocale as e}from"react-intlayer";import{getLocalizedUrl as t,getPathWithoutLocale as n}from"@intlayer/core/localization";import{useCallback as r,useMemo as i}from"react";import{useRouter as a}from"next/router.js";const o=()=>{let{push:o,pathname:s,reload:c}=a(),l=i(()=>n(s),[s]);return{...e({onLocaleChange:r(e=>(o(t(l,e)),c()),[l])}),pathWithoutLocale:l}};export{o as useLocalePageRouter};
+'use client';
+
+import { useLocale } from "react-intlayer";
+import { getLocalizedUrl, getPathWithoutLocale } from "@intlayer/core/localization";
+import { useCallback, useMemo } from "react";
+import { useRouter } from "next/router.js";
+
+//#region src/client/useLocalePageRouter.ts
+/**
+* Hook to manage the current locale in Next.js Page Router.
+*
+* This hook provides locale management functionality tailored for the Next.js Page Router,
+* handling redirections and page reloads upon locale changes.
+*
+* @returns An object containing the current locale, path without locale, and functions to update the locale.
+*
+* @example
+* ```tsx
+* import { useLocalePageRouter } from 'next-intlayer';
+*
+* const MyComponent = () => {
+*   const { setLocale } = useLocalePageRouter();
+*
+*   return (
+*     <button onClick={() => setLocale('fr')}>Switch to French</button>
+*   );
+* };
+* ```
+*/
+const useLocalePageRouter = () => {
+	const { push, pathname, reload } = useRouter();
+	const pathWithoutLocale = useMemo(() => getPathWithoutLocale(pathname), [pathname]);
+	return {
+		...useLocale({ onLocaleChange: useCallback((locale) => {
+			push(getLocalizedUrl(pathWithoutLocale, locale));
+			return reload();
+		}, [pathWithoutLocale]) }),
+		pathWithoutLocale
+	};
+};
+
+//#endregion
+export { useLocalePageRouter };
 //# sourceMappingURL=useLocalePageRouter.mjs.map

package/dist/esm/client/useLocalePageRouter.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"useLocalePageRouter.mjs","names":["useLocaleReact"],"sources":["../../../src/client/useLocalePageRouter.ts"],"sourcesContent":["'use client';\n\nimport {\n  getLocalizedUrl,\n  getPathWithoutLocale,\n} from '@intlayer/core/localization';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport { useRouter } from 'next/router.js';\nimport { useCallback, useMemo } from 'react';\nimport { useLocale as useLocaleReact } from 'react-intlayer';\n\n/**\n * Hook to manage the current locale in Next.js Page Router.\n *\n * This hook provides locale management functionality tailored for the Next.js Page Router,\n * handling redirections and page reloads upon locale changes.\n *\n * @returns An object containing the current locale, path without locale, and functions to update the locale.\n *\n * @example\n * ```tsx\n * import { useLocalePageRouter } from 'next-intlayer';\n *\n * const MyComponent = () => {\n *   const { setLocale } = useLocalePageRouter();\n *\n *   return (\n *     <button onClick={() => setLocale('fr')}>Switch to French</button>\n *   );\n * };\n * ```\n */\nexport const useLocalePageRouter = () => {\n  const { push, pathname, reload } = useRouter();\n  const pathWithoutLocale = useMemo(\n    () => getPathWithoutLocale(pathname),\n    [pathname]\n  );\n\n  const redirectionFunction = useCallback(\n    (locale: LocalesValues) => {\n      const pathWithLocale = getLocalizedUrl(pathWithoutLocale, locale);\n\n      push(pathWithLocale);\n\n      return reload();\n    },\n    [pathWithoutLocale]\n  );\n\n  const reactLocaleHook = useLocaleReact({\n    onLocaleChange: redirectionFunction,\n  });\n\n  return {\n    ...reactLocaleHook,\n    pathWithoutLocale,\n  };\n};\n"],"mappings":"4OAgCA,MAAa,MAA4B,CACvC,GAAM,CAAE,OAAM,WAAU,UAAW,GAAW,CACxC,EAAoB,MAClB,EAAqB,EAAS,CACpC,CAAC,EAAS,CACX,CAiBD,MAAO,CACL,GALsBA,EAAe,CACrC,eAZ0B,EACzB,IAGC,EAFuB,EAAgB,EAAmB,EAAO,CAE7C,CAEb,GAAQ,EAEjB,CAAC,EAAkB,CACpB,CAIA,CAAC,CAIA,oBACD"}
+{"version":3,"file":"useLocalePageRouter.mjs","names":["useLocaleReact"],"sources":["../../../src/client/useLocalePageRouter.ts"],"sourcesContent":["'use client';\n\nimport {\n  getLocalizedUrl,\n  getPathWithoutLocale,\n} from '@intlayer/core/localization';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport { useRouter } from 'next/router.js';\nimport { useCallback, useMemo } from 'react';\nimport { useLocale as useLocaleReact } from 'react-intlayer';\n\n/**\n * Hook to manage the current locale in Next.js Page Router.\n *\n * This hook provides locale management functionality tailored for the Next.js Page Router,\n * handling redirections and page reloads upon locale changes.\n *\n * @returns An object containing the current locale, path without locale, and functions to update the locale.\n *\n * @example\n * ```tsx\n * import { useLocalePageRouter } from 'next-intlayer';\n *\n * const MyComponent = () => {\n *   const { setLocale } = useLocalePageRouter();\n *\n *   return (\n *     <button onClick={() => setLocale('fr')}>Switch to French</button>\n *   );\n * };\n * ```\n */\nexport const useLocalePageRouter = () => {\n  const { push, pathname, reload } = useRouter();\n  const pathWithoutLocale = useMemo(\n    () => getPathWithoutLocale(pathname),\n    [pathname]\n  );\n\n  const redirectionFunction = useCallback(\n    (locale: LocalesValues) => {\n      const pathWithLocale = getLocalizedUrl(pathWithoutLocale, locale);\n\n      push(pathWithLocale);\n\n      return reload();\n    },\n    [pathWithoutLocale]\n  );\n\n  const reactLocaleHook = useLocaleReact({\n    onLocaleChange: redirectionFunction,\n  });\n\n  return {\n    ...reactLocaleHook,\n    pathWithoutLocale,\n  };\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCA,MAAa,4BAA4B;CACvC,MAAM,EAAE,MAAM,UAAU,WAAW,WAAW;CAC9C,MAAM,oBAAoB,cAClB,qBAAqB,SAAS,EACpC,CAAC,SAAS,CACX;AAiBD,QAAO;EACL,GALsBA,UAAe,EACrC,gBAZ0B,aACzB,WAA0B;AAGzB,QAFuB,gBAAgB,mBAAmB,OAAO,CAE7C;AAEpB,UAAO,QAAQ;KAEjB,CAAC,kBAAkB,CACpB,EAIA,CAAC;EAIA;EACD"}

package/dist/esm/client/useRewriteURL.mjs

@@ -1 +1,5 @@
-"use client";import{useRewriteURL as e}from"react-intlayer";export{e as useRewriteURL};
+'use client';
+
+import { useRewriteURL } from "react-intlayer";
+
+export { useRewriteURL };

package/dist/esm/generateStaticParams.mjs

@@ -1,2 +1,27 @@
-import e from"@intlayer/config/built";const{locales:t}=e.internationalization,n=()=>t.map(e=>({locale:e}));export{n as generateStaticParams};
+import configuration from "@intlayer/config/built";
+
+//#region src/generateStaticParams.ts
+const { locales } = configuration.internationalization;
+/**
+* Generates static parameters for Next.js's dynamic routes based on the configured locales.
+*
+* This function is typically used in Next.js App Router for `generateStaticParams`
+* to ensure all supported locales are pre-rendered at build time.
+*
+* @returns An array of objects containing the `locale` parameter for each configured locale.
+*
+* @example
+* ```tsx
+* // app/[locale]/layout.tsx
+* export { generateStaticParams } from 'next-intlayer';
+*
+* export default async function RootLayout({ children, params }) {
+*   // ...
+* }
+* ```
+*/
+const generateStaticParams = () => locales.map((locale) => ({ locale }));
+
+//#endregion
+export { generateStaticParams };
 //# sourceMappingURL=generateStaticParams.mjs.map

package/dist/esm/generateStaticParams.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"generateStaticParams.mjs","names":[],"sources":["../../src/generateStaticParams.ts"],"sourcesContent":["import configuration from '@intlayer/config/built';\n\nconst { locales } = configuration.internationalization;\n\n/**\n * Generates static parameters for Next.js's dynamic routes based on the configured locales.\n *\n * This function is typically used in Next.js App Router for `generateStaticParams`\n * to ensure all supported locales are pre-rendered at build time.\n *\n * @returns An array of objects containing the `locale` parameter for each configured locale.\n *\n * @example\n * ```tsx\n * // app/[locale]/layout.tsx\n * export { generateStaticParams } from 'next-intlayer';\n *\n * export default async function RootLayout({ children, params }) {\n *   // ...\n * }\n * ```\n */\nexport const generateStaticParams = () => locales.map((locale) => ({ locale }));\n"],"mappings":"sCAEA,KAAM,CAAE,WAAY,EAAc,qBAoBrB,MAA6B,EAAQ,IAAK,IAAY,CAAE,SAAQ,EAAE"}
+{"version":3,"file":"generateStaticParams.mjs","names":[],"sources":["../../src/generateStaticParams.ts"],"sourcesContent":["import configuration from '@intlayer/config/built';\n\nconst { locales } = configuration.internationalization;\n\n/**\n * Generates static parameters for Next.js's dynamic routes based on the configured locales.\n *\n * This function is typically used in Next.js App Router for `generateStaticParams`\n * to ensure all supported locales are pre-rendered at build time.\n *\n * @returns An array of objects containing the `locale` parameter for each configured locale.\n *\n * @example\n * ```tsx\n * // app/[locale]/layout.tsx\n * export { generateStaticParams } from 'next-intlayer';\n *\n * export default async function RootLayout({ children, params }) {\n *   // ...\n * }\n * ```\n */\nexport const generateStaticParams = () => locales.map((locale) => ({ locale }));\n"],"mappings":";;;AAEA,MAAM,EAAE,YAAY,cAAc;;;;;;;;;;;;;;;;;;;AAoBlC,MAAa,6BAA6B,QAAQ,KAAK,YAAY,EAAE,QAAQ,EAAE"}

package/dist/esm/index.mjs

@@ -1 +1,8 @@
-import{IntlayerClientProvider as e}from"./client/IntlayerClientProvider.mjs";import{useLocale as t}from"./client/useLocale.mjs";import{useLocalePageRouter as n}from"./client/useLocalePageRouter.mjs";import{useRewriteURL as r}from"./client/useRewriteURL.mjs";import{generateStaticParams as i}from"./generateStaticParams.mjs";import{IntlayerClientContext as a,MarkdownProvider as o,MarkdownRenderer as s,getDictionary as c,getIntlayer as l,localeCookie as u,localeInStorage as d,setLocaleCookie as f,setLocaleInStorage as p,t as m,useDictionary as h,useDictionaryAsync as g,useDictionaryDynamic as _,useI18n as v,useIntl as y,useIntlayer as b,useLoadDynamic as x,useLocaleCookie as S,useLocaleStorage as C}from"react-intlayer";export{a as IntlayerClientContext,e as IntlayerClientProvider,o as MarkdownProvider,s as MarkdownRenderer,i as generateStaticParams,c as getDictionary,l as getIntlayer,u as localeCookie,d as localeInStorage,f as setLocaleCookie,p as setLocaleInStorage,m as t,h as useDictionary,g as useDictionaryAsync,_ as useDictionaryDynamic,v as useI18n,y as useIntl,b as useIntlayer,x as useLoadDynamic,t as useLocale,S as useLocaleCookie,n as useLocalePageRouter,C as useLocaleStorage,r as useRewriteURL};
+import { IntlayerClientProvider } from "./client/IntlayerClientProvider.mjs";
+import { useLocale } from "./client/useLocale.mjs";
+import { useLocalePageRouter } from "./client/useLocalePageRouter.mjs";
+import { useRewriteURL } from "./client/useRewriteURL.mjs";
+import { generateStaticParams } from "./generateStaticParams.mjs";
+import { IntlayerClientContext, MarkdownProvider, MarkdownRenderer, getDictionary, getIntlayer, localeCookie, localeInStorage, setLocaleCookie, setLocaleInStorage, t, useDictionary, useDictionaryAsync, useDictionaryDynamic, useI18n, useIntl, useIntlayer, useLoadDynamic, useLocaleCookie, useLocaleStorage } from "react-intlayer";
+
+export { IntlayerClientContext, IntlayerClientProvider, MarkdownProvider, MarkdownRenderer, generateStaticParams, getDictionary, getIntlayer, localeCookie, localeInStorage, setLocaleCookie, setLocaleInStorage, t, useDictionary, useDictionaryAsync, useDictionaryDynamic, useI18n, useIntl, useIntlayer, useLoadDynamic, useLocale, useLocaleCookie, useLocalePageRouter, useLocaleStorage, useRewriteURL };

package/dist/esm/proxy/index.mjs

@@ -1 +1,5 @@
-import{localeDetector as e}from"./localeDetector.mjs";import{intlayerProxy as t}from"./intlayerProxy.mjs";import{multipleProxies as n}from"./multipleProxies.mjs";export{t as intlayerProxy,e as localeDetector,n as multipleProxies};
+import { localeDetector } from "./localeDetector.mjs";
+import { intlayerProxy } from "./intlayerProxy.mjs";
+import { multipleProxies } from "./multipleProxies.mjs";
+
+export { intlayerProxy, localeDetector, multipleProxies };

package/dist/esm/proxy/intlayerProxy.mjs

@@ -1,2 +1,247 @@
-import{localeDetector as e}from"./localeDetector.mjs";import{getCanonicalPath as t,getLocalizedPath as n,getRewriteRules as r}from"@intlayer/core/localization";import i from"@intlayer/config/built";import{ROUTING_MODE as a}from"@intlayer/config/defaultValues";import{getLocaleFromStorage as o,setLocaleInStorage as s}from"@intlayer/core/utils";import{NextResponse as c}from"next/server";const{internationalization:l,routing:u}=i??{},{locales:d,defaultLocale:f}=l??{},{basePath:p,mode:m,rewrite:h}=u??{},g=m??a,_=g===`no-prefix`||g===`search-params`,v=g===`prefix-all`,y=!_,b=r(h,`url`),x=e=>{let t=e.headers.get(`purpose`),n=e.headers.get(`next-router-prefetch`),r=e.headers.get(`next-url`),i=e.headers.get(`x-nextjs-data`);return t===`prefetch`||n===`1`||!!r||!!i},S=(e,t)=>{if(g!==`search-params`)return e;let n=new URLSearchParams(e??``);return n.set(`locale`,t),`?${n.toString()}`},C=(e,t,n)=>{let r=e.nextUrl.pathname,i=w(e);return _?T(e,i,r):D(e,i,E(r),r)},w=e=>o({getCookie:t=>e.cookies.get(t)?.value??null,getHeader:t=>e.headers.get(t)??null}),T=(n,r,i)=>{let a=E(i);if(a){let e=t(i.slice(`/${a}`.length)||`/`,a,b),r=S(n.nextUrl.search,a);return N(n,r?`${e}${r}`:`${e}${n.nextUrl.search??``}`)}if(g===`search-params`){let a=new URLSearchParams(n.nextUrl.search).get(`locale`),o=d?.includes(a),s=r??(o?a:void 0)??r??e?.(n)??f;d?.includes(s)||(s=f);let c=t(i,s,b);if(a===s)return M(n,`${y?`/${s}${c}`:c}${n.nextUrl.search??``}`,s);let l=S(n.nextUrl.search,s);return N(n,l?`${i}${l}`:`${i}${n.nextUrl.search??``}`)}let o=r??e?.(n)??f;d?.includes(o)||(o=f);let s=t(i,o,b),c=y?`/${o}${s}`:s,l=S(n.nextUrl.search,o);return M(n,l?`${c}${l}`:`${c}${n.nextUrl.search??``}`,o)},E=e=>d.find(t=>e.startsWith(`/${t}/`)||e===`/${t}`),D=(e,t,n,r)=>n?k(e,n,r):x(e)?O(e,f,r):O(e,t,r),O=(r,i,a)=>{let o=i??e?.(r)??f;d.includes(o)||(o=f);let s=t(a,o,b),c=n(s,o,b),l=typeof c==`string`?c:c.path,u=j(o,l,p,S(r.nextUrl.search,o));return v||o!==f?N(r,u):M(r,y?`/${o}${s}`:s,o)},k=(e,r,i)=>{let a=i.slice(`/${r}`.length)||`/`,o=t(a,r,b),s=n(o,r,b),c=typeof s==`string`?s:s.path;if(typeof s!=`string`&&s.isRewritten&&c!==a)return N(e,j(r,c,p,S(e.nextUrl.search,r)));let l=y?`/${r}${o}`:o;if(!v&&r===f)return A(e,r,i);let u=e.nextUrl.search;return M(e,l+(u??``),r)},A=(e,t,r)=>{if(!v&&t===f){let i=n(r,t,b),a=typeof i==`string`?i:i.path,o=p.endsWith(`/`),s=a;return s.startsWith(`/`)&&(s=s.slice(1)),N(e,`${p}${o?``:`/`}${s}`+(S(e.nextUrl.search,t)??e.nextUrl.search??``))}let i=S(e.nextUrl.search,t),a=y?`/${t}${r}`:r;return M(e,i?`${a}${i}`:`${a}${e.nextUrl.search??``}`,t)},j=(e,t,n,r)=>{let i=t.startsWith(`/${e}`)?t.slice(`/${e}`.length)||`/`:t;if(g===`no-prefix`||g===`search-params`)return`${i}${r?`?${r}`:``}`;let a=t.startsWith(`/${e}`)?t:`${e}${t.startsWith(`/`)?``:`/`}${t}`;return`${n}${n.endsWith(`/`)?``:`/`}${a}`.replace(/\/+/g,`/`)},M=(e,t,n)=>{let r=e.nextUrl.search,i=r&&!t.includes(`?`)?`${t}${r}`:t,a=new Headers(e.headers);s(n,{setHeader:(e,t)=>{a.set(e,t)}});let o=new URL(i,e.url),l=o.href===e.nextUrl.href?c.next({request:{headers:a}}):c.rewrite(o,{request:{headers:a}});return s(n,{setHeader:(e,t)=>{l.headers.set(e,t)}}),l},N=(e,t)=>{let n=e.nextUrl.search,r=n&&!t.includes(`?`)?`${t}${n}`:t;return c.redirect(new URL(r,e.url))};export{C as intlayerProxy};
+import { localeDetector as localeDetector$1 } from "./localeDetector.mjs";
+import { getCanonicalPath, getLocalizedPath, getRewriteRules } from "@intlayer/core/localization";
+import configuration from "@intlayer/config/built";
+import { ROUTING_MODE } from "@intlayer/config/defaultValues";
+import { getLocaleFromStorage, setLocaleInStorage } from "@intlayer/core/utils";
+import { NextResponse } from "next/server";
+
+//#region src/proxy/intlayerProxy.ts
+const { internationalization, routing } = configuration ?? {};
+const { locales, defaultLocale } = internationalization ?? {};
+const { basePath, mode, rewrite } = routing ?? {};
+const effectiveMode = mode ?? ROUTING_MODE;
+const noPrefix = effectiveMode === "no-prefix" || effectiveMode === "search-params";
+const prefixDefault = effectiveMode === "prefix-all";
+const internalPrefix = !noPrefix;
+const rewriteRules = getRewriteRules(rewrite, "url");
+/**
+* Detects if the request is a prefetch request from Next.js.
+*
+* Next.js prefetch requests can be identified by several headers:
+* - purpose: 'prefetch' (standard prefetch header)
+* - next-router-prefetch: '1' (Next.js router prefetch)
+* - next-url: present (Next.js internal navigation)
+*
+* During prefetch, we should ignore cookie-based locale detection
+* to prevent unwanted redirects when users are switching locales.
+*
+* @param request - The incoming Next.js request object.
+* @returns - True if the request is a prefetch request, false otherwise.
+*/
+const isPrefetchRequest = (request) => {
+	const purpose = request.headers.get("purpose");
+	const nextRouterPrefetch = request.headers.get("next-router-prefetch");
+	const nextUrl = request.headers.get("next-url");
+	const xNextjsData = request.headers.get("x-nextjs-data");
+	return purpose === "prefetch" || nextRouterPrefetch === "1" || !!nextUrl || !!xNextjsData;
+};
+const appendLocaleSearchIfNeeded = (search, locale) => {
+	if (effectiveMode !== "search-params") return search;
+	const params = new URLSearchParams(search ?? "");
+	params.set("locale", locale);
+	return `?${params.toString()}`;
+};
+/**
+* Proxy that handles the internationalization layer
+*
+* Usage:
+*
+* ```ts
+* // ./src/proxy.ts
+*
+* export { intlayerProxy as proxy } from '@intlayer/next/proxy';
+*
+* // applies this proxy only to files in the app directory
+* export const config = {
+*   matcher: '/((?!api|static|.*\\..*|_next).*)',
+* };
+* ```
+*
+* Main proxy function for handling internationalization.
+*
+* @param request - The incoming Next.js request object.
+* @param event - The Next.js fetch event (optional).
+* @param response - The Next.js response object (optional).
+* @returns - The response to be returned to the client.
+*/
+const intlayerProxy = (request, _event, _response) => {
+	const pathname = request.nextUrl.pathname;
+	const localLocale = getLocalLocale(request);
+	if (noPrefix) return handleNoPrefix(request, localLocale, pathname);
+	return handlePrefix(request, localLocale, getPathLocale(pathname), pathname);
+};
+/**
+* Retrieves the locale from the request cookies if available and valid.
+*
+* @param request - The incoming Next.js request object.
+* @returns - The locale found in the cookies, or undefined if not found or invalid.
+*/
+const getLocalLocale = (request) => getLocaleFromStorage({
+	getCookie: (name) => request.cookies.get(name)?.value ?? null,
+	getHeader: (name) => request.headers.get(name) ?? null
+});
+/**
+* Handles the case where URLs do not have locale prefixes.
+*/
+const handleNoPrefix = (request, localLocale, pathname) => {
+	const pathLocale = getPathLocale(pathname);
+	if (pathLocale) {
+		const canonicalPath = getCanonicalPath(pathname.slice(`/${pathLocale}`.length) || "/", pathLocale, rewriteRules);
+		const search = appendLocaleSearchIfNeeded(request.nextUrl.search, pathLocale);
+		return redirectUrl(request, search ? `${canonicalPath}${search}` : `${canonicalPath}${request.nextUrl.search ?? ""}`);
+	}
+	if (effectiveMode === "search-params") {
+		const existingLocale = new URLSearchParams(request.nextUrl.search).get("locale");
+		const isExistingValid = locales?.includes(existingLocale);
+		let locale = localLocale ?? (isExistingValid ? existingLocale : void 0) ?? localLocale ?? localeDetector$1?.(request) ?? defaultLocale;
+		if (!locales?.includes(locale)) locale = defaultLocale;
+		const canonicalPath = getCanonicalPath(pathname, locale, rewriteRules);
+		if (existingLocale === locale) return rewriteUrl(request, `${internalPrefix ? `/${locale}${canonicalPath}` : canonicalPath}${request.nextUrl.search ?? ""}`, locale);
+		const search = appendLocaleSearchIfNeeded(request.nextUrl.search, locale);
+		return redirectUrl(request, search ? `${pathname}${search}` : `${pathname}${request.nextUrl.search ?? ""}`);
+	}
+	let locale = localLocale ?? localeDetector$1?.(request) ?? defaultLocale;
+	if (!locales?.includes(locale)) locale = defaultLocale;
+	const canonicalPath = getCanonicalPath(pathname, locale, rewriteRules);
+	const internalPath = internalPrefix ? `/${locale}${canonicalPath}` : canonicalPath;
+	const search = appendLocaleSearchIfNeeded(request.nextUrl.search, locale);
+	return rewriteUrl(request, search ? `${internalPath}${search}` : `${internalPath}${request.nextUrl.search ?? ""}`, locale);
+};
+/**
+* Extracts the locale from the URL pathname if present.
+*
+* @param pathname - The pathname from the request URL.
+* @returns - The locale found in the pathname, or undefined if not found.
+*/
+const getPathLocale = (pathname) => locales.find((locale) => pathname.startsWith(`/${locale}/`) || pathname === `/${locale}`);
+/**
+* Handles the case where URLs have locale prefixes.
+*
+* @param request - The incoming Next.js request object.
+* @param localLocale - The locale from the cookie.
+* @param pathLocale - The locale extracted from the pathname.
+* @param pathname - The pathname from the request URL.
+* @param basePathTrailingSlash - Indicates if the basePath ends with a slash.
+* @returns - The response to be returned to the client.
+*/
+const handlePrefix = (request, localLocale, pathLocale, pathname) => {
+	if (!pathLocale) {
+		if (isPrefetchRequest(request) && true) return handleMissingPathLocale(request, defaultLocale, pathname);
+		return handleMissingPathLocale(request, localLocale, pathname);
+	}
+	return handleExistingPathLocale(request, pathLocale, pathname);
+};
+/**
+* Handles requests where the locale is missing from the URL pathname.
+*
+* @param request - The incoming Next.js request object.
+* @param localLocale - The locale from the cookie.
+* @param pathname - The pathname from the request URL.
+* @param basePathTrailingSlash - Indicates if the basePath ends with a slash.
+* @returns - The response to be returned to the client.
+*/
+const handleMissingPathLocale = (request, localLocale, pathname) => {
+	let locale = localLocale ?? localeDetector$1?.(request) ?? defaultLocale;
+	if (!locales.includes(locale)) locale = defaultLocale;
+	const canonicalPath = getCanonicalPath(pathname, locale, rewriteRules);
+	const targetLocalizedPathResult = getLocalizedPath(canonicalPath, locale, rewriteRules);
+	const targetLocalizedPath = typeof targetLocalizedPathResult === "string" ? targetLocalizedPathResult : targetLocalizedPathResult.path;
+	const newPath = constructPath(locale, targetLocalizedPath, basePath, appendLocaleSearchIfNeeded(request.nextUrl.search, locale));
+	return prefixDefault || locale !== defaultLocale ? redirectUrl(request, newPath) : rewriteUrl(request, internalPrefix ? `/${locale}${canonicalPath}` : canonicalPath, locale);
+};
+/**
+* Handles requests where the locale exists in the URL pathname.
+*
+* @param request - The incoming Next.js request object.
+* @param localLocale - The locale from the cookie.
+* @param pathLocale - The locale extracted from the pathname.
+* @param pathname - The pathname from the request URL.
+* @returns - The response to be returned to the client.
+*/
+const handleExistingPathLocale = (request, pathLocale, pathname) => {
+	const rawPath = pathname.slice(`/${pathLocale}`.length) || "/";
+	const canonicalPath = getCanonicalPath(rawPath, pathLocale, rewriteRules);
+	const targetLocalizedPathResult = getLocalizedPath(canonicalPath, pathLocale, rewriteRules);
+	const targetLocalizedPath = typeof targetLocalizedPathResult === "string" ? targetLocalizedPathResult : targetLocalizedPathResult.path;
+	if ((typeof targetLocalizedPathResult === "string" ? false : targetLocalizedPathResult.isRewritten) && targetLocalizedPath !== rawPath) return redirectUrl(request, constructPath(pathLocale, targetLocalizedPath, basePath, appendLocaleSearchIfNeeded(request.nextUrl.search, pathLocale)));
+	const internalUrl = internalPrefix ? `/${pathLocale}${canonicalPath}` : canonicalPath;
+	if (!prefixDefault && pathLocale === defaultLocale) return handleDefaultLocaleRedirect(request, pathLocale, pathname);
+	const search = request.nextUrl.search;
+	return rewriteUrl(request, internalUrl + (search ?? ""), pathLocale);
+};
+/**
+* Handles the scenario where the locale in the cookie does not match the locale in the URL pathname.
+*
+* @param request - The incoming Next.js request object.
+* @param pathname - The pathname from the request URL.
+* @param pathLocale - The locale extracted from the pathname.
+* @param localLocale - The locale from the cookie.
+* @param basePath - The base path of the application.
+* @returns - The new URL path with the correct locale.
+*/
+/**
+* The key fix for 404s without [locale] folders
+*/
+const handleDefaultLocaleRedirect = (request, pathLocale, canonicalPath) => {
+	if (!prefixDefault && pathLocale === defaultLocale) {
+		const targetLocalizedPathResult = getLocalizedPath(canonicalPath, pathLocale, rewriteRules);
+		const targetLocalizedPath = typeof targetLocalizedPathResult === "string" ? targetLocalizedPathResult : targetLocalizedPathResult.path;
+		const basePathTrailingSlash = basePath.endsWith("/");
+		let finalPath = targetLocalizedPath;
+		if (finalPath.startsWith("/")) finalPath = finalPath.slice(1);
+		return redirectUrl(request, `${basePath}${basePathTrailingSlash ? "" : "/"}${finalPath}` + (appendLocaleSearchIfNeeded(request.nextUrl.search, pathLocale) ?? request.nextUrl.search ?? ""));
+	}
+	const searchWithLocale = appendLocaleSearchIfNeeded(request.nextUrl.search, pathLocale);
+	const internalPath = internalPrefix ? `/${pathLocale}${canonicalPath}` : canonicalPath;
+	return rewriteUrl(request, searchWithLocale ? `${internalPath}${searchWithLocale}` : `${internalPath}${request.nextUrl.search ?? ""}`, pathLocale);
+};
+/**
+* Constructs a new path by combining the locale, path, basePath, and search parameters.
+*
+* @param locale - The locale to include in the path.
+* @param path - The original path from the request.
+* @param basePath - The base path of the application.
+* @param [search] - The query string from the request URL (optional).
+* @returns - The constructed new path.
+*/
+const constructPath = (locale, path, basePath, search) => {
+	const pathWithoutPrefix = path.startsWith(`/${locale}`) ? path.slice(`/${locale}`.length) || "/" : path;
+	if (effectiveMode === "no-prefix" || effectiveMode === "search-params") return `${pathWithoutPrefix}${search ? `?${search}` : ""}`;
+	const pathWithLocalePrefix = path.startsWith(`/${locale}`) ? path : `${locale}${path.startsWith("/") ? "" : "/"}${path}`;
+	return `${basePath}${basePath.endsWith("/") ? "" : "/"}${pathWithLocalePrefix}`.replace(/\/+/g, "/");
+};
+/**
+* This handles the internal path Next.js sees.
+* To support optional [locale] folders, we need to decide if we
+* keep the locale prefix or strip it.
+*/
+const rewriteUrl = (request, newPath, locale) => {
+	const search = request.nextUrl.search;
+	const pathWithSearch = search && !newPath.includes("?") ? `${newPath}${search}` : newPath;
+	const requestHeaders = new Headers(request.headers);
+	setLocaleInStorage(locale, { setHeader: (name, value) => {
+		requestHeaders.set(name, value);
+	} });
+	const targetUrl = new URL(pathWithSearch, request.url);
+	const response = targetUrl.href === request.nextUrl.href ? NextResponse.next({ request: { headers: requestHeaders } }) : NextResponse.rewrite(targetUrl, { request: { headers: requestHeaders } });
+	setLocaleInStorage(locale, { setHeader: (name, value) => {
+		response.headers.set(name, value);
+	} });
+	return response;
+};
+/**
+* Redirects the request to the new path.
+*
+* @param request - The incoming Next.js request object.
+* @param newPath - The new path to redirect to.
+* @returns - The redirect response.
+*/
+const redirectUrl = (request, newPath) => {
+	const search = request.nextUrl.search;
+	const pathWithSearch = search && !newPath.includes("?") ? `${newPath}${search}` : newPath;
+	return NextResponse.redirect(new URL(pathWithSearch, request.url));
+};
+
+//#endregion
+export { intlayerProxy };
 //# sourceMappingURL=intlayerProxy.mjs.map

package/dist/esm/proxy/intlayerProxy.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"intlayerProxy.mjs","names":["localeDetector"],"sources":["../../../src/proxy/intlayerProxy.ts"],"sourcesContent":["import configuration from '@intlayer/config/built';\nimport { ROUTING_MODE } from '@intlayer/config/defaultValues';\nimport {\n  getCanonicalPath,\n  getLocalizedPath,\n  getRewriteRules,\n} from '@intlayer/core/localization';\nimport { getLocaleFromStorage, setLocaleInStorage } from '@intlayer/core/utils';\nimport type { Locale } from '@intlayer/types/allLocales';\nimport {\n  type NextFetchEvent,\n  type NextRequest,\n  NextResponse,\n} from 'next/server';\nimport { localeDetector } from './localeDetector';\n\n/**\n * Controls whether locale detection occurs during Next.js prefetch requests\n * - true: Detect and apply locale during prefetch\n * - false: Use default locale during prefetch (recommended)\n *\n * This setting affects how Next.js handles locale prefetching:\n *\n * Example scenario:\n * - User's browser language is 'fr'\n * - Current page is /fr/about\n * - Link prefetches /about\n *\n * With `detectLocaleOnPrefetchNoPrefix:true`\n * - Prefetch detects 'fr' locale from browser\n * - Redirects prefetch to /fr/about\n *\n * With `detectLocaleOnPrefetchNoPrefix:false` (default)\n * - Prefetch uses default locale\n * - Redirects prefetch to /en/about (assuming 'en' is default)\n *\n * When to use true:\n * - Your app uses non-localized internal links (e.g. <a href=\"/about\">)\n * - You want consistent locale detection behavior between regular and prefetch requests\n *\n * When to use false (default):\n * - Your app uses locale-prefixed links (e.g. <a href=\"/fr/about\">)\n * - You want to optimize prefetching performance\n * - You want to avoid potential redirect loops\n */\nconst DEFAULT_DETECT_LOCALE_ON_PREFETCH_NO_PREFIX = false;\n\nconst { internationalization, routing } = configuration ?? {};\nconst { locales, defaultLocale } = internationalization ?? {};\nconst { basePath, mode, rewrite } = routing ?? {};\n\n// Note: cookie names are resolved inside LocaleStorage based on configuration\n\n// Derived flags from routing.mode\nconst effectiveMode = mode ?? ROUTING_MODE;\nconst noPrefix =\n  effectiveMode === 'no-prefix' || effectiveMode === 'search-params';\nconst prefixDefault = effectiveMode === 'prefix-all';\n\nconst internalPrefix = !noPrefix;\n\nconst rewriteRules = getRewriteRules(rewrite, 'url');\n\n/**\n * Detects if the request is a prefetch request from Next.js.\n *\n * Next.js prefetch requests can be identified by several headers:\n * - purpose: 'prefetch' (standard prefetch header)\n * - next-router-prefetch: '1' (Next.js router prefetch)\n * - next-url: present (Next.js internal navigation)\n *\n * During prefetch, we should ignore cookie-based locale detection\n * to prevent unwanted redirects when users are switching locales.\n *\n * @param request - The incoming Next.js request object.\n * @returns - True if the request is a prefetch request, false otherwise.\n */\nconst isPrefetchRequest = (request: NextRequest): boolean => {\n  const purpose = request.headers.get('purpose');\n  const nextRouterPrefetch = request.headers.get('next-router-prefetch');\n  const nextUrl = request.headers.get('next-url');\n  const xNextjsData = request.headers.get('x-nextjs-data');\n\n  return (\n    purpose === 'prefetch' ||\n    nextRouterPrefetch === '1' ||\n    !!nextUrl ||\n    !!xNextjsData\n  );\n};\n\n// Ensure locale is reflected in search params when routing mode is 'search-params'\nconst appendLocaleSearchIfNeeded = (\n  search: string | undefined,\n  locale: Locale\n): string | undefined => {\n  if (effectiveMode !== 'search-params') return search;\n  const params = new URLSearchParams(search ?? '');\n  params.set('locale', locale);\n  return `?${params.toString()}`;\n};\n\n/**\n * Proxy that handles the internationalization layer\n *\n * Usage:\n *\n * ```ts\n * // ./src/proxy.ts\n *\n * export { intlayerProxy as proxy } from '@intlayer/next/proxy';\n *\n * // applies this proxy only to files in the app directory\n * export const config = {\n *   matcher: '/((?!api|static|.*\\\\..*|_next).*)',\n * };\n * ```\n *\n * Main proxy function for handling internationalization.\n *\n * @param request - The incoming Next.js request object.\n * @param event - The Next.js fetch event (optional).\n * @param response - The Next.js response object (optional).\n * @returns - The response to be returned to the client.\n */\nexport const intlayerProxy = (\n  request: NextRequest,\n  _event?: NextFetchEvent,\n  _response?: NextResponse\n): NextResponse => {\n  const pathname = request.nextUrl.pathname;\n\n  const localLocale = getLocalLocale(request);\n\n  if (noPrefix) {\n    return handleNoPrefix(request, localLocale, pathname);\n  }\n\n  const pathLocale = getPathLocale(pathname);\n  return handlePrefix(request, localLocale, pathLocale, pathname);\n};\n\n/**\n * Retrieves the locale from the request cookies if available and valid.\n *\n * @param request - The incoming Next.js request object.\n * @returns - The locale found in the cookies, or undefined if not found or invalid.\n */\nconst getLocalLocale = (request: NextRequest): Locale | undefined =>\n  getLocaleFromStorage({\n    getCookie: (name: string) => request.cookies.get(name)?.value ?? null,\n    getHeader: (name: string) => request.headers.get(name) ?? null,\n  });\n\n/**\n * Handles the case where URLs do not have locale prefixes.\n */\nconst handleNoPrefix = (\n  request: NextRequest,\n  localLocale: Locale | undefined,\n  pathname: string\n): NextResponse => {\n  const pathLocale = getPathLocale(pathname);\n\n  if (pathLocale) {\n    const pathWithoutLocale = pathname.slice(`/${pathLocale}`.length) || '/';\n\n    const canonicalPath = getCanonicalPath(\n      pathWithoutLocale,\n      pathLocale,\n      rewriteRules\n    );\n\n    const search = appendLocaleSearchIfNeeded(\n      request.nextUrl.search,\n      pathLocale\n    );\n\n    const redirectPath = search\n      ? `${canonicalPath}${search}`\n      : `${canonicalPath}${request.nextUrl.search ?? ''}`;\n\n    return redirectUrl(request, redirectPath);\n  }\n\n  if (effectiveMode === 'search-params') {\n    const existingSearchParams = new URLSearchParams(request.nextUrl.search);\n    const existingLocale = existingSearchParams.get('locale');\n\n    const isExistingValid = locales?.includes(existingLocale as Locale);\n\n    let locale = (localLocale ??\n      (isExistingValid ? (existingLocale as Locale) : undefined) ??\n      localLocale ??\n      localeDetector?.(request) ??\n      defaultLocale) as Locale;\n\n    if (!locales?.includes(locale as Locale)) {\n      locale = defaultLocale as Locale;\n    }\n\n    const canonicalPath = getCanonicalPath(\n      pathname,\n      locale as Locale,\n      rewriteRules\n    );\n\n    if (existingLocale === locale) {\n      const internalPath = internalPrefix\n        ? `/${locale}${canonicalPath}`\n        : canonicalPath;\n      const rewritePath = `${internalPath}${request.nextUrl.search ?? ''}`;\n      return rewriteUrl(request, rewritePath, locale as Locale);\n    }\n\n    const search = appendLocaleSearchIfNeeded(\n      request.nextUrl.search,\n      locale as Locale\n    );\n    // Use original pathname for redirect to preserve user's URL input, just adding params\n    const redirectPath = search\n      ? `${pathname}${search}`\n      : `${pathname}${request.nextUrl.search ?? ''}`;\n\n    return redirectUrl(request, redirectPath);\n  }\n\n  // effectiveMode === 'no-prefix'\n  let locale = (localLocale ??\n    localeDetector?.(request) ??\n    defaultLocale) as Locale;\n\n  if (!locales?.includes(locale as Locale)) {\n    locale = defaultLocale as Locale;\n  }\n\n  const canonicalPath = getCanonicalPath(\n    pathname,\n    locale as Locale,\n    rewriteRules\n  );\n\n  const internalPath = internalPrefix\n    ? `/${locale}${canonicalPath}`\n    : canonicalPath;\n  const search = appendLocaleSearchIfNeeded(\n    request.nextUrl.search,\n    locale as Locale\n  );\n  const rewritePath = search\n    ? `${internalPath}${search}`\n    : `${internalPath}${request.nextUrl.search ?? ''}`;\n\n  return rewriteUrl(request, rewritePath, locale as Locale);\n};\n\n/**\n * Extracts the locale from the URL pathname if present.\n *\n * @param pathname - The pathname from the request URL.\n * @returns - The locale found in the pathname, or undefined if not found.\n */\nconst getPathLocale = (pathname: string): Locale | undefined =>\n  (locales as Locale[]).find(\n    (locale) => pathname.startsWith(`/${locale}/`) || pathname === `/${locale}`\n  );\n\n/**\n * Handles the case where URLs have locale prefixes.\n *\n * @param request - The incoming Next.js request object.\n * @param localLocale - The locale from the cookie.\n * @param pathLocale - The locale extracted from the pathname.\n * @param pathname - The pathname from the request URL.\n * @param basePathTrailingSlash - Indicates if the basePath ends with a slash.\n * @returns - The response to be returned to the client.\n */\nconst handlePrefix = (\n  request: NextRequest,\n  localLocale: Locale | undefined,\n  pathLocale: Locale | undefined,\n  pathname: string\n): NextResponse => {\n  if (!pathLocale) {\n    const isPrefetch = isPrefetchRequest(request);\n    if (isPrefetch && !DEFAULT_DETECT_LOCALE_ON_PREFETCH_NO_PREFIX) {\n      return handleMissingPathLocale(\n        request,\n        defaultLocale as Locale,\n        pathname\n      );\n    }\n    return handleMissingPathLocale(request, localLocale, pathname);\n  }\n\n  return handleExistingPathLocale(request, pathLocale, pathname);\n};\n\n/**\n * Handles requests where the locale is missing from the URL pathname.\n *\n * @param request - The incoming Next.js request object.\n * @param localLocale - The locale from the cookie.\n * @param pathname - The pathname from the request URL.\n * @param basePathTrailingSlash - Indicates if the basePath ends with a slash.\n * @returns - The response to be returned to the client.\n */\nconst handleMissingPathLocale = (\n  request: NextRequest,\n  localLocale: Locale | undefined,\n  pathname: string\n): NextResponse => {\n  let locale = (localLocale ??\n    localeDetector?.(request) ??\n    defaultLocale) as Locale;\n\n  if (!(locales as Locale[]).includes(locale)) {\n    locale = defaultLocale as Locale;\n  }\n\n  // Resolve to canonical path.\n  // If user visits /a-propos (implied 'fr'), we resolve to /about\n  const canonicalPath = getCanonicalPath(pathname, locale, rewriteRules);\n\n  // Determine target localized path for redirection\n  // /about + 'fr' -> /a-propos\n  const targetLocalizedPathResult = getLocalizedPath(\n    canonicalPath,\n    locale,\n    rewriteRules\n  );\n  const targetLocalizedPath =\n    typeof targetLocalizedPathResult === 'string'\n      ? targetLocalizedPathResult\n      : targetLocalizedPathResult.path;\n\n  const newPath = constructPath(\n    locale,\n    targetLocalizedPath,\n    basePath as string,\n    appendLocaleSearchIfNeeded(request.nextUrl.search, locale)\n  );\n\n  return prefixDefault || locale !== defaultLocale\n    ? redirectUrl(request, newPath)\n    : rewriteUrl(\n        request,\n        internalPrefix ? `/${locale}${canonicalPath}` : canonicalPath,\n        locale\n      ); // Rewrite must use Canonical\n};\n\n/**\n * Handles requests where the locale exists in the URL pathname.\n *\n * @param request - The incoming Next.js request object.\n * @param localLocale - The locale from the cookie.\n * @param pathLocale - The locale extracted from the pathname.\n * @param pathname - The pathname from the request URL.\n * @returns - The response to be returned to the client.\n */\nconst handleExistingPathLocale = (\n  request: NextRequest,\n  pathLocale: Locale,\n  pathname: string\n): NextResponse => {\n  const rawPath = pathname.slice(`/${pathLocale}`.length) || '/';\n\n  // 1. Identify the Canonical Path (Internal Next.js path)\n  // Ex: /a-propos (from URL) -> /about (Canonical)\n  const canonicalPath = getCanonicalPath(rawPath, pathLocale, rewriteRules);\n\n  // By skipping the forced localLocale check, we allow the explicit pathLocale\n  // to take precedence, which correctly updates the header/cookie when navigating.\n\n  // Rewrite Logic\n  // We must rewrite to the Next.js internal structure: /[locale]/[canonicalPath]\n  // Ex: Rewrite /fr/a-propos -> /fr/about\n\n  // 2. Redirect to localized path if needed (Canonical -> Localized)\n  // Ex: /fr/about -> /fr/a-propos\n  const targetLocalizedPathResult = getLocalizedPath(\n    canonicalPath,\n    pathLocale,\n    rewriteRules\n  );\n  const targetLocalizedPath =\n    typeof targetLocalizedPathResult === 'string'\n      ? targetLocalizedPathResult\n      : targetLocalizedPathResult.path;\n  const isRewritten =\n    typeof targetLocalizedPathResult === 'string'\n      ? false\n      : targetLocalizedPathResult.isRewritten;\n\n  if (isRewritten && targetLocalizedPath !== rawPath) {\n    const newPath = constructPath(\n      pathLocale,\n      targetLocalizedPath,\n      basePath as string,\n      appendLocaleSearchIfNeeded(request.nextUrl.search, pathLocale)\n    );\n    return redirectUrl(request, newPath);\n  }\n\n  const internalUrl = internalPrefix\n    ? `/${pathLocale}${canonicalPath}`\n    : canonicalPath;\n\n  // Only handle redirect if we are strictly managing default locale prefixing\n  if (!prefixDefault && pathLocale === defaultLocale) {\n    return handleDefaultLocaleRedirect(request, pathLocale, pathname);\n  }\n\n  const search = request.nextUrl.search;\n  return rewriteUrl(request, internalUrl + (search ?? ''), pathLocale);\n};\n\n/**\n * Handles the scenario where the locale in the cookie does not match the locale in the URL pathname.\n *\n * @param request - The incoming Next.js request object.\n * @param pathname - The pathname from the request URL.\n * @param pathLocale - The locale extracted from the pathname.\n * @param localLocale - The locale from the cookie.\n * @param basePath - The base path of the application.\n * @returns - The new URL path with the correct locale.\n */\n// Function handleCookieLocaleMismatch was removed because the URL locale should take precedence over the stored locale.\n\n/**\n * The key fix for 404s without [locale] folders\n */\nconst handleDefaultLocaleRedirect = (\n  request: NextRequest,\n  pathLocale: Locale,\n  canonicalPath: string // Internal path (e.g. /about)\n): NextResponse => {\n  if (!prefixDefault && pathLocale === defaultLocale) {\n    // Redirect to remove prefix\n    // We use canonicalPath because in no-prefix default mode, the URL is usually just the path\n    // But wait, if we are in this function, the URL *has* a prefix.\n    // We want to redirect to /about (localized for EN).\n\n    const targetLocalizedPathResult = getLocalizedPath(\n      canonicalPath,\n      pathLocale,\n      rewriteRules\n    );\n    const targetLocalizedPath =\n      typeof targetLocalizedPathResult === 'string'\n        ? targetLocalizedPathResult\n        : targetLocalizedPathResult.path;\n\n    // Construct path without prefix\n    const basePathTrailingSlash = (basePath as string).endsWith('/');\n    let finalPath = targetLocalizedPath;\n    if (finalPath.startsWith('/')) finalPath = finalPath.slice(1);\n\n    const fullPath = `${basePath}${basePathTrailingSlash ? '' : '/'}${finalPath}`;\n\n    const searchWithLocale = appendLocaleSearchIfNeeded(\n      request.nextUrl.search,\n      pathLocale\n    );\n\n    return redirectUrl(\n      request,\n      fullPath + (searchWithLocale ?? request.nextUrl.search ?? '')\n    );\n  }\n\n  const searchWithLocale = appendLocaleSearchIfNeeded(\n    request.nextUrl.search,\n    pathLocale\n  );\n\n  // If no redirect needed, we rewrite to the internal canonical path\n  const internalPath = internalPrefix\n    ? `/${pathLocale}${canonicalPath}`\n    : canonicalPath;\n\n  const rewriteTarget = searchWithLocale\n    ? `${internalPath}${searchWithLocale}`\n    : `${internalPath}${request.nextUrl.search ?? ''}`;\n\n  return rewriteUrl(request, rewriteTarget, pathLocale);\n};\n\n/**\n * Constructs a new path by combining the locale, path, basePath, and search parameters.\n *\n * @param locale - The locale to include in the path.\n * @param path - The original path from the request.\n * @param basePath - The base path of the application.\n * @param [search] - The query string from the request URL (optional).\n * @returns - The constructed new path.\n */\nconst constructPath = (\n  locale: Locale,\n  path: string,\n  basePath: string,\n  search?: string\n): string => {\n  // Remove existing locale prefix from path if it was passed by mistake,\n  // though we usually pass localized paths here now.\n  const pathWithoutPrefix = path.startsWith(`/${locale}`)\n    ? path.slice(`/${locale}`.length) || '/'\n    : path;\n\n  if (effectiveMode === 'no-prefix' || effectiveMode === 'search-params') {\n    return `${pathWithoutPrefix}${search ? `?${search}` : ''}`;\n  }\n\n  // Prefix handling\n  const pathWithLocalePrefix = path.startsWith(`/${locale}`)\n    ? path\n    : `${locale}${path.startsWith('/') ? '' : '/'}${path}`;\n\n  const basePathTrailingSlash = basePath.endsWith('/');\n  const newPath = `${basePath}${basePathTrailingSlash ? '' : '/'}${pathWithLocalePrefix}`;\n\n  // Clean double slashes\n  const cleanPath = newPath.replace(/\\/+/g, '/');\n\n  return cleanPath;\n};\n\n/**\n * This handles the internal path Next.js sees.\n * To support optional [locale] folders, we need to decide if we\n * keep the locale prefix or strip it.\n */\nconst rewriteUrl = (\n  request: NextRequest,\n  newPath: string,\n  locale: Locale\n): NextResponse => {\n  const search = request.nextUrl.search;\n  const pathWithSearch =\n    search && !newPath.includes('?') ? `${newPath}${search}` : newPath;\n\n  const requestHeaders = new Headers(request.headers);\n  setLocaleInStorage(locale, {\n    setHeader: (name: string, value: string) => {\n      requestHeaders.set(name, value);\n    },\n  });\n\n  const targetUrl = new URL(pathWithSearch, request.url);\n\n  // If the target URL is exactly the current request URL,\n  // we just want to `next()` to avoid losing headers on a redundant rewrite.\n  const response =\n    targetUrl.href === request.nextUrl.href\n      ? NextResponse.next({\n          request: {\n            headers: requestHeaders,\n          },\n        })\n      : NextResponse.rewrite(targetUrl, {\n          request: {\n            headers: requestHeaders,\n          },\n        });\n\n  setLocaleInStorage(locale, {\n    setHeader: (name: string, value: string) => {\n      response.headers.set(name, value);\n    },\n  });\n  return response;\n};\n\n/**\n * Redirects the request to the new path.\n *\n * @param request - The incoming Next.js request object.\n * @param newPath - The new path to redirect to.\n * @returns - The redirect response.\n */\nconst redirectUrl = (request: NextRequest, newPath: string): NextResponse => {\n  const search = request.nextUrl.search;\n  const pathWithSearch =\n    search && !newPath.includes('?') ? `${newPath}${search}` : newPath;\n\n  return NextResponse.redirect(new URL(pathWithSearch, request.url));\n};\n"],"mappings":"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"}
+{"version":3,"file":"intlayerProxy.mjs","names":["localeDetector"],"sources":["../../../src/proxy/intlayerProxy.ts"],"sourcesContent":["import configuration from '@intlayer/config/built';\nimport { ROUTING_MODE } from '@intlayer/config/defaultValues';\nimport {\n  getCanonicalPath,\n  getLocalizedPath,\n  getRewriteRules,\n} from '@intlayer/core/localization';\nimport { getLocaleFromStorage, setLocaleInStorage } from '@intlayer/core/utils';\nimport type { Locale } from '@intlayer/types/allLocales';\nimport {\n  type NextFetchEvent,\n  type NextRequest,\n  NextResponse,\n} from 'next/server';\nimport { localeDetector } from './localeDetector';\n\n/**\n * Controls whether locale detection occurs during Next.js prefetch requests\n * - true: Detect and apply locale during prefetch\n * - false: Use default locale during prefetch (recommended)\n *\n * This setting affects how Next.js handles locale prefetching:\n *\n * Example scenario:\n * - User's browser language is 'fr'\n * - Current page is /fr/about\n * - Link prefetches /about\n *\n * With `detectLocaleOnPrefetchNoPrefix:true`\n * - Prefetch detects 'fr' locale from browser\n * - Redirects prefetch to /fr/about\n *\n * With `detectLocaleOnPrefetchNoPrefix:false` (default)\n * - Prefetch uses default locale\n * - Redirects prefetch to /en/about (assuming 'en' is default)\n *\n * When to use true:\n * - Your app uses non-localized internal links (e.g. <a href=\"/about\">)\n * - You want consistent locale detection behavior between regular and prefetch requests\n *\n * When to use false (default):\n * - Your app uses locale-prefixed links (e.g. <a href=\"/fr/about\">)\n * - You want to optimize prefetching performance\n * - You want to avoid potential redirect loops\n */\nconst DEFAULT_DETECT_LOCALE_ON_PREFETCH_NO_PREFIX = false;\n\nconst { internationalization, routing } = configuration ?? {};\nconst { locales, defaultLocale } = internationalization ?? {};\nconst { basePath, mode, rewrite } = routing ?? {};\n\n// Note: cookie names are resolved inside LocaleStorage based on configuration\n\n// Derived flags from routing.mode\nconst effectiveMode = mode ?? ROUTING_MODE;\nconst noPrefix =\n  effectiveMode === 'no-prefix' || effectiveMode === 'search-params';\nconst prefixDefault = effectiveMode === 'prefix-all';\n\nconst internalPrefix = !noPrefix;\n\nconst rewriteRules = getRewriteRules(rewrite, 'url');\n\n/**\n * Detects if the request is a prefetch request from Next.js.\n *\n * Next.js prefetch requests can be identified by several headers:\n * - purpose: 'prefetch' (standard prefetch header)\n * - next-router-prefetch: '1' (Next.js router prefetch)\n * - next-url: present (Next.js internal navigation)\n *\n * During prefetch, we should ignore cookie-based locale detection\n * to prevent unwanted redirects when users are switching locales.\n *\n * @param request - The incoming Next.js request object.\n * @returns - True if the request is a prefetch request, false otherwise.\n */\nconst isPrefetchRequest = (request: NextRequest): boolean => {\n  const purpose = request.headers.get('purpose');\n  const nextRouterPrefetch = request.headers.get('next-router-prefetch');\n  const nextUrl = request.headers.get('next-url');\n  const xNextjsData = request.headers.get('x-nextjs-data');\n\n  return (\n    purpose === 'prefetch' ||\n    nextRouterPrefetch === '1' ||\n    !!nextUrl ||\n    !!xNextjsData\n  );\n};\n\n// Ensure locale is reflected in search params when routing mode is 'search-params'\nconst appendLocaleSearchIfNeeded = (\n  search: string | undefined,\n  locale: Locale\n): string | undefined => {\n  if (effectiveMode !== 'search-params') return search;\n  const params = new URLSearchParams(search ?? '');\n  params.set('locale', locale);\n  return `?${params.toString()}`;\n};\n\n/**\n * Proxy that handles the internationalization layer\n *\n * Usage:\n *\n * ```ts\n * // ./src/proxy.ts\n *\n * export { intlayerProxy as proxy } from '@intlayer/next/proxy';\n *\n * // applies this proxy only to files in the app directory\n * export const config = {\n *   matcher: '/((?!api|static|.*\\\\..*|_next).*)',\n * };\n * ```\n *\n * Main proxy function for handling internationalization.\n *\n * @param request - The incoming Next.js request object.\n * @param event - The Next.js fetch event (optional).\n * @param response - The Next.js response object (optional).\n * @returns - The response to be returned to the client.\n */\nexport const intlayerProxy = (\n  request: NextRequest,\n  _event?: NextFetchEvent,\n  _response?: NextResponse\n): NextResponse => {\n  const pathname = request.nextUrl.pathname;\n\n  const localLocale = getLocalLocale(request);\n\n  if (noPrefix) {\n    return handleNoPrefix(request, localLocale, pathname);\n  }\n\n  const pathLocale = getPathLocale(pathname);\n  return handlePrefix(request, localLocale, pathLocale, pathname);\n};\n\n/**\n * Retrieves the locale from the request cookies if available and valid.\n *\n * @param request - The incoming Next.js request object.\n * @returns - The locale found in the cookies, or undefined if not found or invalid.\n */\nconst getLocalLocale = (request: NextRequest): Locale | undefined =>\n  getLocaleFromStorage({\n    getCookie: (name: string) => request.cookies.get(name)?.value ?? null,\n    getHeader: (name: string) => request.headers.get(name) ?? null,\n  });\n\n/**\n * Handles the case where URLs do not have locale prefixes.\n */\nconst handleNoPrefix = (\n  request: NextRequest,\n  localLocale: Locale | undefined,\n  pathname: string\n): NextResponse => {\n  const pathLocale = getPathLocale(pathname);\n\n  if (pathLocale) {\n    const pathWithoutLocale = pathname.slice(`/${pathLocale}`.length) || '/';\n\n    const canonicalPath = getCanonicalPath(\n      pathWithoutLocale,\n      pathLocale,\n      rewriteRules\n    );\n\n    const search = appendLocaleSearchIfNeeded(\n      request.nextUrl.search,\n      pathLocale\n    );\n\n    const redirectPath = search\n      ? `${canonicalPath}${search}`\n      : `${canonicalPath}${request.nextUrl.search ?? ''}`;\n\n    return redirectUrl(request, redirectPath);\n  }\n\n  if (effectiveMode === 'search-params') {\n    const existingSearchParams = new URLSearchParams(request.nextUrl.search);\n    const existingLocale = existingSearchParams.get('locale');\n\n    const isExistingValid = locales?.includes(existingLocale as Locale);\n\n    let locale = (localLocale ??\n      (isExistingValid ? (existingLocale as Locale) : undefined) ??\n      localLocale ??\n      localeDetector?.(request) ??\n      defaultLocale) as Locale;\n\n    if (!locales?.includes(locale as Locale)) {\n      locale = defaultLocale as Locale;\n    }\n\n    const canonicalPath = getCanonicalPath(\n      pathname,\n      locale as Locale,\n      rewriteRules\n    );\n\n    if (existingLocale === locale) {\n      const internalPath = internalPrefix\n        ? `/${locale}${canonicalPath}`\n        : canonicalPath;\n      const rewritePath = `${internalPath}${request.nextUrl.search ?? ''}`;\n      return rewriteUrl(request, rewritePath, locale as Locale);\n    }\n\n    const search = appendLocaleSearchIfNeeded(\n      request.nextUrl.search,\n      locale as Locale\n    );\n    // Use original pathname for redirect to preserve user's URL input, just adding params\n    const redirectPath = search\n      ? `${pathname}${search}`\n      : `${pathname}${request.nextUrl.search ?? ''}`;\n\n    return redirectUrl(request, redirectPath);\n  }\n\n  // effectiveMode === 'no-prefix'\n  let locale = (localLocale ??\n    localeDetector?.(request) ??\n    defaultLocale) as Locale;\n\n  if (!locales?.includes(locale as Locale)) {\n    locale = defaultLocale as Locale;\n  }\n\n  const canonicalPath = getCanonicalPath(\n    pathname,\n    locale as Locale,\n    rewriteRules\n  );\n\n  const internalPath = internalPrefix\n    ? `/${locale}${canonicalPath}`\n    : canonicalPath;\n  const search = appendLocaleSearchIfNeeded(\n    request.nextUrl.search,\n    locale as Locale\n  );\n  const rewritePath = search\n    ? `${internalPath}${search}`\n    : `${internalPath}${request.nextUrl.search ?? ''}`;\n\n  return rewriteUrl(request, rewritePath, locale as Locale);\n};\n\n/**\n * Extracts the locale from the URL pathname if present.\n *\n * @param pathname - The pathname from the request URL.\n * @returns - The locale found in the pathname, or undefined if not found.\n */\nconst getPathLocale = (pathname: string): Locale | undefined =>\n  (locales as Locale[]).find(\n    (locale) => pathname.startsWith(`/${locale}/`) || pathname === `/${locale}`\n  );\n\n/**\n * Handles the case where URLs have locale prefixes.\n *\n * @param request - The incoming Next.js request object.\n * @param localLocale - The locale from the cookie.\n * @param pathLocale - The locale extracted from the pathname.\n * @param pathname - The pathname from the request URL.\n * @param basePathTrailingSlash - Indicates if the basePath ends with a slash.\n * @returns - The response to be returned to the client.\n */\nconst handlePrefix = (\n  request: NextRequest,\n  localLocale: Locale | undefined,\n  pathLocale: Locale | undefined,\n  pathname: string\n): NextResponse => {\n  if (!pathLocale) {\n    const isPrefetch = isPrefetchRequest(request);\n    if (isPrefetch && !DEFAULT_DETECT_LOCALE_ON_PREFETCH_NO_PREFIX) {\n      return handleMissingPathLocale(\n        request,\n        defaultLocale as Locale,\n        pathname\n      );\n    }\n    return handleMissingPathLocale(request, localLocale, pathname);\n  }\n\n  return handleExistingPathLocale(request, pathLocale, pathname);\n};\n\n/**\n * Handles requests where the locale is missing from the URL pathname.\n *\n * @param request - The incoming Next.js request object.\n * @param localLocale - The locale from the cookie.\n * @param pathname - The pathname from the request URL.\n * @param basePathTrailingSlash - Indicates if the basePath ends with a slash.\n * @returns - The response to be returned to the client.\n */\nconst handleMissingPathLocale = (\n  request: NextRequest,\n  localLocale: Locale | undefined,\n  pathname: string\n): NextResponse => {\n  let locale = (localLocale ??\n    localeDetector?.(request) ??\n    defaultLocale) as Locale;\n\n  if (!(locales as Locale[]).includes(locale)) {\n    locale = defaultLocale as Locale;\n  }\n\n  // Resolve to canonical path.\n  // If user visits /a-propos (implied 'fr'), we resolve to /about\n  const canonicalPath = getCanonicalPath(pathname, locale, rewriteRules);\n\n  // Determine target localized path for redirection\n  // /about + 'fr' -> /a-propos\n  const targetLocalizedPathResult = getLocalizedPath(\n    canonicalPath,\n    locale,\n    rewriteRules\n  );\n  const targetLocalizedPath =\n    typeof targetLocalizedPathResult === 'string'\n      ? targetLocalizedPathResult\n      : targetLocalizedPathResult.path;\n\n  const newPath = constructPath(\n    locale,\n    targetLocalizedPath,\n    basePath as string,\n    appendLocaleSearchIfNeeded(request.nextUrl.search, locale)\n  );\n\n  return prefixDefault || locale !== defaultLocale\n    ? redirectUrl(request, newPath)\n    : rewriteUrl(\n        request,\n        internalPrefix ? `/${locale}${canonicalPath}` : canonicalPath,\n        locale\n      ); // Rewrite must use Canonical\n};\n\n/**\n * Handles requests where the locale exists in the URL pathname.\n *\n * @param request - The incoming Next.js request object.\n * @param localLocale - The locale from the cookie.\n * @param pathLocale - The locale extracted from the pathname.\n * @param pathname - The pathname from the request URL.\n * @returns - The response to be returned to the client.\n */\nconst handleExistingPathLocale = (\n  request: NextRequest,\n  pathLocale: Locale,\n  pathname: string\n): NextResponse => {\n  const rawPath = pathname.slice(`/${pathLocale}`.length) || '/';\n\n  // 1. Identify the Canonical Path (Internal Next.js path)\n  // Ex: /a-propos (from URL) -> /about (Canonical)\n  const canonicalPath = getCanonicalPath(rawPath, pathLocale, rewriteRules);\n\n  // By skipping the forced localLocale check, we allow the explicit pathLocale\n  // to take precedence, which correctly updates the header/cookie when navigating.\n\n  // Rewrite Logic\n  // We must rewrite to the Next.js internal structure: /[locale]/[canonicalPath]\n  // Ex: Rewrite /fr/a-propos -> /fr/about\n\n  // 2. Redirect to localized path if needed (Canonical -> Localized)\n  // Ex: /fr/about -> /fr/a-propos\n  const targetLocalizedPathResult = getLocalizedPath(\n    canonicalPath,\n    pathLocale,\n    rewriteRules\n  );\n  const targetLocalizedPath =\n    typeof targetLocalizedPathResult === 'string'\n      ? targetLocalizedPathResult\n      : targetLocalizedPathResult.path;\n  const isRewritten =\n    typeof targetLocalizedPathResult === 'string'\n      ? false\n      : targetLocalizedPathResult.isRewritten;\n\n  if (isRewritten && targetLocalizedPath !== rawPath) {\n    const newPath = constructPath(\n      pathLocale,\n      targetLocalizedPath,\n      basePath as string,\n      appendLocaleSearchIfNeeded(request.nextUrl.search, pathLocale)\n    );\n    return redirectUrl(request, newPath);\n  }\n\n  const internalUrl = internalPrefix\n    ? `/${pathLocale}${canonicalPath}`\n    : canonicalPath;\n\n  // Only handle redirect if we are strictly managing default locale prefixing\n  if (!prefixDefault && pathLocale === defaultLocale) {\n    return handleDefaultLocaleRedirect(request, pathLocale, pathname);\n  }\n\n  const search = request.nextUrl.search;\n  return rewriteUrl(request, internalUrl + (search ?? ''), pathLocale);\n};\n\n/**\n * Handles the scenario where the locale in the cookie does not match the locale in the URL pathname.\n *\n * @param request - The incoming Next.js request object.\n * @param pathname - The pathname from the request URL.\n * @param pathLocale - The locale extracted from the pathname.\n * @param localLocale - The locale from the cookie.\n * @param basePath - The base path of the application.\n * @returns - The new URL path with the correct locale.\n */\n// Function handleCookieLocaleMismatch was removed because the URL locale should take precedence over the stored locale.\n\n/**\n * The key fix for 404s without [locale] folders\n */\nconst handleDefaultLocaleRedirect = (\n  request: NextRequest,\n  pathLocale: Locale,\n  canonicalPath: string // Internal path (e.g. /about)\n): NextResponse => {\n  if (!prefixDefault && pathLocale === defaultLocale) {\n    // Redirect to remove prefix\n    // We use canonicalPath because in no-prefix default mode, the URL is usually just the path\n    // But wait, if we are in this function, the URL *has* a prefix.\n    // We want to redirect to /about (localized for EN).\n\n    const targetLocalizedPathResult = getLocalizedPath(\n      canonicalPath,\n      pathLocale,\n      rewriteRules\n    );\n    const targetLocalizedPath =\n      typeof targetLocalizedPathResult === 'string'\n        ? targetLocalizedPathResult\n        : targetLocalizedPathResult.path;\n\n    // Construct path without prefix\n    const basePathTrailingSlash = (basePath as string).endsWith('/');\n    let finalPath = targetLocalizedPath;\n    if (finalPath.startsWith('/')) finalPath = finalPath.slice(1);\n\n    const fullPath = `${basePath}${basePathTrailingSlash ? '' : '/'}${finalPath}`;\n\n    const searchWithLocale = appendLocaleSearchIfNeeded(\n      request.nextUrl.search,\n      pathLocale\n    );\n\n    return redirectUrl(\n      request,\n      fullPath + (searchWithLocale ?? request.nextUrl.search ?? '')\n    );\n  }\n\n  const searchWithLocale = appendLocaleSearchIfNeeded(\n    request.nextUrl.search,\n    pathLocale\n  );\n\n  // If no redirect needed, we rewrite to the internal canonical path\n  const internalPath = internalPrefix\n    ? `/${pathLocale}${canonicalPath}`\n    : canonicalPath;\n\n  const rewriteTarget = searchWithLocale\n    ? `${internalPath}${searchWithLocale}`\n    : `${internalPath}${request.nextUrl.search ?? ''}`;\n\n  return rewriteUrl(request, rewriteTarget, pathLocale);\n};\n\n/**\n * Constructs a new path by combining the locale, path, basePath, and search parameters.\n *\n * @param locale - The locale to include in the path.\n * @param path - The original path from the request.\n * @param basePath - The base path of the application.\n * @param [search] - The query string from the request URL (optional).\n * @returns - The constructed new path.\n */\nconst constructPath = (\n  locale: Locale,\n  path: string,\n  basePath: string,\n  search?: string\n): string => {\n  // Remove existing locale prefix from path if it was passed by mistake,\n  // though we usually pass localized paths here now.\n  const pathWithoutPrefix = path.startsWith(`/${locale}`)\n    ? path.slice(`/${locale}`.length) || '/'\n    : path;\n\n  if (effectiveMode === 'no-prefix' || effectiveMode === 'search-params') {\n    return `${pathWithoutPrefix}${search ? `?${search}` : ''}`;\n  }\n\n  // Prefix handling\n  const pathWithLocalePrefix = path.startsWith(`/${locale}`)\n    ? path\n    : `${locale}${path.startsWith('/') ? '' : '/'}${path}`;\n\n  const basePathTrailingSlash = basePath.endsWith('/');\n  const newPath = `${basePath}${basePathTrailingSlash ? '' : '/'}${pathWithLocalePrefix}`;\n\n  // Clean double slashes\n  const cleanPath = newPath.replace(/\\/+/g, '/');\n\n  return cleanPath;\n};\n\n/**\n * This handles the internal path Next.js sees.\n * To support optional [locale] folders, we need to decide if we\n * keep the locale prefix or strip it.\n */\nconst rewriteUrl = (\n  request: NextRequest,\n  newPath: string,\n  locale: Locale\n): NextResponse => {\n  const search = request.nextUrl.search;\n  const pathWithSearch =\n    search && !newPath.includes('?') ? `${newPath}${search}` : newPath;\n\n  const requestHeaders = new Headers(request.headers);\n  setLocaleInStorage(locale, {\n    setHeader: (name: string, value: string) => {\n      requestHeaders.set(name, value);\n    },\n  });\n\n  const targetUrl = new URL(pathWithSearch, request.url);\n\n  // If the target URL is exactly the current request URL,\n  // we just want to `next()` to avoid losing headers on a redundant rewrite.\n  const response =\n    targetUrl.href === request.nextUrl.href\n      ? NextResponse.next({\n          request: {\n            headers: requestHeaders,\n          },\n        })\n      : NextResponse.rewrite(targetUrl, {\n          request: {\n            headers: requestHeaders,\n          },\n        });\n\n  setLocaleInStorage(locale, {\n    setHeader: (name: string, value: string) => {\n      response.headers.set(name, value);\n    },\n  });\n  return response;\n};\n\n/**\n * Redirects the request to the new path.\n *\n * @param request - The incoming Next.js request object.\n * @param newPath - The new path to redirect to.\n * @returns - The redirect response.\n */\nconst redirectUrl = (request: NextRequest, newPath: string): NextResponse => {\n  const search = request.nextUrl.search;\n  const pathWithSearch =\n    search && !newPath.includes('?') ? `${newPath}${search}` : newPath;\n\n  return NextResponse.redirect(new URL(pathWithSearch, request.url));\n};\n"],"mappings":"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"}

package/dist/esm/proxy/localeDetector.mjs

@@ -1,2 +1,19 @@
-import{localeDetector as e}from"@intlayer/core/localization";const t=t=>{let n={};return t.headers.forEach((e,t)=>{n[t]=e}),e(n)};export{t as localeDetector};
+import { localeDetector as localeDetector$1 } from "@intlayer/core/localization";
+
+//#region src/proxy/localeDetector.ts
+/**
+* Detects the locale from the request headers
+*
+* Headers are provided by the browser and can be used to determine the user's preferred language
+*/
+const localeDetector = (request) => {
+	const negotiatorHeaders = {};
+	request.headers.forEach((value, key) => {
+		negotiatorHeaders[key] = value;
+	});
+	return localeDetector$1(negotiatorHeaders);
+};
+
+//#endregion
+export { localeDetector };
 //# sourceMappingURL=localeDetector.mjs.map