gt-next 11.4.11 → 11.4.13

package/dist/link/getLocalizeHref.mjs

@@ -0,0 +1,56 @@
+import { localizeHref } from "./localize-utils.mjs";
+import { use } from "../utils/use.mjs";
+import { getLocale } from "../request/getLocale.mjs";
+import { getI18nConfig } from "gt-i18n/internal";
+//#region src/link/getLocalizeHref.ts
+/**
+* Returns a function that localizes hrefs the same way `gt-next/link` does,
+* for server code such as Server Components, route handlers, and Server
+* Actions.
+*
+* Internal paths are prefixed with the target locale, except default-locale
+* paths when `prefixDefaultLocale` is `false` (an explicit default `locale`
+* keeps its prefix while `enableSmartRouting` is on). Localized path aliases
+* and locale availability are still resolved by the middleware. External URLs
+* are never prefixed.
+*
+* @example
+* ```tsx
+* import { getLocalizeHref } from 'gt-next/server';
+*
+* export async function CheckoutButton() {
+*   const localizeHref = await getLocalizeHref();
+*   return <Button href={localizeHref('/checkout')}>Checkout</Button>;
+* }
+* ```
+*
+* @returns A promise of a function taking an href and an optional locale (a
+* locale string, or `false` to leave the href unchanged) that returns the
+* localized href.
+*/
+async function getLocalizeHref() {
+	const currentLocale = await getLocale();
+	const defaultLocale = getI18nConfig().getDefaultLocale();
+	return (href, locale) => localizeHref(href, locale, currentLocale, defaultLocale);
+}
+/**
+* Server Component version of `useLocalizeHref()`: localizes hrefs the same
+* way `gt-next/link` does, using the request locale.
+*
+* @example
+* ```tsx
+* import { useLocalizeHref } from 'gt-next';
+*
+* export function CheckoutButton() {
+*   const localizeHref = useLocalizeHref();
+*   return <Button href={localizeHref('/checkout')}>Checkout</Button>;
+* }
+* ```
+*/
+function useLocalizeHref() {
+	return use(getLocalizeHref());
+}
+//#endregion
+export { getLocalizeHref, useLocalizeHref };
+
+//# sourceMappingURL=getLocalizeHref.mjs.map

package/dist/link/getLocalizeHref.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"getLocalizeHref.mjs","names":[],"sources":["../../src/link/getLocalizeHref.ts"],"sourcesContent":["import { getI18nConfig } from 'gt-i18n/internal';\nimport { getLocale } from '../request/getLocale';\nimport { use } from '../utils/use';\nimport { localizeHref, type LinkLocale } from './localize-utils';\n\n/**\n * Returns a function that localizes hrefs the same way `gt-next/link` does,\n * for server code such as Server Components, route handlers, and Server\n * Actions.\n *\n * Internal paths are prefixed with the target locale, except default-locale\n * paths when `prefixDefaultLocale` is `false` (an explicit default `locale`\n * keeps its prefix while `enableSmartRouting` is on). Localized path aliases\n * and locale availability are still resolved by the middleware. External URLs\n * are never prefixed.\n *\n * @example\n * ```tsx\n * import { getLocalizeHref } from 'gt-next/server';\n *\n * export async function CheckoutButton() {\n *   const localizeHref = await getLocalizeHref();\n *   return <Button href={localizeHref('/checkout')}>Checkout</Button>;\n * }\n * ```\n *\n * @returns A promise of a function taking an href and an optional locale (a\n * locale string, or `false` to leave the href unchanged) that returns the\n * localized href.\n */\nexport async function getLocalizeHref(): Promise<\n  (href: string, locale?: LinkLocale) => string\n> {\n  const currentLocale = await getLocale();\n  const defaultLocale = getI18nConfig().getDefaultLocale();\n  return (href, locale) =>\n    localizeHref(href, locale, currentLocale, defaultLocale);\n}\n\n/**\n * Server Component version of `useLocalizeHref()`: localizes hrefs the same\n * way `gt-next/link` does, using the request locale.\n *\n * @example\n * ```tsx\n * import { useLocalizeHref } from 'gt-next';\n *\n * export function CheckoutButton() {\n *   const localizeHref = useLocalizeHref();\n *   return <Button href={localizeHref('/checkout')}>Checkout</Button>;\n * }\n * ```\n */\nexport function useLocalizeHref() {\n  return use(getLocalizeHref());\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BA,eAAsB,kBAEpB;CACA,MAAM,gBAAgB,MAAM,WAAW;CACvC,MAAM,gBAAgB,eAAe,CAAC,kBAAkB;AACxD,SAAQ,MAAM,WACZ,aAAa,MAAM,QAAQ,eAAe,cAAc;;;;;;;;;;;;;;;;AAiB5D,SAAgB,kBAAkB;AAChC,QAAO,IAAI,iBAAiB,CAAC"}

package/dist/link/localize-utils.d.ts

@@ -0,0 +1,15 @@
+import type NextLink from 'next/link';
+import type { ComponentProps } from 'react';
+/** A locale to prefix, `undefined` for the current locale, or `false` for none. */
+export type LinkLocale = ComponentProps<typeof NextLink>['locale'];
+/**
+ * Localizes an href the way `gt-next/link` does.
+ *
+ * Internal paths are prefixed with the target locale, except default-locale
+ * paths when `prefixDefaultLocale` is `false` (an explicit default `locale`
+ * keeps its prefix while `enableSmartRouting` is on). Localized path aliases
+ * and locale availability are still resolved by the middleware. External URLs
+ * are never prefixed.
+ */
+export declare function localizeHref(href: string, locale: LinkLocale, currentLocale: string, defaultLocale: string): string;
+//# sourceMappingURL=localize-utils.d.ts.map

package/dist/link/localize-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"localize-utils.d.ts","sourceRoot":"","sources":["../../src/link/localize-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,QAAQ,MAAM,WAAW,CAAC;AACtC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,OAAO,CAAC;AAG5C,mFAAmF;AACnF,MAAM,MAAM,UAAU,GAAG,cAAc,CAAC,OAAO,QAAQ,CAAC,CAAC,QAAQ,CAAC,CAAC;AA6CnE;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAC1B,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,UAAU,EAClB,aAAa,EAAE,MAAM,EACrB,aAAa,EAAE,MAAM,GACpB,MAAM,CAGR"}

package/dist/link/localize-utils.js

@@ -0,0 +1,49 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_middleware_dir_resolveMiddlewareConfig = require("../middleware-dir/resolveMiddlewareConfig.js");
+//#region src/link/localize-utils.ts
+let routingConfig;
+/**
+* Reads the routing options passed to withGTConfig() on first use, so
+* importing gt-next/link does no work.
+*/
+function getRoutingConfig() {
+	routingConfig ??= require_middleware_dir_resolveMiddlewareConfig.resolveMiddlewareConfig();
+	return routingConfig;
+}
+/**
+* Returns the locale to prefix, or `false` when the middleware would not
+* redirect the unprefixed path. Unprefixed default-locale paths are rewritten
+* internally unless `prefixDefaultLocale` is set. An explicit default-locale
+* switch keeps its prefix while smart routing would otherwise route to the
+* locale cookie.
+*/
+function getPrefixLocale(locale, currentLocale, defaultLocale) {
+	if (locale === false) return false;
+	const targetLocale = locale ?? currentLocale;
+	const { prefixDefaultLocale, enableSmartRouting } = getRoutingConfig();
+	if (prefixDefaultLocale || targetLocale !== defaultLocale) return targetLocale;
+	return locale !== void 0 && enableSmartRouting ? targetLocale : false;
+}
+function prefixPath(path, locale) {
+	if (!path.startsWith("/") || path.startsWith("//")) return path;
+	const url = new URL(path, "http://localhost");
+	url.pathname = url.pathname === "/" ? `/${encodeURIComponent(locale)}` : `/${encodeURIComponent(locale)}${url.pathname}`;
+	return `${url.pathname}${url.search}${url.hash}`;
+}
+/**
+* Localizes an href the way `gt-next/link` does.
+*
+* Internal paths are prefixed with the target locale, except default-locale
+* paths when `prefixDefaultLocale` is `false` (an explicit default `locale`
+* keeps its prefix while `enableSmartRouting` is on). Localized path aliases
+* and locale availability are still resolved by the middleware. External URLs
+* are never prefixed.
+*/
+function localizeHref(href, locale, currentLocale, defaultLocale) {
+	const prefixLocale = getPrefixLocale(locale, currentLocale, defaultLocale);
+	return prefixLocale ? prefixPath(href, prefixLocale) : href;
+}
+//#endregion
+exports.localizeHref = localizeHref;
+
+//# sourceMappingURL=localize-utils.js.map

package/dist/link/localize-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"localize-utils.js","names":["resolveMiddlewareConfig"],"sources":["../../src/link/localize-utils.ts"],"sourcesContent":["import type NextLink from 'next/link';\nimport type { ComponentProps } from 'react';\nimport { resolveMiddlewareConfig } from '../middleware-dir/resolveMiddlewareConfig';\n\n/** A locale to prefix, `undefined` for the current locale, or `false` for none. */\nexport type LinkLocale = ComponentProps<typeof NextLink>['locale'];\n\nlet routingConfig: ReturnType<typeof resolveMiddlewareConfig> | undefined;\n\n/**\n * Reads the routing options passed to withGTConfig() on first use, so\n * importing gt-next/link does no work.\n */\nfunction getRoutingConfig() {\n  routingConfig ??= resolveMiddlewareConfig();\n  return routingConfig;\n}\n\n/**\n * Returns the locale to prefix, or `false` when the middleware would not\n * redirect the unprefixed path. Unprefixed default-locale paths are rewritten\n * internally unless `prefixDefaultLocale` is set. An explicit default-locale\n * switch keeps its prefix while smart routing would otherwise route to the\n * locale cookie.\n */\nfunction getPrefixLocale(\n  locale: LinkLocale,\n  currentLocale: string,\n  defaultLocale: string\n): string | false {\n  if (locale === false) return false;\n  const targetLocale = locale ?? currentLocale;\n  const { prefixDefaultLocale, enableSmartRouting } = getRoutingConfig();\n  if (prefixDefaultLocale || targetLocale !== defaultLocale)\n    return targetLocale;\n  return locale !== undefined && enableSmartRouting ? targetLocale : false;\n}\n\nfunction prefixPath(path: string, locale: string): string {\n  if (!path.startsWith('/') || path.startsWith('//')) return path;\n\n  const url = new URL(path, 'http://localhost');\n  url.pathname =\n    url.pathname === '/'\n      ? `/${encodeURIComponent(locale)}`\n      : `/${encodeURIComponent(locale)}${url.pathname}`;\n\n  return `${url.pathname}${url.search}${url.hash}`;\n}\n\n/**\n * Localizes an href the way `gt-next/link` does.\n *\n * Internal paths are prefixed with the target locale, except default-locale\n * paths when `prefixDefaultLocale` is `false` (an explicit default `locale`\n * keeps its prefix while `enableSmartRouting` is on). Localized path aliases\n * and locale availability are still resolved by the middleware. External URLs\n * are never prefixed.\n */\nexport function localizeHref(\n  href: string,\n  locale: LinkLocale,\n  currentLocale: string,\n  defaultLocale: string\n): string {\n  const prefixLocale = getPrefixLocale(locale, currentLocale, defaultLocale);\n  return prefixLocale ? prefixPath(href, prefixLocale) : href;\n}\n"],"mappings":";;;AAOA,IAAI;;;;;AAMJ,SAAS,mBAAmB;AAC1B,mBAAkBA,+CAAAA,yBAAyB;AAC3C,QAAO;;;;;;;;;AAUT,SAAS,gBACP,QACA,eACA,eACgB;AAChB,KAAI,WAAW,MAAO,QAAO;CAC7B,MAAM,eAAe,UAAU;CAC/B,MAAM,EAAE,qBAAqB,uBAAuB,kBAAkB;AACtE,KAAI,uBAAuB,iBAAiB,cAC1C,QAAO;AACT,QAAO,WAAW,KAAA,KAAa,qBAAqB,eAAe;;AAGrE,SAAS,WAAW,MAAc,QAAwB;AACxD,KAAI,CAAC,KAAK,WAAW,IAAI,IAAI,KAAK,WAAW,KAAK,CAAE,QAAO;CAE3D,MAAM,MAAM,IAAI,IAAI,MAAM,mBAAmB;AAC7C,KAAI,WACF,IAAI,aAAa,MACb,IAAI,mBAAmB,OAAO,KAC9B,IAAI,mBAAmB,OAAO,GAAG,IAAI;AAE3C,QAAO,GAAG,IAAI,WAAW,IAAI,SAAS,IAAI;;;;;;;;;;;AAY5C,SAAgB,aACd,MACA,QACA,eACA,eACQ;CACR,MAAM,eAAe,gBAAgB,QAAQ,eAAe,cAAc;AAC1E,QAAO,eAAe,WAAW,MAAM,aAAa,GAAG"}

package/dist/link/localize-utils.mjs

@@ -0,0 +1,48 @@
+import { resolveMiddlewareConfig } from "../middleware-dir/resolveMiddlewareConfig.mjs";
+//#region src/link/localize-utils.ts
+let routingConfig;
+/**
+* Reads the routing options passed to withGTConfig() on first use, so
+* importing gt-next/link does no work.
+*/
+function getRoutingConfig() {
+	routingConfig ??= resolveMiddlewareConfig();
+	return routingConfig;
+}
+/**
+* Returns the locale to prefix, or `false` when the middleware would not
+* redirect the unprefixed path. Unprefixed default-locale paths are rewritten
+* internally unless `prefixDefaultLocale` is set. An explicit default-locale
+* switch keeps its prefix while smart routing would otherwise route to the
+* locale cookie.
+*/
+function getPrefixLocale(locale, currentLocale, defaultLocale) {
+	if (locale === false) return false;
+	const targetLocale = locale ?? currentLocale;
+	const { prefixDefaultLocale, enableSmartRouting } = getRoutingConfig();
+	if (prefixDefaultLocale || targetLocale !== defaultLocale) return targetLocale;
+	return locale !== void 0 && enableSmartRouting ? targetLocale : false;
+}
+function prefixPath(path, locale) {
+	if (!path.startsWith("/") || path.startsWith("//")) return path;
+	const url = new URL(path, "http://localhost");
+	url.pathname = url.pathname === "/" ? `/${encodeURIComponent(locale)}` : `/${encodeURIComponent(locale)}${url.pathname}`;
+	return `${url.pathname}${url.search}${url.hash}`;
+}
+/**
+* Localizes an href the way `gt-next/link` does.
+*
+* Internal paths are prefixed with the target locale, except default-locale
+* paths when `prefixDefaultLocale` is `false` (an explicit default `locale`
+* keeps its prefix while `enableSmartRouting` is on). Localized path aliases
+* and locale availability are still resolved by the middleware. External URLs
+* are never prefixed.
+*/
+function localizeHref(href, locale, currentLocale, defaultLocale) {
+	const prefixLocale = getPrefixLocale(locale, currentLocale, defaultLocale);
+	return prefixLocale ? prefixPath(href, prefixLocale) : href;
+}
+//#endregion
+export { localizeHref };
+
+//# sourceMappingURL=localize-utils.mjs.map

package/dist/link/localize-utils.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"localize-utils.mjs","names":[],"sources":["../../src/link/localize-utils.ts"],"sourcesContent":["import type NextLink from 'next/link';\nimport type { ComponentProps } from 'react';\nimport { resolveMiddlewareConfig } from '../middleware-dir/resolveMiddlewareConfig';\n\n/** A locale to prefix, `undefined` for the current locale, or `false` for none. */\nexport type LinkLocale = ComponentProps<typeof NextLink>['locale'];\n\nlet routingConfig: ReturnType<typeof resolveMiddlewareConfig> | undefined;\n\n/**\n * Reads the routing options passed to withGTConfig() on first use, so\n * importing gt-next/link does no work.\n */\nfunction getRoutingConfig() {\n  routingConfig ??= resolveMiddlewareConfig();\n  return routingConfig;\n}\n\n/**\n * Returns the locale to prefix, or `false` when the middleware would not\n * redirect the unprefixed path. Unprefixed default-locale paths are rewritten\n * internally unless `prefixDefaultLocale` is set. An explicit default-locale\n * switch keeps its prefix while smart routing would otherwise route to the\n * locale cookie.\n */\nfunction getPrefixLocale(\n  locale: LinkLocale,\n  currentLocale: string,\n  defaultLocale: string\n): string | false {\n  if (locale === false) return false;\n  const targetLocale = locale ?? currentLocale;\n  const { prefixDefaultLocale, enableSmartRouting } = getRoutingConfig();\n  if (prefixDefaultLocale || targetLocale !== defaultLocale)\n    return targetLocale;\n  return locale !== undefined && enableSmartRouting ? targetLocale : false;\n}\n\nfunction prefixPath(path: string, locale: string): string {\n  if (!path.startsWith('/') || path.startsWith('//')) return path;\n\n  const url = new URL(path, 'http://localhost');\n  url.pathname =\n    url.pathname === '/'\n      ? `/${encodeURIComponent(locale)}`\n      : `/${encodeURIComponent(locale)}${url.pathname}`;\n\n  return `${url.pathname}${url.search}${url.hash}`;\n}\n\n/**\n * Localizes an href the way `gt-next/link` does.\n *\n * Internal paths are prefixed with the target locale, except default-locale\n * paths when `prefixDefaultLocale` is `false` (an explicit default `locale`\n * keeps its prefix while `enableSmartRouting` is on). Localized path aliases\n * and locale availability are still resolved by the middleware. External URLs\n * are never prefixed.\n */\nexport function localizeHref(\n  href: string,\n  locale: LinkLocale,\n  currentLocale: string,\n  defaultLocale: string\n): string {\n  const prefixLocale = getPrefixLocale(locale, currentLocale, defaultLocale);\n  return prefixLocale ? prefixPath(href, prefixLocale) : href;\n}\n"],"mappings":";;AAOA,IAAI;;;;;AAMJ,SAAS,mBAAmB;AAC1B,mBAAkB,yBAAyB;AAC3C,QAAO;;;;;;;;;AAUT,SAAS,gBACP,QACA,eACA,eACgB;AAChB,KAAI,WAAW,MAAO,QAAO;CAC7B,MAAM,eAAe,UAAU;CAC/B,MAAM,EAAE,qBAAqB,uBAAuB,kBAAkB;AACtE,KAAI,uBAAuB,iBAAiB,cAC1C,QAAO;AACT,QAAO,WAAW,KAAA,KAAa,qBAAqB,eAAe;;AAGrE,SAAS,WAAW,MAAc,QAAwB;AACxD,KAAI,CAAC,KAAK,WAAW,IAAI,IAAI,KAAK,WAAW,KAAK,CAAE,QAAO;CAE3D,MAAM,MAAM,IAAI,IAAI,MAAM,mBAAmB;AAC7C,KAAI,WACF,IAAI,aAAa,MACb,IAAI,mBAAmB,OAAO,KAC9B,IAAI,mBAAmB,OAAO,GAAG,IAAI;AAE3C,QAAO,GAAG,IAAI,WAAW,IAAI,SAAS,IAAI;;;;;;;;;;;AAY5C,SAAgB,aACd,MACA,QACA,eACA,eACQ;CACR,MAAM,eAAe,gBAAgB,QAAQ,eAAe,cAAc;AAC1E,QAAO,eAAe,WAAW,MAAM,aAAa,GAAG"}

package/dist/link/useLocalizeHref.d.ts

@@ -0,0 +1,34 @@
+import { type LinkLocale } from './localize-utils';
+/**
+ * Returns a function that localizes hrefs the same way `gt-next/link` does,
+ * for navigation that does not render a `<Link>`, such as `router.push()`.
+ *
+ * Internal paths are prefixed with the target locale, except default-locale
+ * paths when `prefixDefaultLocale` is `false` (an explicit default `locale`
+ * keeps its prefix while `enableSmartRouting` is on). Localized path aliases
+ * and locale availability are still resolved by the middleware. External URLs
+ * are never prefixed.
+ *
+ * @example
+ * ```tsx
+ * 'use client';
+ *
+ * import { useRouter } from 'next/navigation';
+ * import { useLocalizeHref } from 'gt-next/link';
+ *
+ * export function Checkout() {
+ *   const router = useRouter();
+ *   const localizeHref = useLocalizeHref();
+ *   return (
+ *     <button onClick={() => router.push(localizeHref('/checkout'))}>
+ *       Checkout
+ *     </button>
+ *   );
+ * }
+ * ```
+ *
+ * @returns A function taking an href and an optional locale (a locale string,
+ * or `false` to leave the href unchanged) that returns the localized href.
+ */
+export declare function useLocalizeHref(): (href: string, locale?: LinkLocale) => string;
+//# sourceMappingURL=useLocalizeHref.d.ts.map

package/dist/link/useLocalizeHref.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLocalizeHref.d.ts","sourceRoot":"","sources":["../../src/link/useLocalizeHref.ts"],"names":[],"mappings":"AAEA,OAAO,EAAgB,KAAK,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEjE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,eAAe,IAAI,CACjC,IAAI,EAAE,MAAM,EACZ,MAAM,CAAC,EAAE,UAAU,KAChB,MAAM,CAOV"}

package/dist/link/useLocalizeHref.js

@@ -0,0 +1,46 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("../_virtual/_rolldown/runtime.js");
+const require_link_localize_utils = require("./localize-utils.js");
+let gt_react = require("gt-react");
+let react = require("react");
+//#region src/link/useLocalizeHref.ts
+/**
+* Returns a function that localizes hrefs the same way `gt-next/link` does,
+* for navigation that does not render a `<Link>`, such as `router.push()`.
+*
+* Internal paths are prefixed with the target locale, except default-locale
+* paths when `prefixDefaultLocale` is `false` (an explicit default `locale`
+* keeps its prefix while `enableSmartRouting` is on). Localized path aliases
+* and locale availability are still resolved by the middleware. External URLs
+* are never prefixed.
+*
+* @example
+* ```tsx
+* 'use client';
+*
+* import { useRouter } from 'next/navigation';
+* import { useLocalizeHref } from 'gt-next/link';
+*
+* export function Checkout() {
+*   const router = useRouter();
+*   const localizeHref = useLocalizeHref();
+*   return (
+*     <button onClick={() => router.push(localizeHref('/checkout'))}>
+*       Checkout
+*     </button>
+*   );
+* }
+* ```
+*
+* @returns A function taking an href and an optional locale (a locale string,
+* or `false` to leave the href unchanged) that returns the localized href.
+*/
+function useLocalizeHref() {
+	const currentLocale = (0, gt_react.useLocale)();
+	const defaultLocale = (0, gt_react.useDefaultLocale)();
+	return (0, react.useCallback)((href, locale) => require_link_localize_utils.localizeHref(href, locale, currentLocale, defaultLocale), [currentLocale, defaultLocale]);
+}
+//#endregion
+exports.useLocalizeHref = useLocalizeHref;
+
+//# sourceMappingURL=useLocalizeHref.js.map

package/dist/link/useLocalizeHref.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLocalizeHref.js","names":["localizeHref"],"sources":["../../src/link/useLocalizeHref.ts"],"sourcesContent":["import { useCallback } from 'react';\nimport { useDefaultLocale, useLocale } from 'gt-react';\nimport { localizeHref, type LinkLocale } from './localize-utils';\n\n/**\n * Returns a function that localizes hrefs the same way `gt-next/link` does,\n * for navigation that does not render a `<Link>`, such as `router.push()`.\n *\n * Internal paths are prefixed with the target locale, except default-locale\n * paths when `prefixDefaultLocale` is `false` (an explicit default `locale`\n * keeps its prefix while `enableSmartRouting` is on). Localized path aliases\n * and locale availability are still resolved by the middleware. External URLs\n * are never prefixed.\n *\n * @example\n * ```tsx\n * 'use client';\n *\n * import { useRouter } from 'next/navigation';\n * import { useLocalizeHref } from 'gt-next/link';\n *\n * export function Checkout() {\n *   const router = useRouter();\n *   const localizeHref = useLocalizeHref();\n *   return (\n *     <button onClick={() => router.push(localizeHref('/checkout'))}>\n *       Checkout\n *     </button>\n *   );\n * }\n * ```\n *\n * @returns A function taking an href and an optional locale (a locale string,\n * or `false` to leave the href unchanged) that returns the localized href.\n */\nexport function useLocalizeHref(): (\n  href: string,\n  locale?: LinkLocale\n) => string {\n  const currentLocale = useLocale();\n  const defaultLocale = useDefaultLocale();\n  return useCallback(\n    (href, locale) => localizeHref(href, locale, currentLocale, defaultLocale),\n    [currentLocale, defaultLocale]\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCA,SAAgB,kBAGJ;CACV,MAAM,iBAAA,GAAA,SAAA,YAA2B;CACjC,MAAM,iBAAA,GAAA,SAAA,mBAAkC;AACxC,SAAA,GAAA,MAAA,cACG,MAAM,WAAWA,4BAAAA,aAAa,MAAM,QAAQ,eAAe,cAAc,EAC1E,CAAC,eAAe,cAAc,CAC/B"}

package/dist/link/useLocalizeHref.mjs

@@ -0,0 +1,44 @@
+import { localizeHref } from "./localize-utils.mjs";
+import { useDefaultLocale, useLocale } from "gt-react";
+import { useCallback } from "react";
+//#region src/link/useLocalizeHref.ts
+/**
+* Returns a function that localizes hrefs the same way `gt-next/link` does,
+* for navigation that does not render a `<Link>`, such as `router.push()`.
+*
+* Internal paths are prefixed with the target locale, except default-locale
+* paths when `prefixDefaultLocale` is `false` (an explicit default `locale`
+* keeps its prefix while `enableSmartRouting` is on). Localized path aliases
+* and locale availability are still resolved by the middleware. External URLs
+* are never prefixed.
+*
+* @example
+* ```tsx
+* 'use client';
+*
+* import { useRouter } from 'next/navigation';
+* import { useLocalizeHref } from 'gt-next/link';
+*
+* export function Checkout() {
+*   const router = useRouter();
+*   const localizeHref = useLocalizeHref();
+*   return (
+*     <button onClick={() => router.push(localizeHref('/checkout'))}>
+*       Checkout
+*     </button>
+*   );
+* }
+* ```
+*
+* @returns A function taking an href and an optional locale (a locale string,
+* or `false` to leave the href unchanged) that returns the localized href.
+*/
+function useLocalizeHref() {
+	const currentLocale = useLocale();
+	const defaultLocale = useDefaultLocale();
+	return useCallback((href, locale) => localizeHref(href, locale, currentLocale, defaultLocale), [currentLocale, defaultLocale]);
+}
+//#endregion
+export { useLocalizeHref };
+
+//# sourceMappingURL=useLocalizeHref.mjs.map

package/dist/link/useLocalizeHref.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLocalizeHref.mjs","names":[],"sources":["../../src/link/useLocalizeHref.ts"],"sourcesContent":["import { useCallback } from 'react';\nimport { useDefaultLocale, useLocale } from 'gt-react';\nimport { localizeHref, type LinkLocale } from './localize-utils';\n\n/**\n * Returns a function that localizes hrefs the same way `gt-next/link` does,\n * for navigation that does not render a `<Link>`, such as `router.push()`.\n *\n * Internal paths are prefixed with the target locale, except default-locale\n * paths when `prefixDefaultLocale` is `false` (an explicit default `locale`\n * keeps its prefix while `enableSmartRouting` is on). Localized path aliases\n * and locale availability are still resolved by the middleware. External URLs\n * are never prefixed.\n *\n * @example\n * ```tsx\n * 'use client';\n *\n * import { useRouter } from 'next/navigation';\n * import { useLocalizeHref } from 'gt-next/link';\n *\n * export function Checkout() {\n *   const router = useRouter();\n *   const localizeHref = useLocalizeHref();\n *   return (\n *     <button onClick={() => router.push(localizeHref('/checkout'))}>\n *       Checkout\n *     </button>\n *   );\n * }\n * ```\n *\n * @returns A function taking an href and an optional locale (a locale string,\n * or `false` to leave the href unchanged) that returns the localized href.\n */\nexport function useLocalizeHref(): (\n  href: string,\n  locale?: LinkLocale\n) => string {\n  const currentLocale = useLocale();\n  const defaultLocale = useDefaultLocale();\n  return useCallback(\n    (href, locale) => localizeHref(href, locale, currentLocale, defaultLocale),\n    [currentLocale, defaultLocale]\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCA,SAAgB,kBAGJ;CACV,MAAM,gBAAgB,WAAW;CACjC,MAAM,gBAAgB,kBAAkB;AACxC,QAAO,aACJ,MAAM,WAAW,aAAa,MAAM,QAAQ,eAAe,cAAc,EAC1E,CAAC,eAAe,cAAc,CAC/B"}

package/dist/link.d.ts

@@ -1,3 +1,5 @@
 export { Link as default } from './link/Link';
 export type { LinkProps } from './link/Link';
+export { useLocalizeHref } from './link/useLocalizeHref';
+export type { LinkLocale } from './link/localize-utils';
 //# sourceMappingURL=link.d.ts.map

package/dist/link.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"link.d.ts","sourceRoot":"","sources":["../src/link.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,IAAI,IAAI,OAAO,EAAE,MAAM,aAAa,CAAC;AAC9C,YAAY,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC"}
+{"version":3,"file":"link.d.ts","sourceRoot":"","sources":["../src/link.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,IAAI,IAAI,OAAO,EAAE,MAAM,aAAa,CAAC;AAC9C,YAAY,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAC7C,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AACzD,YAAY,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC"}

package/dist/link.js

@@ -3,5 +3,7 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
+const require_link_useLocalizeHref = require("./link/useLocalizeHref.js");
 const require_link_Link = require("./link/Link.js");
 exports.default = require_link_Link.Link;
+exports.useLocalizeHref = require_link_useLocalizeHref.useLocalizeHref;

package/dist/link.mjs

@@ -1,3 +1,4 @@
 "use client";
+import { useLocalizeHref } from "./link/useLocalizeHref.mjs";
 import { Link } from "./link/Link.mjs";
-export { Link as default };
+export { Link as default, useLocalizeHref };

package/dist/middleware-dir/createMiddlewareRouting.d.ts

@@ -0,0 +1,7 @@
+import type { MiddlewareRouting, ResolvedMiddlewareConfig } from './types';
+/**
+ * Pre-processes the locale, cookie, and path configuration once per
+ * middleware instance so requests only do lookups.
+ */
+export declare function createMiddlewareRouting({ pathConfig: inputPathConfig, routeOverrides: inputRouteOverrides, localeRoutes, prefixDefaultLocale, }: ResolvedMiddlewareConfig): MiddlewareRouting;
+//# sourceMappingURL=createMiddlewareRouting.d.ts.map

package/dist/middleware-dir/createMiddlewareRouting.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createMiddlewareRouting.d.ts","sourceRoot":"","sources":["../../src/middleware-dir/createMiddlewareRouting.ts"],"names":[],"mappings":"AAoBA,OAAO,KAAK,EAEV,iBAAiB,EACjB,wBAAwB,EAEzB,MAAM,SAAS,CAAC;AAEjB;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,EACtC,UAAU,EAAE,eAAe,EAC3B,cAAc,EAAE,mBAAmB,EACnC,YAAY,EACZ,mBAAmB,GACpB,EAAE,wBAAwB,GAAG,iBAAiB,CA6J9C"}

package/dist/middleware-dir/createMiddlewareRouting.js

@@ -0,0 +1,79 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("../_virtual/_rolldown/runtime.js");
+require("../utils/headers.js");
+require("../utils/cookies.js");
+const require_utils_pathRegex = require("../utils/pathRegex.js");
+const require_errors_middleware = require("../errors/middleware.js");
+const require_middleware_dir_resolveMiddlewareConfig = require("./resolveMiddlewareConfig.js");
+const require_middleware_dir_createPathMatcher = require("./createPathMatcher.js");
+let generaltranslation_internal = require("generaltranslation/internal");
+let _generaltranslation_react_core_pure = require("@generaltranslation/react-core/pure");
+let generaltranslation_runtime = require("generaltranslation/runtime");
+//#region src/middleware-dir/createMiddlewareRouting.ts
+/**
+* Pre-processes the locale, cookie, and path configuration once per
+* middleware instance so requests only do lookups.
+*/
+function createMiddlewareRouting({ pathConfig: inputPathConfig, routeOverrides: inputRouteOverrides, localeRoutes, prefixDefaultLocale }) {
+	const pathRegex = require_utils_pathRegex.compilePathRegex(process.env._GENERALTRANSLATION_PATH_REGEX);
+	const i18nConfig = require_middleware_dir_resolveMiddlewareConfig.parseEnvConfig("_GENERALTRANSLATION_I18N_CONFIG_PARAMS", process.env._GENERALTRANSLATION_I18N_CONFIG_PARAMS);
+	const gt = new generaltranslation_runtime.GTRuntime({ customMapping: i18nConfig.customMapping });
+	const defaultLocale = i18nConfig.defaultLocale || generaltranslation_internal.libraryDefaultLocale;
+	const locales = Array.from(new Set([defaultLocale, ...i18nConfig.locales || []]));
+	const resolvedConfigLocales = /* @__PURE__ */ new Map();
+	const determineLocaleWithCache = (locale) => {
+		const cached = resolvedConfigLocales.get(locale);
+		if (cached !== void 0) return cached;
+		const resolved = gt.determineLocale(locale, locales) ?? locale;
+		resolvedConfigLocales.set(locale, resolved);
+		return resolved;
+	};
+	const resolvePathConfigLocale = process.env._GENERALTRANSLATION_GT_SERVICES_ENABLED === "true" ? determineLocaleWithCache : (locale) => locale;
+	const headersAndCookies = i18nConfig.headersAndCookies || {};
+	const localeRoutingEnabledCookieName = headersAndCookies?.localeRoutingEnabledCookieName || "generaltranslation.locale-routing-enabled";
+	const referrerLocaleCookieName = headersAndCookies?.referrerLocaleCookieName || "generaltranslation.referrer-locale";
+	const localeCookieName = headersAndCookies?.localeCookieName || _generaltranslation_react_core_pure.defaultLocaleCookieName;
+	const resetLocaleCookieName = headersAndCookies?.resetLocaleCookieName || _generaltranslation_react_core_pure.defaultResetLocaleCookieName;
+	const localeHeaderName = headersAndCookies?.localeHeaderName || "x-generaltranslation-locale";
+	if (!gt.isValidLocale(defaultLocale)) throw new Error(`gt-next middleware: defaultLocale "${defaultLocale}" is not a valid locale.`);
+	const warningLocales = locales.filter((locale) => !gt.isValidLocale(locale));
+	if (warningLocales.length) console.warn(require_errors_middleware.createUnsupportedLocalesWarning(warningLocales));
+	const pathConfig = Object.entries(inputPathConfig).reduce((acc, [sharedPath, localizedPath]) => {
+		if (typeof localizedPath === "string") acc[sharedPath] = localizedPath;
+		else acc[sharedPath] = Object.entries(localizedPath).reduce((acc, [locale, localizedPath]) => {
+			acc[resolvePathConfigLocale(locale)] = localizedPath;
+			return acc;
+		}, {});
+		return acc;
+	}, {});
+	const { pathToSharedPath, defaultLocalePaths } = require_middleware_dir_createPathMatcher.createPathToSharedPathMap(Object.fromEntries(Object.entries(pathConfig).map(([sharedPath, localizedPath]) => [sharedPath, typeof localizedPath === "string" ? Object.fromEntries(locales.map((locale) => [determineLocaleWithCache(locale), localizedPath === "" ? "/" : localizedPath])) : localizedPath])), prefixDefaultLocale, defaultLocale);
+	const routeOverrides = Object.entries(inputRouteOverrides).reduce((acc, [locale, paths]) => {
+		acc[resolvePathConfigLocale(locale)] = paths;
+		return acc;
+	}, {});
+	return {
+		pathRegex,
+		gt,
+		defaultLocale,
+		locales,
+		localeRoutingEnabledCookieName,
+		referrerLocaleCookieName,
+		localeCookieName,
+		resetLocaleCookieName,
+		localeHeaderName,
+		pathConfig,
+		pathToSharedPath,
+		defaultLocalePaths,
+		routeOverridePathMaps: Object.entries(routeOverrides).reduce((acc, [locale, paths]) => {
+			acc[locale] = require_middleware_dir_createPathMatcher.createPathToSharedPathMap(Object.fromEntries(paths.map((path) => [path, path])), true, defaultLocale).pathToSharedPath;
+			return acc;
+		}, {}),
+		localeRoutePathMaps: new Map(Object.entries(localeRoutes).map(([locale, paths]) => {
+			return [determineLocaleWithCache(locale), require_middleware_dir_createPathMatcher.createPathMatcher(paths.map((path) => [path, path]))];
+		}))
+	};
+}
+//#endregion
+exports.createMiddlewareRouting = createMiddlewareRouting;
+
+//# sourceMappingURL=createMiddlewareRouting.js.map

package/dist/middleware-dir/createMiddlewareRouting.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createMiddlewareRouting.js","names":["compilePathRegex","parseEnvConfig","GTRuntime","libraryDefaultLocale","defaultLocaleCookieName","defaultResetLocaleCookieName","createUnsupportedLocalesWarning","createPathToSharedPathMap","createPathMatcher"],"sources":["../../src/middleware-dir/createMiddlewareRouting.ts"],"sourcesContent":["import { GTRuntime } from 'generaltranslation/runtime';\nimport { libraryDefaultLocale } from 'generaltranslation/internal';\nimport {\n  defaultLocaleCookieName,\n  defaultResetLocaleCookieName,\n} from '@generaltranslation/react-core/pure';\nimport { createUnsupportedLocalesWarning } from '../errors/middleware';\nimport {\n  defaultLocaleRoutingEnabledCookieName,\n  defaultReferrerLocaleCookieName,\n} from '../utils/cookies';\nimport { defaultLocaleHeaderName } from '../utils/headers';\nimport { compilePathRegex } from '../utils/pathRegex';\nimport {\n  createPathMatcher,\n  createPathToSharedPathMap,\n  type PathConfig,\n  type PathMatcher,\n} from './createPathMatcher';\nimport { parseEnvConfig } from './resolveMiddlewareConfig';\nimport type {\n  MiddlewareI18nConfig,\n  MiddlewareRouting,\n  ResolvedMiddlewareConfig,\n  RouteOverrides,\n} from './types';\n\n/**\n * Pre-processes the locale, cookie, and path configuration once per\n * middleware instance so requests only do lookups.\n */\nexport function createMiddlewareRouting({\n  pathConfig: inputPathConfig,\n  routeOverrides: inputRouteOverrides,\n  localeRoutes,\n  prefixDefaultLocale,\n}: ResolvedMiddlewareConfig): MiddlewareRouting {\n  const pathRegex = compilePathRegex(\n    process.env._GENERALTRANSLATION_PATH_REGEX\n  );\n\n  // i18n config\n  const i18nConfig = parseEnvConfig<MiddlewareI18nConfig>(\n    '_GENERALTRANSLATION_I18N_CONFIG_PARAMS',\n    process.env._GENERALTRANSLATION_I18N_CONFIG_PARAMS\n  );\n\n  // gt instance\n  const gt = new GTRuntime({\n    customMapping: i18nConfig.customMapping,\n  });\n\n  // Configured spellings are the identity used by routes, cookies and caches.\n  const defaultLocale: string =\n    i18nConfig.defaultLocale || libraryDefaultLocale;\n  const locales = Array.from(\n    new Set([defaultLocale, ...(i18nConfig.locales || [])])\n  );\n  // Route entries repeat locale keys. Resolve each key once per factory instead\n  // of rebuilding the full locale-resolution index for every route/locale pair.\n  const resolvedConfigLocales = new Map<string, string>();\n  const determineLocaleWithCache = (locale: string) => {\n    const cached = resolvedConfigLocales.get(locale);\n    if (cached !== undefined) return cached;\n    const resolved = gt.determineLocale(locale, locales) ?? locale;\n    resolvedConfigLocales.set(locale, resolved);\n    return resolved;\n  };\n  const resolvePathConfigLocale =\n    process.env._GENERALTRANSLATION_GT_SERVICES_ENABLED === 'true'\n      ? determineLocaleWithCache\n      : (locale: string) => locale;\n\n  // cookies and header names\n  const headersAndCookies = i18nConfig.headersAndCookies || {};\n  const localeRoutingEnabledCookieName =\n    headersAndCookies?.localeRoutingEnabledCookieName ||\n    defaultLocaleRoutingEnabledCookieName;\n  const referrerLocaleCookieName =\n    headersAndCookies?.referrerLocaleCookieName ||\n    defaultReferrerLocaleCookieName;\n  const localeCookieName =\n    headersAndCookies?.localeCookieName || defaultLocaleCookieName;\n  const resetLocaleCookieName =\n    headersAndCookies?.resetLocaleCookieName || defaultResetLocaleCookieName;\n  const localeHeaderName =\n    headersAndCookies?.localeHeaderName || defaultLocaleHeaderName;\n\n  if (!gt.isValidLocale(defaultLocale))\n    throw new Error(\n      `gt-next middleware: defaultLocale \"${defaultLocale}\" is not a valid locale.`\n    );\n\n  const warningLocales = locales.filter((locale) => !gt.isValidLocale(locale));\n  if (warningLocales.length)\n    console.warn(createUnsupportedLocalesWarning(warningLocales));\n\n  // --- localized routes --- //\n  // Resolve pathConfig keys to the configured locale spelling.\n  const pathConfig = Object.entries(inputPathConfig).reduce<PathConfig>(\n    (acc, [sharedPath, localizedPath]) => {\n      if (typeof localizedPath === 'string') {\n        acc[sharedPath] = localizedPath;\n      } else {\n        acc[sharedPath] = Object.entries(localizedPath).reduce<{\n          [key: string]: string;\n        }>((acc, [locale, localizedPath]) => {\n          acc[resolvePathConfigLocale(locale)] = localizedPath;\n          return acc;\n        }, {});\n      }\n      return acc;\n    },\n    {}\n  );\n\n  // String aliases apply to every locale, including the default locale.\n  // Expand a copy for lookup while retaining string target semantics in routing.\n  const matcherPathConfig = Object.fromEntries(\n    Object.entries(pathConfig).map(([sharedPath, localizedPath]) => [\n      sharedPath,\n      typeof localizedPath === 'string'\n        ? Object.fromEntries(\n            locales.map((locale) => [\n              determineLocaleWithCache(locale),\n              localizedPath === '' ? '/' : localizedPath,\n            ])\n          )\n        : localizedPath,\n    ])\n  );\n\n  // Create the path mapping\n  const { pathToSharedPath, defaultLocalePaths } = createPathToSharedPathMap(\n    matcherPathConfig,\n    prefixDefaultLocale,\n    defaultLocale\n  );\n\n  // --- route overrides --- //\n  // Resolve routeOverrides keys to the configured locale spelling.\n  const routeOverrides = Object.entries(\n    inputRouteOverrides\n  ).reduce<RouteOverrides>((acc, [locale, paths]) => {\n    acc[resolvePathConfigLocale(locale)] = paths;\n    return acc;\n  }, {});\n\n  // Create the route override path mapping\n  const routeOverridePathMaps = Object.entries(routeOverrides).reduce<\n    Record<string, PathMatcher>\n  >((acc, [locale, paths]) => {\n    const overridePathConfig = Object.fromEntries(\n      paths.map((path) => [path, path])\n    );\n    acc[locale] = createPathToSharedPathMap(\n      overridePathConfig,\n      true,\n      defaultLocale\n    ).pathToSharedPath;\n    return acc;\n  }, {});\n\n  // --- locale routes --- //\n  // Compile availability separately from aliases and overrides so it cannot\n  // change route precedence. An empty list deliberately matches nothing.\n  const localeRoutePathMaps = new Map(\n    Object.entries(localeRoutes).map(([locale, paths]) => {\n      // Match request resolution so equivalent spellings use the same map key.\n      const resolvedLocale = determineLocaleWithCache(locale);\n      return [\n        resolvedLocale,\n        createPathMatcher(paths.map((path) => [path, path])),\n      ];\n    })\n  );\n\n  return {\n    pathRegex,\n    gt,\n    defaultLocale,\n    locales,\n    localeRoutingEnabledCookieName,\n    referrerLocaleCookieName,\n    localeCookieName,\n    resetLocaleCookieName,\n    localeHeaderName,\n    pathConfig,\n    pathToSharedPath,\n    defaultLocalePaths,\n    routeOverridePathMaps,\n    localeRoutePathMaps,\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;AA+BA,SAAgB,wBAAwB,EACtC,YAAY,iBACZ,gBAAgB,qBAChB,cACA,uBAC8C;CAC9C,MAAM,YAAYA,wBAAAA,iBAChB,QAAQ,IAAI,+BACb;CAGD,MAAM,aAAaC,+CAAAA,eACjB,0CACA,QAAQ,IAAI,uCACb;CAGD,MAAM,KAAK,IAAIC,2BAAAA,UAAU,EACvB,eAAe,WAAW,eAC3B,CAAC;CAGF,MAAM,gBACJ,WAAW,iBAAiBC,4BAAAA;CAC9B,MAAM,UAAU,MAAM,KACpB,IAAI,IAAI,CAAC,eAAe,GAAI,WAAW,WAAW,EAAE,CAAE,CAAC,CACxD;CAGD,MAAM,wCAAwB,IAAI,KAAqB;CACvD,MAAM,4BAA4B,WAAmB;EACnD,MAAM,SAAS,sBAAsB,IAAI,OAAO;AAChD,MAAI,WAAW,KAAA,EAAW,QAAO;EACjC,MAAM,WAAW,GAAG,gBAAgB,QAAQ,QAAQ,IAAI;AACxD,wBAAsB,IAAI,QAAQ,SAAS;AAC3C,SAAO;;CAET,MAAM,0BACJ,QAAQ,IAAI,4CAA4C,SACpD,4BACC,WAAmB;CAG1B,MAAM,oBAAoB,WAAW,qBAAqB,EAAE;CAC5D,MAAM,iCACJ,mBAAmB,kCAAA;CAErB,MAAM,2BACJ,mBAAmB,4BAAA;CAErB,MAAM,mBACJ,mBAAmB,oBAAoBC,oCAAAA;CACzC,MAAM,wBACJ,mBAAmB,yBAAyBC,oCAAAA;CAC9C,MAAM,mBACJ,mBAAmB,oBAAA;AAErB,KAAI,CAAC,GAAG,cAAc,cAAc,CAClC,OAAM,IAAI,MACR,sCAAsC,cAAc,0BACrD;CAEH,MAAM,iBAAiB,QAAQ,QAAQ,WAAW,CAAC,GAAG,cAAc,OAAO,CAAC;AAC5E,KAAI,eAAe,OACjB,SAAQ,KAAKC,0BAAAA,gCAAgC,eAAe,CAAC;CAI/D,MAAM,aAAa,OAAO,QAAQ,gBAAgB,CAAC,QAChD,KAAK,CAAC,YAAY,mBAAmB;AACpC,MAAI,OAAO,kBAAkB,SAC3B,KAAI,cAAc;MAElB,KAAI,cAAc,OAAO,QAAQ,cAAc,CAAC,QAE5C,KAAK,CAAC,QAAQ,mBAAmB;AACnC,OAAI,wBAAwB,OAAO,IAAI;AACvC,UAAO;KACN,EAAE,CAAC;AAER,SAAO;IAET,EAAE,CACH;CAmBD,MAAM,EAAE,kBAAkB,uBAAuBC,yCAAAA,0BAfvB,OAAO,YAC/B,OAAO,QAAQ,WAAW,CAAC,KAAK,CAAC,YAAY,mBAAmB,CAC9D,YACA,OAAO,kBAAkB,WACrB,OAAO,YACL,QAAQ,KAAK,WAAW,CACtB,yBAAyB,OAAO,EAChC,kBAAkB,KAAK,MAAM,cAC9B,CAAC,CACH,GACD,cACL,CAAC,CAKe,EACjB,qBACA,cACD;CAID,MAAM,iBAAiB,OAAO,QAC5B,oBACD,CAAC,QAAwB,KAAK,CAAC,QAAQ,WAAW;AACjD,MAAI,wBAAwB,OAAO,IAAI;AACvC,SAAO;IACN,EAAE,CAAC;AA+BN,QAAO;EACL;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA,uBAzC4B,OAAO,QAAQ,eAAe,CAAC,QAE1D,KAAK,CAAC,QAAQ,WAAW;AAI1B,OAAI,UAAUA,yCAAAA,0BAHa,OAAO,YAChC,MAAM,KAAK,SAAS,CAAC,MAAM,KAAK,CAAC,CAGf,EAClB,MACA,cACD,CAAC;AACF,UAAO;KACN,EAAE,CA6BkB;EACrB,qBAAA,IAzB8B,IAC9B,OAAO,QAAQ,aAAa,CAAC,KAAK,CAAC,QAAQ,WAAW;AAGpD,UAAO,CADgB,yBAAyB,OAEhC,EACdC,yCAAAA,kBAAkB,MAAM,KAAK,SAAS,CAAC,MAAM,KAAK,CAAC,CAAC,CACrD;IACD,CAiBiB;EACpB"}

package/dist/middleware-dir/createMiddlewareRouting.mjs

@@ -0,0 +1,77 @@
+import "../utils/headers.mjs";
+import "../utils/cookies.mjs";
+import { compilePathRegex } from "../utils/pathRegex.mjs";
+import { createUnsupportedLocalesWarning } from "../errors/middleware.mjs";
+import { parseEnvConfig } from "./resolveMiddlewareConfig.mjs";
+import { createPathMatcher, createPathToSharedPathMap } from "./createPathMatcher.mjs";
+import { libraryDefaultLocale } from "generaltranslation/internal";
+import { defaultLocaleCookieName, defaultResetLocaleCookieName } from "@generaltranslation/react-core/pure";
+import { GTRuntime } from "generaltranslation/runtime";
+//#region src/middleware-dir/createMiddlewareRouting.ts
+/**
+* Pre-processes the locale, cookie, and path configuration once per
+* middleware instance so requests only do lookups.
+*/
+function createMiddlewareRouting({ pathConfig: inputPathConfig, routeOverrides: inputRouteOverrides, localeRoutes, prefixDefaultLocale }) {
+	const pathRegex = compilePathRegex(process.env._GENERALTRANSLATION_PATH_REGEX);
+	const i18nConfig = parseEnvConfig("_GENERALTRANSLATION_I18N_CONFIG_PARAMS", process.env._GENERALTRANSLATION_I18N_CONFIG_PARAMS);
+	const gt = new GTRuntime({ customMapping: i18nConfig.customMapping });
+	const defaultLocale = i18nConfig.defaultLocale || libraryDefaultLocale;
+	const locales = Array.from(new Set([defaultLocale, ...i18nConfig.locales || []]));
+	const resolvedConfigLocales = /* @__PURE__ */ new Map();
+	const determineLocaleWithCache = (locale) => {
+		const cached = resolvedConfigLocales.get(locale);
+		if (cached !== void 0) return cached;
+		const resolved = gt.determineLocale(locale, locales) ?? locale;
+		resolvedConfigLocales.set(locale, resolved);
+		return resolved;
+	};
+	const resolvePathConfigLocale = process.env._GENERALTRANSLATION_GT_SERVICES_ENABLED === "true" ? determineLocaleWithCache : (locale) => locale;
+	const headersAndCookies = i18nConfig.headersAndCookies || {};
+	const localeRoutingEnabledCookieName = headersAndCookies?.localeRoutingEnabledCookieName || "generaltranslation.locale-routing-enabled";
+	const referrerLocaleCookieName = headersAndCookies?.referrerLocaleCookieName || "generaltranslation.referrer-locale";
+	const localeCookieName = headersAndCookies?.localeCookieName || defaultLocaleCookieName;
+	const resetLocaleCookieName = headersAndCookies?.resetLocaleCookieName || defaultResetLocaleCookieName;
+	const localeHeaderName = headersAndCookies?.localeHeaderName || "x-generaltranslation-locale";
+	if (!gt.isValidLocale(defaultLocale)) throw new Error(`gt-next middleware: defaultLocale "${defaultLocale}" is not a valid locale.`);
+	const warningLocales = locales.filter((locale) => !gt.isValidLocale(locale));
+	if (warningLocales.length) console.warn(createUnsupportedLocalesWarning(warningLocales));
+	const pathConfig = Object.entries(inputPathConfig).reduce((acc, [sharedPath, localizedPath]) => {
+		if (typeof localizedPath === "string") acc[sharedPath] = localizedPath;
+		else acc[sharedPath] = Object.entries(localizedPath).reduce((acc, [locale, localizedPath]) => {
+			acc[resolvePathConfigLocale(locale)] = localizedPath;
+			return acc;
+		}, {});
+		return acc;
+	}, {});
+	const { pathToSharedPath, defaultLocalePaths } = createPathToSharedPathMap(Object.fromEntries(Object.entries(pathConfig).map(([sharedPath, localizedPath]) => [sharedPath, typeof localizedPath === "string" ? Object.fromEntries(locales.map((locale) => [determineLocaleWithCache(locale), localizedPath === "" ? "/" : localizedPath])) : localizedPath])), prefixDefaultLocale, defaultLocale);
+	const routeOverrides = Object.entries(inputRouteOverrides).reduce((acc, [locale, paths]) => {
+		acc[resolvePathConfigLocale(locale)] = paths;
+		return acc;
+	}, {});
+	return {
+		pathRegex,
+		gt,
+		defaultLocale,
+		locales,
+		localeRoutingEnabledCookieName,
+		referrerLocaleCookieName,
+		localeCookieName,
+		resetLocaleCookieName,
+		localeHeaderName,
+		pathConfig,
+		pathToSharedPath,
+		defaultLocalePaths,
+		routeOverridePathMaps: Object.entries(routeOverrides).reduce((acc, [locale, paths]) => {
+			acc[locale] = createPathToSharedPathMap(Object.fromEntries(paths.map((path) => [path, path])), true, defaultLocale).pathToSharedPath;
+			return acc;
+		}, {}),
+		localeRoutePathMaps: new Map(Object.entries(localeRoutes).map(([locale, paths]) => {
+			return [determineLocaleWithCache(locale), createPathMatcher(paths.map((path) => [path, path]))];
+		}))
+	};
+}
+//#endregion
+export { createMiddlewareRouting };
+
+//# sourceMappingURL=createMiddlewareRouting.mjs.map

package/dist/middleware-dir/createMiddlewareRouting.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createMiddlewareRouting.mjs","names":[],"sources":["../../src/middleware-dir/createMiddlewareRouting.ts"],"sourcesContent":["import { GTRuntime } from 'generaltranslation/runtime';\nimport { libraryDefaultLocale } from 'generaltranslation/internal';\nimport {\n  defaultLocaleCookieName,\n  defaultResetLocaleCookieName,\n} from '@generaltranslation/react-core/pure';\nimport { createUnsupportedLocalesWarning } from '../errors/middleware';\nimport {\n  defaultLocaleRoutingEnabledCookieName,\n  defaultReferrerLocaleCookieName,\n} from '../utils/cookies';\nimport { defaultLocaleHeaderName } from '../utils/headers';\nimport { compilePathRegex } from '../utils/pathRegex';\nimport {\n  createPathMatcher,\n  createPathToSharedPathMap,\n  type PathConfig,\n  type PathMatcher,\n} from './createPathMatcher';\nimport { parseEnvConfig } from './resolveMiddlewareConfig';\nimport type {\n  MiddlewareI18nConfig,\n  MiddlewareRouting,\n  ResolvedMiddlewareConfig,\n  RouteOverrides,\n} from './types';\n\n/**\n * Pre-processes the locale, cookie, and path configuration once per\n * middleware instance so requests only do lookups.\n */\nexport function createMiddlewareRouting({\n  pathConfig: inputPathConfig,\n  routeOverrides: inputRouteOverrides,\n  localeRoutes,\n  prefixDefaultLocale,\n}: ResolvedMiddlewareConfig): MiddlewareRouting {\n  const pathRegex = compilePathRegex(\n    process.env._GENERALTRANSLATION_PATH_REGEX\n  );\n\n  // i18n config\n  const i18nConfig = parseEnvConfig<MiddlewareI18nConfig>(\n    '_GENERALTRANSLATION_I18N_CONFIG_PARAMS',\n    process.env._GENERALTRANSLATION_I18N_CONFIG_PARAMS\n  );\n\n  // gt instance\n  const gt = new GTRuntime({\n    customMapping: i18nConfig.customMapping,\n  });\n\n  // Configured spellings are the identity used by routes, cookies and caches.\n  const defaultLocale: string =\n    i18nConfig.defaultLocale || libraryDefaultLocale;\n  const locales = Array.from(\n    new Set([defaultLocale, ...(i18nConfig.locales || [])])\n  );\n  // Route entries repeat locale keys. Resolve each key once per factory instead\n  // of rebuilding the full locale-resolution index for every route/locale pair.\n  const resolvedConfigLocales = new Map<string, string>();\n  const determineLocaleWithCache = (locale: string) => {\n    const cached = resolvedConfigLocales.get(locale);\n    if (cached !== undefined) return cached;\n    const resolved = gt.determineLocale(locale, locales) ?? locale;\n    resolvedConfigLocales.set(locale, resolved);\n    return resolved;\n  };\n  const resolvePathConfigLocale =\n    process.env._GENERALTRANSLATION_GT_SERVICES_ENABLED === 'true'\n      ? determineLocaleWithCache\n      : (locale: string) => locale;\n\n  // cookies and header names\n  const headersAndCookies = i18nConfig.headersAndCookies || {};\n  const localeRoutingEnabledCookieName =\n    headersAndCookies?.localeRoutingEnabledCookieName ||\n    defaultLocaleRoutingEnabledCookieName;\n  const referrerLocaleCookieName =\n    headersAndCookies?.referrerLocaleCookieName ||\n    defaultReferrerLocaleCookieName;\n  const localeCookieName =\n    headersAndCookies?.localeCookieName || defaultLocaleCookieName;\n  const resetLocaleCookieName =\n    headersAndCookies?.resetLocaleCookieName || defaultResetLocaleCookieName;\n  const localeHeaderName =\n    headersAndCookies?.localeHeaderName || defaultLocaleHeaderName;\n\n  if (!gt.isValidLocale(defaultLocale))\n    throw new Error(\n      `gt-next middleware: defaultLocale \"${defaultLocale}\" is not a valid locale.`\n    );\n\n  const warningLocales = locales.filter((locale) => !gt.isValidLocale(locale));\n  if (warningLocales.length)\n    console.warn(createUnsupportedLocalesWarning(warningLocales));\n\n  // --- localized routes --- //\n  // Resolve pathConfig keys to the configured locale spelling.\n  const pathConfig = Object.entries(inputPathConfig).reduce<PathConfig>(\n    (acc, [sharedPath, localizedPath]) => {\n      if (typeof localizedPath === 'string') {\n        acc[sharedPath] = localizedPath;\n      } else {\n        acc[sharedPath] = Object.entries(localizedPath).reduce<{\n          [key: string]: string;\n        }>((acc, [locale, localizedPath]) => {\n          acc[resolvePathConfigLocale(locale)] = localizedPath;\n          return acc;\n        }, {});\n      }\n      return acc;\n    },\n    {}\n  );\n\n  // String aliases apply to every locale, including the default locale.\n  // Expand a copy for lookup while retaining string target semantics in routing.\n  const matcherPathConfig = Object.fromEntries(\n    Object.entries(pathConfig).map(([sharedPath, localizedPath]) => [\n      sharedPath,\n      typeof localizedPath === 'string'\n        ? Object.fromEntries(\n            locales.map((locale) => [\n              determineLocaleWithCache(locale),\n              localizedPath === '' ? '/' : localizedPath,\n            ])\n          )\n        : localizedPath,\n    ])\n  );\n\n  // Create the path mapping\n  const { pathToSharedPath, defaultLocalePaths } = createPathToSharedPathMap(\n    matcherPathConfig,\n    prefixDefaultLocale,\n    defaultLocale\n  );\n\n  // --- route overrides --- //\n  // Resolve routeOverrides keys to the configured locale spelling.\n  const routeOverrides = Object.entries(\n    inputRouteOverrides\n  ).reduce<RouteOverrides>((acc, [locale, paths]) => {\n    acc[resolvePathConfigLocale(locale)] = paths;\n    return acc;\n  }, {});\n\n  // Create the route override path mapping\n  const routeOverridePathMaps = Object.entries(routeOverrides).reduce<\n    Record<string, PathMatcher>\n  >((acc, [locale, paths]) => {\n    const overridePathConfig = Object.fromEntries(\n      paths.map((path) => [path, path])\n    );\n    acc[locale] = createPathToSharedPathMap(\n      overridePathConfig,\n      true,\n      defaultLocale\n    ).pathToSharedPath;\n    return acc;\n  }, {});\n\n  // --- locale routes --- //\n  // Compile availability separately from aliases and overrides so it cannot\n  // change route precedence. An empty list deliberately matches nothing.\n  const localeRoutePathMaps = new Map(\n    Object.entries(localeRoutes).map(([locale, paths]) => {\n      // Match request resolution so equivalent spellings use the same map key.\n      const resolvedLocale = determineLocaleWithCache(locale);\n      return [\n        resolvedLocale,\n        createPathMatcher(paths.map((path) => [path, path])),\n      ];\n    })\n  );\n\n  return {\n    pathRegex,\n    gt,\n    defaultLocale,\n    locales,\n    localeRoutingEnabledCookieName,\n    referrerLocaleCookieName,\n    localeCookieName,\n    resetLocaleCookieName,\n    localeHeaderName,\n    pathConfig,\n    pathToSharedPath,\n    defaultLocalePaths,\n    routeOverridePathMaps,\n    localeRoutePathMaps,\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;AA+BA,SAAgB,wBAAwB,EACtC,YAAY,iBACZ,gBAAgB,qBAChB,cACA,uBAC8C;CAC9C,MAAM,YAAY,iBAChB,QAAQ,IAAI,+BACb;CAGD,MAAM,aAAa,eACjB,0CACA,QAAQ,IAAI,uCACb;CAGD,MAAM,KAAK,IAAI,UAAU,EACvB,eAAe,WAAW,eAC3B,CAAC;CAGF,MAAM,gBACJ,WAAW,iBAAiB;CAC9B,MAAM,UAAU,MAAM,KACpB,IAAI,IAAI,CAAC,eAAe,GAAI,WAAW,WAAW,EAAE,CAAE,CAAC,CACxD;CAGD,MAAM,wCAAwB,IAAI,KAAqB;CACvD,MAAM,4BAA4B,WAAmB;EACnD,MAAM,SAAS,sBAAsB,IAAI,OAAO;AAChD,MAAI,WAAW,KAAA,EAAW,QAAO;EACjC,MAAM,WAAW,GAAG,gBAAgB,QAAQ,QAAQ,IAAI;AACxD,wBAAsB,IAAI,QAAQ,SAAS;AAC3C,SAAO;;CAET,MAAM,0BACJ,QAAQ,IAAI,4CAA4C,SACpD,4BACC,WAAmB;CAG1B,MAAM,oBAAoB,WAAW,qBAAqB,EAAE;CAC5D,MAAM,iCACJ,mBAAmB,kCAAA;CAErB,MAAM,2BACJ,mBAAmB,4BAAA;CAErB,MAAM,mBACJ,mBAAmB,oBAAoB;CACzC,MAAM,wBACJ,mBAAmB,yBAAyB;CAC9C,MAAM,mBACJ,mBAAmB,oBAAA;AAErB,KAAI,CAAC,GAAG,cAAc,cAAc,CAClC,OAAM,IAAI,MACR,sCAAsC,cAAc,0BACrD;CAEH,MAAM,iBAAiB,QAAQ,QAAQ,WAAW,CAAC,GAAG,cAAc,OAAO,CAAC;AAC5E,KAAI,eAAe,OACjB,SAAQ,KAAK,gCAAgC,eAAe,CAAC;CAI/D,MAAM,aAAa,OAAO,QAAQ,gBAAgB,CAAC,QAChD,KAAK,CAAC,YAAY,mBAAmB;AACpC,MAAI,OAAO,kBAAkB,SAC3B,KAAI,cAAc;MAElB,KAAI,cAAc,OAAO,QAAQ,cAAc,CAAC,QAE5C,KAAK,CAAC,QAAQ,mBAAmB;AACnC,OAAI,wBAAwB,OAAO,IAAI;AACvC,UAAO;KACN,EAAE,CAAC;AAER,SAAO;IAET,EAAE,CACH;CAmBD,MAAM,EAAE,kBAAkB,uBAAuB,0BAfvB,OAAO,YAC/B,OAAO,QAAQ,WAAW,CAAC,KAAK,CAAC,YAAY,mBAAmB,CAC9D,YACA,OAAO,kBAAkB,WACrB,OAAO,YACL,QAAQ,KAAK,WAAW,CACtB,yBAAyB,OAAO,EAChC,kBAAkB,KAAK,MAAM,cAC9B,CAAC,CACH,GACD,cACL,CAAC,CAKe,EACjB,qBACA,cACD;CAID,MAAM,iBAAiB,OAAO,QAC5B,oBACD,CAAC,QAAwB,KAAK,CAAC,QAAQ,WAAW;AACjD,MAAI,wBAAwB,OAAO,IAAI;AACvC,SAAO;IACN,EAAE,CAAC;AA+BN,QAAO;EACL;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA,uBAzC4B,OAAO,QAAQ,eAAe,CAAC,QAE1D,KAAK,CAAC,QAAQ,WAAW;AAI1B,OAAI,UAAU,0BAHa,OAAO,YAChC,MAAM,KAAK,SAAS,CAAC,MAAM,KAAK,CAAC,CAGf,EAClB,MACA,cACD,CAAC;AACF,UAAO;KACN,EAAE,CA6BkB;EACrB,qBAAA,IAzB8B,IAC9B,OAAO,QAAQ,aAAa,CAAC,KAAK,CAAC,QAAQ,WAAW;AAGpD,UAAO,CADgB,yBAAyB,OAEhC,EACd,kBAAkB,MAAM,KAAK,SAAS,CAAC,MAAM,KAAK,CAAC,CAAC,CACrD;IACD,CAiBiB;EACpB"}

package/dist/middleware-dir/createNextMiddleware.d.ts

@@ -1,8 +1,7 @@
 import { NextResponse } from 'next/server';
 import type { NextRequest } from 'next/server';
-import { type PathConfig } from './utils';
-export type RouteOverrides = Record<string, readonly string[]>;
-export type LocaleRoutes = Record<string, readonly string[]>;
+import type { MiddlewareConfig } from './types';
+export type { RouteOverrides, LocaleRoutes } from './types';
 /**
  * Middleware factory to create a Next.js middleware for i18n routing and locale detection.
  *
@@ -11,6 +10,8 @@ export type LocaleRoutes = Record<string, readonly string[]>;
  * If locale routing is enabled, it redirects to the localized pathname and
  * updates the locale cookie.
  *
+ * Options omitted here fall back to the same options passed to `withGTConfig()`.
+ *
  * @param {boolean} [config.localeRouting=true] - Flag to enable or disable automatic locale-based routing.
  * @param {boolean} [config.prefixDefaultLocale=false] - Flag to enable or disable prefixing the default locale to the pathname, i.e., /en/about -> /about
  * @param {boolean} [config.enableSmartRouting=true] - Keep automatic locale negotiation. Disable to treat returning visitors' unprefixed URLs as default-locale routes.
@@ -20,13 +21,5 @@ export type LocaleRoutes = Record<string, readonly string[]>;
  * @param {LocaleRoutes} [config.localeRoutes] - Shared paths available per locale; other paths fall back to the default locale
  * @returns {function} - A middleware function that processes the request and response.
  */
-export declare function createNextMiddleware({ localeRouting, prefixDefaultLocale, enableSmartRouting, ignoreSourceMaps, pathConfig, routeOverrides, localeRoutes, }?: {
-    localeRouting?: boolean;
-    prefixDefaultLocale?: boolean;
-    enableSmartRouting?: boolean;
-    ignoreSourceMaps?: boolean;
-    pathConfig?: PathConfig;
-    routeOverrides?: RouteOverrides;
-    localeRoutes?: LocaleRoutes;
-}): (req: NextRequest) => NextResponse<unknown>;
+export declare function createNextMiddleware(options?: MiddlewareConfig): (req: NextRequest) => NextResponse<unknown>;
 //# sourceMappingURL=createNextMiddleware.d.ts.map