@intlayer/core 9.3.1 → 9.3.3

package/dist/esm/localization/domainUtils.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"domainUtils.mjs","names":[],"sources":["../../../src/localization/domainUtils.ts"],"sourcesContent":["import type { Locale } from '@intlayer/types/allLocales';\nimport type { RoutingConfig } from '@intlayer/types/config';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\n\n/**\n * The locale → domain map configured under `routing.domains`\n * (e.g. `{ en: 'intlayer.org', zh: 'intlayer.cn' }`).\n */\nexport type LocaleDomainMap = RoutingConfig['domains'];\n\n/**\n * Strips the protocol from a domain string and returns only the hostname.\n *\n * Example:\n *\n * ```ts\n * getDomainHostname('https://intlayer.cn') // 'intlayer.cn'\n * getDomainHostname('intlayer.cn')         // 'intlayer.cn'\n * ```\n *\n * @param domain - A domain value from `routing.domains`, with or without protocol.\n * @returns The bare hostname.\n */\nexport const getDomainHostname = (domain: string): string => {\n  try {\n    return /^https?:\\/\\//.test(domain) ? new URL(domain).hostname : domain;\n  } catch {\n    return domain;\n  }\n};\n\n/**\n * Returns the absolute origin for a domain value, prepending `https://`\n * when no protocol is present.\n *\n * Example:\n *\n * ```ts\n * getDomainOrigin('intlayer.cn')        // 'https://intlayer.cn'\n * getDomainOrigin('http://intlayer.cn') // 'http://intlayer.cn'\n * ```\n *\n * @param domain - A domain value from `routing.domains`, with or without protocol.\n * @returns The origin usable as a URL base.\n */\nexport const getDomainOrigin = (domain: string): string =>\n  /^https?:\\/\\//.test(domain) ? domain : `https://${domain}`;\n\n/**\n * Returns the locale exclusively mapped to a given hostname via `routing.domains`,\n * or `undefined` when zero or more than one locale share that hostname.\n *\n * Example: with `domains = { zh: 'intlayer.cn', en: 'intlayer.org', fr: 'intlayer.org' }`\n *\n * ```ts\n * getLocaleFromDomain('intlayer.cn', domains)  // 'zh'\n * getLocaleFromDomain('intlayer.org', domains) // undefined (en and fr share it)\n * getLocaleFromDomain('example.com', domains)  // undefined (not mapped)\n * ```\n *\n * @param hostname - The bare hostname of the incoming request.\n * @param domains - The configured locale → domain map.\n * @returns The exclusively mapped locale, or `undefined`.\n */\nexport const getLocaleFromDomain = (\n  hostname: string,\n  domains: LocaleDomainMap\n): Locale | undefined => {\n  if (!domains) return undefined;\n\n  const matchingLocales = Object.entries(domains).filter(\n    ([, domain]) =>\n      typeof domain === 'string' && getDomainHostname(domain) === hostname\n  );\n\n  return matchingLocales.length === 1\n    ? (matchingLocales[0]?.[0] as Locale)\n    : undefined;\n};\n\n/**\n * Checks whether a locale is the only locale mapped to its configured domain.\n * When true, the domain alone identifies the locale and no URL prefix is needed.\n * Hostnames are compared after protocol stripping, so\n * `{ en: 'https://intlayer.org', fr: 'intlayer.org' }` counts as a shared domain.\n *\n * @param locale - The locale to check.\n * @param domains - The configured locale → domain map.\n * @returns `true` when the locale has a domain shared with no other locale.\n */\nexport const isLocaleExclusiveOnDomain = (\n  locale: LocalesValues,\n  domains: LocaleDomainMap\n): boolean => {\n  const localeDomain = domains?.[locale];\n\n  if (!localeDomain) return false;\n\n  const localeHostname = getDomainHostname(localeDomain);\n\n  const localesOnSameDomain = Object.values(domains).filter(\n    (domain) =>\n      typeof domain === 'string' && getDomainHostname(domain) === localeHostname\n  ).length;\n\n  return localesOnSameDomain === 1;\n};\n"],"mappings":";;;;;;;;;;;;;;AAuBA,MAAa,qBAAqB,WAA2B;CAC3D,IAAI;EACF,OAAO,eAAe,KAAK,MAAM,IAAI,IAAI,IAAI,MAAM,CAAC,CAAC,WAAW;CAClE,QAAQ;EACN,OAAO;CACT;AACF;;;;;;;;;;;;;;;AAgBA,MAAa,mBAAmB,WAC9B,eAAe,KAAK,MAAM,IAAI,SAAS,WAAW;;;;;;;;;;;;;;;;;AAkBpD,MAAa,uBACX,UACA,YACuB;CACvB,IAAI,CAAC,SAAS,OAAO;CAErB,MAAM,kBAAkB,OAAO,QAAQ,OAAO,CAAC,CAAC,QAC7C,GAAG,YACF,OAAO,WAAW,YAAY,kBAAkB,MAAM,MAAM,QAChE;CAEA,OAAO,gBAAgB,WAAW,IAC7B,gBAAgB,EAAE,GAAG,KACtB;AACN;;;;;;;;;;;AAYA,MAAa,6BACX,QACA,YACY;CACZ,MAAM,eAAe,UAAU;CAE/B,IAAI,CAAC,cAAc,OAAO;CAE1B,MAAM,iBAAiB,kBAAkB,YAAY;CAOrD,OAL4B,OAAO,OAAO,OAAO,CAAC,CAAC,QAChD,WACC,OAAO,WAAW,YAAY,kBAAkB,MAAM,MAAM,cAChE,CAAC,CAAC,WAE6B;AACjC"}
+{"version":3,"file":"domainUtils.mjs","names":[],"sources":["../../../src/localization/domainUtils.ts"],"sourcesContent":["import type { RoutingConfig } from '@intlayer/types/config';\nimport type {\n  DeclaredLocales,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\n\n/**\n * The locale → domain map configured under `routing.domains`\n * (e.g. `{ en: 'intlayer.org', zh: 'intlayer.cn' }`).\n */\nexport type LocaleDomainMap = RoutingConfig['domains'];\n\n/**\n * Strips the protocol from a domain string and returns only the hostname.\n *\n * Example:\n *\n * ```ts\n * getDomainHostname('https://intlayer.cn') // 'intlayer.cn'\n * getDomainHostname('intlayer.cn')         // 'intlayer.cn'\n * ```\n *\n * @param domain - A domain value from `routing.domains`, with or without protocol.\n * @returns The bare hostname.\n */\nexport const getDomainHostname = (domain: string): string => {\n  try {\n    return /^https?:\\/\\//.test(domain) ? new URL(domain).hostname : domain;\n  } catch {\n    return domain;\n  }\n};\n\n/**\n * Returns the absolute origin for a domain value, prepending `https://`\n * when no protocol is present.\n *\n * Example:\n *\n * ```ts\n * getDomainOrigin('intlayer.cn')        // 'https://intlayer.cn'\n * getDomainOrigin('http://intlayer.cn') // 'http://intlayer.cn'\n * ```\n *\n * @param domain - A domain value from `routing.domains`, with or without protocol.\n * @returns The origin usable as a URL base.\n */\nexport const getDomainOrigin = (domain: string): string =>\n  /^https?:\\/\\//.test(domain) ? domain : `https://${domain}`;\n\n/**\n * Returns the locale exclusively mapped to a given hostname via `routing.domains`,\n * or `undefined` when zero or more than one locale share that hostname.\n *\n * Example: with `domains = { zh: 'intlayer.cn', en: 'intlayer.org', fr: 'intlayer.org' }`\n *\n * ```ts\n * getLocaleFromDomain('intlayer.cn', domains)  // 'zh'\n * getLocaleFromDomain('intlayer.org', domains) // undefined (en and fr share it)\n * getLocaleFromDomain('example.com', domains)  // undefined (not mapped)\n * ```\n *\n * @param hostname - The bare hostname of the incoming request.\n * @param domains - The configured locale → domain map.\n * @returns The exclusively mapped locale, or `undefined`.\n */\nexport const getLocaleFromDomain = (\n  hostname: string,\n  domains: LocaleDomainMap\n): DeclaredLocales | undefined => {\n  if (!domains) return undefined;\n\n  const matchingLocales = Object.entries(domains).filter(\n    ([, domain]) =>\n      typeof domain === 'string' && getDomainHostname(domain) === hostname\n  );\n\n  return matchingLocales.length === 1\n    ? (matchingLocales[0]?.[0] as DeclaredLocales)\n    : undefined;\n};\n\n/**\n * Checks whether a locale is the only locale mapped to its configured domain.\n * When true, the domain alone identifies the locale and no URL prefix is needed.\n * Hostnames are compared after protocol stripping, so\n * `{ en: 'https://intlayer.org', fr: 'intlayer.org' }` counts as a shared domain.\n *\n * @param locale - The locale to check.\n * @param domains - The configured locale → domain map.\n * @returns `true` when the locale has a domain shared with no other locale.\n */\nexport const isLocaleExclusiveOnDomain = (\n  locale: LocalesValues,\n  domains: LocaleDomainMap\n): boolean => {\n  const localeDomain = domains?.[locale];\n\n  if (!localeDomain) return false;\n\n  const localeHostname = getDomainHostname(localeDomain);\n\n  const localesOnSameDomain = Object.values(domains).filter(\n    (domain) =>\n      typeof domain === 'string' && getDomainHostname(domain) === localeHostname\n  ).length;\n\n  return localesOnSameDomain === 1;\n};\n"],"mappings":";;;;;;;;;;;;;;AAyBA,MAAa,qBAAqB,WAA2B;CAC3D,IAAI;EACF,OAAO,eAAe,KAAK,MAAM,IAAI,IAAI,IAAI,MAAM,CAAC,CAAC,WAAW;CAClE,QAAQ;EACN,OAAO;CACT;AACF;;;;;;;;;;;;;;;AAgBA,MAAa,mBAAmB,WAC9B,eAAe,KAAK,MAAM,IAAI,SAAS,WAAW;;;;;;;;;;;;;;;;;AAkBpD,MAAa,uBACX,UACA,YACgC;CAChC,IAAI,CAAC,SAAS,OAAO;CAErB,MAAM,kBAAkB,OAAO,QAAQ,OAAO,CAAC,CAAC,QAC7C,GAAG,YACF,OAAO,WAAW,YAAY,kBAAkB,MAAM,MAAM,QAChE;CAEA,OAAO,gBAAgB,WAAW,IAC7B,gBAAgB,EAAE,GAAG,KACtB;AACN;;;;;;;;;;;AAYA,MAAa,6BACX,QACA,YACY;CACZ,MAAM,eAAe,UAAU;CAE/B,IAAI,CAAC,cAAc,OAAO;CAE1B,MAAM,iBAAiB,kBAAkB,YAAY;CAOrD,OAL4B,OAAO,OAAO,OAAO,CAAC,CAAC,QAChD,WACC,OAAO,WAAW,YAAY,kBAAkB,MAAM,MAAM,cAChE,CAAC,CAAC,WAE6B;AACjC"}

package/dist/esm/localization/getHTMLTextDir.mjs

@@ -1,4 +1,14 @@
 //#region src/localization/getHTMLTextDir.ts
+const rtlScripts = [
+	"Arab",
+	"Hebr",
+	"Thaa",
+	"Syrc",
+	"Mand",
+	"Adlm",
+	"Rohg",
+	"Nkoo"
+];
 /**
 * Returns the text direction of the given locale.
 *
@@ -19,16 +29,7 @@ const getHTMLTextDir = (locale) => {
 		if ("getTextInfo" in localeInfo) return localeInfo.getTextInfo().direction;
 		if ("textInfo" in localeInfo) return localeInfo.textInfo.direction;
 		const maximized = localeInfo.maximize();
-		return [
-			"Arab",
-			"Hebr",
-			"Thaa",
-			"Syrc",
-			"Mand",
-			"Adlm",
-			"Rohg",
-			"Nkoo"
-		].includes(maximized.script ?? "") ? "rtl" : "ltr";
+		return rtlScripts.includes(maximized.script ?? "") ? "rtl" : "ltr";
 	} catch {
 		return "ltr";
 	}

package/dist/esm/localization/getHTMLTextDir.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"getHTMLTextDir.mjs","names":[],"sources":["../../../src/localization/getHTMLTextDir.ts"],"sourcesContent":["import type { LocalesValues } from '@intlayer/types/module_augmentation';\n\ntype Dir = 'ltr' | 'rtl' | 'auto';\n\n/**\n * Returns the text direction of the given locale.\n *\n * Example:\n *\n * getHTMLTextDir('en-US') // 'ltr'\n * getHTMLTextDir('en') // 'ltr'\n * getHTMLTextDir('fr-CA') // 'ltr'\n * getHTMLTextDir('fr') // 'ltr'\n *\n * @param locale The locale to get the text direction for.\n * @returns The text direction of the given locale.\n */\nexport const getHTMLTextDir = (locale?: LocalesValues): Dir => {\n  if (!locale) return 'ltr';\n\n  try {\n    const localeInfo = new Intl.Locale(locale);\n\n    // Check for the 'textInfo' property (part of the Intl Enumeration API)\n    // Most modern browsers support 'direction' via 'getTextInfo()' or 'textInfo'\n    if ('getTextInfo' in localeInfo) {\n      return (localeInfo as any).getTextInfo().direction as Dir;\n    }\n\n    // Fallback for environments supporting 'textInfo' property\n    if ('textInfo' in localeInfo) {\n      return (localeInfo as any).textInfo.direction as Dir;\n    }\n\n    // Manual fallback for older environments using script detection\n    const maximized = localeInfo.maximize();\n    const rtlScripts = [\n      'Arab',\n      'Hebr',\n      'Thaa',\n      'Syrc',\n      'Mand',\n      'Adlm',\n      'Rohg',\n      'Nkoo',\n    ];\n\n    return rtlScripts.includes(maximized.script ?? '') ? 'rtl' : 'ltr';\n  } catch {\n    return 'ltr';\n  }\n};\n"],"mappings":";;;;;;;;;;;;;;AAiBA,MAAa,kBAAkB,WAAgC;CAC7D,IAAI,CAAC,QAAQ,OAAO;CAEpB,IAAI;EACF,MAAM,aAAa,IAAI,KAAK,OAAO,MAAM;EAIzC,IAAI,iBAAiB,YACnB,OAAQ,WAAmB,YAAY,CAAC,CAAC;EAI3C,IAAI,cAAc,YAChB,OAAQ,WAAmB,SAAS;EAItC,MAAM,YAAY,WAAW,SAAS;EAYtC,OAAO;GAVL;GACA;GACA;GACA;GACA;GACA;GACA;GACA;EAGc,CAAC,CAAC,SAAS,UAAU,UAAU,EAAE,IAAI,QAAQ;CAC/D,QAAQ;EACN,OAAO;CACT;AACF"}
+{"version":3,"file":"getHTMLTextDir.mjs","names":[],"sources":["../../../src/localization/getHTMLTextDir.ts"],"sourcesContent":["import type { LocalesValues } from '@intlayer/types/module_augmentation';\n\ntype Dir = 'ltr' | 'rtl' | 'auto';\n\nconst rtlScripts = [\n  'Arab',\n  'Hebr',\n  'Thaa',\n  'Syrc',\n  'Mand',\n  'Adlm',\n  'Rohg',\n  'Nkoo',\n];\n\n/**\n * Returns the text direction of the given locale.\n *\n * Example:\n *\n * getHTMLTextDir('en-US') // 'ltr'\n * getHTMLTextDir('en') // 'ltr'\n * getHTMLTextDir('fr-CA') // 'ltr'\n * getHTMLTextDir('fr') // 'ltr'\n *\n * @param locale The locale to get the text direction for.\n * @returns The text direction of the given locale.\n */\nexport const getHTMLTextDir = (locale?: LocalesValues): Dir => {\n  if (!locale) return 'ltr';\n\n  try {\n    const localeInfo = new Intl.Locale(locale);\n\n    // Check for the 'textInfo' property (part of the Intl Enumeration API)\n    // Most modern browsers support 'direction' via 'getTextInfo()' or 'textInfo'\n    if ('getTextInfo' in localeInfo) {\n      return (localeInfo as any).getTextInfo().direction as Dir;\n    }\n\n    // Fallback for environments supporting 'textInfo' property\n    if ('textInfo' in localeInfo) {\n      return (localeInfo as any).textInfo.direction as Dir;\n    }\n\n    // Manual fallback for older environments using script detection\n    const maximized = (localeInfo as Intl.Locale).maximize();\n\n    return rtlScripts.includes(maximized.script ?? '') ? 'rtl' : 'ltr';\n  } catch {\n    return 'ltr';\n  }\n};\n"],"mappings":";AAIA,MAAM,aAAa;CACjB;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF;;;;;;;;;;;;;;AAeA,MAAa,kBAAkB,WAAgC;CAC7D,IAAI,CAAC,QAAQ,OAAO;CAEpB,IAAI;EACF,MAAM,aAAa,IAAI,KAAK,OAAO,MAAM;EAIzC,IAAI,iBAAiB,YACnB,OAAQ,WAAmB,YAAY,CAAC,CAAC;EAI3C,IAAI,cAAc,YAChB,OAAQ,WAAmB,SAAS;EAItC,MAAM,YAAa,WAA2B,SAAS;EAEvD,OAAO,WAAW,SAAS,UAAU,UAAU,EAAE,IAAI,QAAQ;CAC/D,QAAQ;EACN,OAAO;CACT;AACF"}

package/dist/esm/localization/getLocale.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"getLocale.mjs","names":[],"sources":["../../../src/localization/getLocale.ts"],"sourcesContent":["import { internationalization } from '@intlayer/config/built';\nimport { DEFAULT_LOCALE, LOCALES } from '@intlayer/config/defaultValues';\nimport type { Locale } from '@intlayer/types/allLocales';\nimport { getLocaleFromStorageServer } from '../utils/localeStorage';\nimport { getPreferredLanguages } from './localeDetector';\nimport { localeResolver } from './localeResolver';\n\nexport type RequestContext = {\n  getHeader?: (name: string) => string | null | undefined;\n  getCookie?: (name: string) => string | null | undefined;\n};\n\nexport const getLocale = async (ctx: RequestContext = {}): Promise<Locale> => {\n  const defaultLocale = internationalization?.defaultLocale ?? DEFAULT_LOCALE;\n  const availableLocales = internationalization?.locales ?? LOCALES;\n\n  // Try locale from storage (cookie or header)\n  const storedLocale = getLocaleFromStorageServer({\n    getCookie: ctx.getCookie,\n    getHeader: ctx.getHeader,\n  });\n\n  if (storedLocale) {\n    return storedLocale;\n  }\n\n  // Fallback to Accept-Language negotiation\n  const acceptLanguageHeader = ctx.getHeader?.('accept-language');\n\n  if (!acceptLanguageHeader) {\n    return defaultLocale;\n  }\n\n  const preferredLocaleStrings = getPreferredLanguages(\n    acceptLanguageHeader,\n    availableLocales\n  );\n\n  const userFallbackLocale = localeResolver(\n    preferredLocaleStrings,\n    availableLocales,\n    defaultLocale\n  );\n\n  if (userFallbackLocale) {\n    return userFallbackLocale;\n  }\n\n  // Default locale\n  return defaultLocale;\n};\n"],"mappings":";;;;;;;AAYA,MAAa,YAAY,OAAO,MAAsB,CAAC,MAAuB;CAC5E,MAAM,gBAAgB,sBAAsB,iBAAiB;CAC7D,MAAM,mBAAmB,sBAAsB,WAAW;CAG1D,MAAM,eAAe,2BAA2B;EAC9C,WAAW,IAAI;EACf,WAAW,IAAI;CACjB,CAAC;CAED,IAAI,cACF,OAAO;CAIT,MAAM,uBAAuB,IAAI,YAAY,iBAAiB;CAE9D,IAAI,CAAC,sBACH,OAAO;CAGT,MAAM,yBAAyB,sBAC7B,sBACA,gBACF;CAEA,MAAM,qBAAqB,eACzB,wBACA,kBACA,aACF;CAEA,IAAI,oBACF,OAAO;CAIT,OAAO;AACT"}
+{"version":3,"file":"getLocale.mjs","names":[],"sources":["../../../src/localization/getLocale.ts"],"sourcesContent":["import { internationalization } from '@intlayer/config/built';\nimport { DEFAULT_LOCALE, LOCALES } from '@intlayer/config/defaultValues';\nimport type { DeclaredLocales } from '@intlayer/types/module_augmentation';\nimport { getLocaleFromStorageServer } from '../utils/localeStorage';\nimport { getPreferredLanguages } from './localeDetector';\nimport { localeResolver } from './localeResolver';\n\nexport type RequestContext = {\n  getHeader?: (name: string) => string | null | undefined;\n  getCookie?: (name: string) => string | null | undefined;\n};\n\nexport const getLocale = async (\n  ctx: RequestContext = {}\n): Promise<DeclaredLocales> => {\n  const defaultLocale = internationalization?.defaultLocale ?? DEFAULT_LOCALE;\n  const availableLocales = internationalization?.locales ?? LOCALES;\n\n  // Try locale from storage (cookie or header)\n  const storedLocale = getLocaleFromStorageServer({\n    getCookie: ctx.getCookie,\n    getHeader: ctx.getHeader,\n  });\n\n  if (storedLocale) {\n    return storedLocale;\n  }\n\n  // Fallback to Accept-Language negotiation\n  const acceptLanguageHeader = ctx.getHeader?.('accept-language');\n\n  if (!acceptLanguageHeader) {\n    return defaultLocale;\n  }\n\n  const preferredLocaleStrings = getPreferredLanguages(\n    acceptLanguageHeader,\n    availableLocales\n  );\n\n  const userFallbackLocale = localeResolver(\n    preferredLocaleStrings,\n    availableLocales,\n    defaultLocale\n  );\n\n  if (userFallbackLocale) {\n    return userFallbackLocale;\n  }\n\n  // Default locale\n  return defaultLocale;\n};\n"],"mappings":";;;;;;;AAYA,MAAa,YAAY,OACvB,MAAsB,CAAC,MACM;CAC7B,MAAM,gBAAgB,sBAAsB,iBAAiB;CAC7D,MAAM,mBAAmB,sBAAsB,WAAW;CAG1D,MAAM,eAAe,2BAA2B;EAC9C,WAAW,IAAI;EACf,WAAW,IAAI;CACjB,CAAC;CAED,IAAI,cACF,OAAO;CAIT,MAAM,uBAAuB,IAAI,YAAY,iBAAiB;CAE9D,IAAI,CAAC,sBACH,OAAO;CAGT,MAAM,yBAAyB,sBAC7B,sBACA,gBACF;CAEA,MAAM,qBAAqB,eACzB,wBACA,kBACA,aACF;CAEA,IAAI,oBACF,OAAO;CAIT,OAAO;AACT"}

package/dist/esm/localization/getLocaleFromPath.mjs

@@ -1,5 +1,5 @@
 import { checkIsURLAbsolute } from "../utils/checkIsURLAbsolute.mjs";
-import { resolveRoutingConfig } from "./getPrefix.mjs";
+import { isDeclaredLocale, resolveRoutingConfig } from "./getPrefix.mjs";
 
 //#region src/localization/getLocaleFromPath.ts
 /**
@@ -19,15 +19,15 @@ const getLocaleFromPath = (inputUrl = "/", options) => {
 	if (!defaultLocale || !locales) return defaultLocale;
 	const isAbsoluteUrl = checkIsURLAbsolute(inputUrl);
 	const fixedInputUrl = inputUrl?.endsWith("/") && inputUrl.length > 1 ? inputUrl.slice(0, -1) : inputUrl;
-	const url = isAbsoluteUrl ? new URL(fixedInputUrl) : new URL(fixedInputUrl, "http://example.com");
+	const url = isAbsoluteUrl ? new URL(fixedInputUrl) : new URL(fixedInputUrl, "http://e.com");
 	if (mode === "search-params") {
 		const localeParam = url.searchParams.get("locale");
-		if (localeParam && locales.includes(localeParam)) return localeParam;
+		if (isDeclaredLocale(localeParam, locales)) return localeParam;
 		return defaultLocale;
 	}
 	if (mode === "no-prefix") return defaultLocale;
 	const firstSegment = url.pathname.split("/")[1];
-	if (firstSegment && locales.includes(firstSegment)) return firstSegment;
+	if (isDeclaredLocale(firstSegment, locales)) return firstSegment;
 	if (mode === "prefix-no-default") return defaultLocale;
 };
 

package/dist/esm/localization/getLocaleFromPath.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"getLocaleFromPath.mjs","names":[],"sources":["../../../src/localization/getLocaleFromPath.ts"],"sourcesContent":["import type { Locale } from '@intlayer/types/allLocales';\nimport { checkIsURLAbsolute } from '../utils/checkIsURLAbsolute';\nimport { type RoutingOptions, resolveRoutingConfig } from './getPrefix';\n\n/**\n * Extracts the locale segment from the given URL or pathname based on the routing mode.\n *\n * Mode Behaviors:\n * - 'prefix-no-default': Checks path prefix. If no prefix found, assumes default locale.\n * - 'prefix-all': Checks path prefix.\n * - 'search-params': Checks for 'locale' query parameter.\n * - 'no-prefix': Returns the default locale.\n *\n * @param inputUrl - The complete URL string or pathname to process.\n * @returns The detected locale, default locale (if fallback/implicit), or undefined.\n */\nexport const getLocaleFromPath = (\n  inputUrl: string = '/',\n  options?: RoutingOptions\n): Locale | undefined => {\n  const { defaultLocale, locales, mode } = resolveRoutingConfig(options);\n\n  if (!defaultLocale || !locales) {\n    return defaultLocale as Locale | undefined;\n  }\n\n  const isAbsoluteUrl = checkIsURLAbsolute(inputUrl);\n  const fixedInputUrl =\n    inputUrl?.endsWith('/') && inputUrl.length > 1\n      ? inputUrl.slice(0, -1)\n      : inputUrl;\n\n  const url = isAbsoluteUrl\n    ? new URL(fixedInputUrl)\n    : new URL(fixedInputUrl, 'http://example.com');\n\n  // Handle 'search-params' mode — locale is in query string\n  if (mode === 'search-params') {\n    const localeParam = url.searchParams.get('locale');\n    if (localeParam && locales.includes(localeParam)) {\n      return localeParam as Locale;\n    }\n    return defaultLocale as Locale;\n  }\n\n  // Handle 'no-prefix' mode — locale is not in the URL\n  if (mode === 'no-prefix') {\n    return defaultLocale as Locale;\n  }\n\n  // Handle prefix modes ('prefix-all' | 'prefix-no-default')\n  const firstSegment = url.pathname.split('/')[1];\n  if (firstSegment && locales.includes(firstSegment)) {\n    return firstSegment as Locale;\n  }\n\n  // In 'prefix-no-default', no prefix implies the default locale\n  if (mode === 'prefix-no-default') {\n    return defaultLocale as Locale;\n  }\n\n  return undefined;\n};\n"],"mappings":";;;;;;;;;;;;;;;;AAgBA,MAAa,qBACX,WAAmB,KACnB,YACuB;CACvB,MAAM,EAAE,eAAe,SAAS,SAAS,qBAAqB,OAAO;CAErE,IAAI,CAAC,iBAAiB,CAAC,SACrB,OAAO;CAGT,MAAM,gBAAgB,mBAAmB,QAAQ;CACjD,MAAM,gBACJ,UAAU,SAAS,GAAG,KAAK,SAAS,SAAS,IACzC,SAAS,MAAM,GAAG,EAAE,IACpB;CAEN,MAAM,MAAM,gBACR,IAAI,IAAI,aAAa,IACrB,IAAI,IAAI,eAAe,oBAAoB;CAG/C,IAAI,SAAS,iBAAiB;EAC5B,MAAM,cAAc,IAAI,aAAa,IAAI,QAAQ;EACjD,IAAI,eAAe,QAAQ,SAAS,WAAW,GAC7C,OAAO;EAET,OAAO;CACT;CAGA,IAAI,SAAS,aACX,OAAO;CAIT,MAAM,eAAe,IAAI,SAAS,MAAM,GAAG,CAAC,CAAC;CAC7C,IAAI,gBAAgB,QAAQ,SAAS,YAAY,GAC/C,OAAO;CAIT,IAAI,SAAS,qBACX,OAAO;AAIX"}
+{"version":3,"file":"getLocaleFromPath.mjs","names":[],"sources":["../../../src/localization/getLocaleFromPath.ts"],"sourcesContent":["import type { DeclaredLocales } from '@intlayer/types/module_augmentation';\nimport { checkIsURLAbsolute } from '../utils/checkIsURLAbsolute';\nimport {\n  isDeclaredLocale,\n  type RoutingOptions,\n  resolveRoutingConfig,\n} from './getPrefix';\n\n/**\n * Extracts the locale segment from the given URL or pathname based on the routing mode.\n *\n * Mode Behaviors:\n * - 'prefix-no-default': Checks path prefix. If no prefix found, assumes default locale.\n * - 'prefix-all': Checks path prefix.\n * - 'search-params': Checks for 'locale' query parameter.\n * - 'no-prefix': Returns the default locale.\n *\n * @param inputUrl - The complete URL string or pathname to process.\n * @returns The detected locale, default locale (if fallback/implicit), or undefined.\n */\nexport const getLocaleFromPath = (\n  inputUrl: string = '/',\n  options?: RoutingOptions\n): DeclaredLocales | undefined => {\n  const { defaultLocale, locales, mode } = resolveRoutingConfig(options);\n\n  if (!defaultLocale || !locales) {\n    return defaultLocale as DeclaredLocales | undefined;\n  }\n\n  const isAbsoluteUrl = checkIsURLAbsolute(inputUrl);\n  const fixedInputUrl =\n    inputUrl?.endsWith('/') && inputUrl.length > 1\n      ? inputUrl.slice(0, -1)\n      : inputUrl;\n\n  const url = isAbsoluteUrl\n    ? new URL(fixedInputUrl)\n    : new URL(fixedInputUrl, 'http://e.com');\n\n  // Handle 'search-params' mode — locale is in query string\n  if (mode === 'search-params') {\n    const localeParam = url.searchParams.get('locale');\n    if (isDeclaredLocale(localeParam, locales)) {\n      return localeParam;\n    }\n    return defaultLocale as DeclaredLocales;\n  }\n\n  // Handle 'no-prefix' mode — locale is not in the URL\n  if (mode === 'no-prefix') {\n    return defaultLocale as DeclaredLocales;\n  }\n\n  // Handle prefix modes ('prefix-all' | 'prefix-no-default')\n  const firstSegment = url.pathname.split('/')[1];\n  if (isDeclaredLocale(firstSegment, locales)) {\n    return firstSegment;\n  }\n\n  // In 'prefix-no-default', no prefix implies the default locale\n  if (mode === 'prefix-no-default') {\n    return defaultLocale as DeclaredLocales;\n  }\n\n  return undefined;\n};\n"],"mappings":";;;;;;;;;;;;;;;;AAoBA,MAAa,qBACX,WAAmB,KACnB,YACgC;CAChC,MAAM,EAAE,eAAe,SAAS,SAAS,qBAAqB,OAAO;CAErE,IAAI,CAAC,iBAAiB,CAAC,SACrB,OAAO;CAGT,MAAM,gBAAgB,mBAAmB,QAAQ;CACjD,MAAM,gBACJ,UAAU,SAAS,GAAG,KAAK,SAAS,SAAS,IACzC,SAAS,MAAM,GAAG,EAAE,IACpB;CAEN,MAAM,MAAM,gBACR,IAAI,IAAI,aAAa,IACrB,IAAI,IAAI,eAAe,cAAc;CAGzC,IAAI,SAAS,iBAAiB;EAC5B,MAAM,cAAc,IAAI,aAAa,IAAI,QAAQ;EACjD,IAAI,iBAAiB,aAAa,OAAO,GACvC,OAAO;EAET,OAAO;CACT;CAGA,IAAI,SAAS,aACX,OAAO;CAIT,MAAM,eAAe,IAAI,SAAS,MAAM,GAAG,CAAC,CAAC;CAC7C,IAAI,iBAAiB,cAAc,OAAO,GACxC,OAAO;CAIT,IAAI,SAAS,qBACX,OAAO;AAIX"}

package/dist/esm/localization/getLocalizedPath.mjs

@@ -0,0 +1,73 @@
+import { getPathWithoutLocale } from "./getPathWithoutLocale.mjs";
+import { getPrefix, resolveRoutingConfig } from "./getPrefix.mjs";
+import { getCanonicalPath, getRewriteRules, resolveLocalizedPath } from "./rewriteUtils.mjs";
+import { internationalization } from "@intlayer/config/built";
+
+//#region src/localization/getLocalizedPath.ts
+/**
+* Localizes an application path for a locale: resolves the `routing.rewrite`
+* rules, then applies the locale representation of the routing mode — a path
+* prefix, a `locale` search parameter, or nothing at all.
+*
+* Any query string and hash of the input are preserved.
+*
+* This is the relative half of {@link getLocalizedUrl}, which builds on it to
+* add an origin and cross-domain routing. For a relative input both return the
+* same value; this one never returns an absolute URL — the origin of an
+* absolute input is dropped and only its path is localized.
+*
+* Use `resolveLocalizedPath` instead to apply the rewrite rules alone, without
+* any locale representation.
+*
+* @example
+* ```ts
+* // routing: { mode: 'prefix-no-default', rewrite: { '/about': { fr: '/a-propos' } } }
+* getLocalizedPath('/about', 'fr');       // '/fr/a-propos'
+* getLocalizedPath('/about', 'en');       // '/about'  (default locale, no prefix)
+* getLocalizedPath('/', 'fr');            // '/fr'
+* getLocalizedPath('/contact', 'fr');     // '/fr/contact' (no rewrite rule matches)
+* getLocalizedPath('https://intlayer.org/about', 'fr'); // '/fr/a-propos' (origin dropped)
+*
+* // Manual rules, bypassing the configuration
+* getLocalizedPath('/contact', 'fr', {
+*   rewrite: { '/contact': { fr: '/contactez-nous' } },
+* });
+* // '/fr/contactez-nous'
+* ```
+*
+* @param canonicalPath - The internal application path (e.g. `/about`, `/product/123`).
+*   An absolute URL is accepted; only its path, query and hash are kept.
+* @param locale - The target locale. Defaults to the configured default locale.
+* @param options - Routing overrides (`locales`, `defaultLocale`, `mode`, `rewrite`,
+*   `domains`). Each one defaults to the project configuration. `domains` only
+*   suppresses the prefix of a locale served from its own domain — the origin
+*   itself is never emitted.
+* @returns The localized path for the target locale.
+*/
+const getLocalizedPath = (canonicalPath, locale = internationalization?.defaultLocale, options = {}) => {
+	const { defaultLocale, mode, locales, rewrite, domains } = resolveRoutingConfig(options);
+	const pathWithoutLocale = getPathWithoutLocale(canonicalPath, locales);
+	const rewriteRules = getRewriteRules(rewrite, "url");
+	const parsedPath = new URL(pathWithoutLocale, "http://e.com");
+	const translatedPathname = resolveLocalizedPath(getCanonicalPath(parsedPath.pathname, void 0, rewriteRules), locale, rewriteRules).path;
+	if (!(process.env.INTLAYER_ROUTING_MODE && process.env.INTLAYER_ROUTING_MODE !== "no-prefix") && mode === "no-prefix") return `${translatedPathname}${parsedPath.search}${parsedPath.hash}`;
+	if (!(process.env.INTLAYER_ROUTING_MODE && process.env.INTLAYER_ROUTING_MODE !== "search-params") && mode === "search-params") {
+		const searchParams = new URLSearchParams(parsedPath.search);
+		searchParams.set("locale", locale.toString());
+		const queryParams = searchParams.toString();
+		return `${translatedPathname}${queryParams ? `?${queryParams}` : ""}${parsedPath.hash}`;
+	}
+	const { prefix } = getPrefix(locale, {
+		defaultLocale,
+		mode,
+		locales,
+		domains
+	});
+	let localizedPath = `/${prefix}${translatedPathname}`.replace(/\/+/g, "/");
+	if (localizedPath.length > 1 && localizedPath.endsWith("/")) localizedPath = localizedPath.slice(0, -1);
+	return `${localizedPath}${parsedPath.search}${parsedPath.hash}`;
+};
+
+//#endregion
+export { getLocalizedPath };
+//# sourceMappingURL=getLocalizedPath.mjs.map

package/dist/esm/localization/getLocalizedPath.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"getLocalizedPath.mjs","names":[],"sources":["../../../src/localization/getLocalizedPath.ts"],"sourcesContent":["import { internationalization } from '@intlayer/config/built';\nimport type { Locale } from '@intlayer/types/allLocales';\nimport type {\n  LocalesValues,\n  LocalizedPathname,\n  ResolvedDefaultLocale,\n} from '@intlayer/types/module_augmentation';\nimport { getPathWithoutLocale } from './getPathWithoutLocale';\nimport {\n  getPrefix,\n  type RoutingOptions,\n  resolveRoutingConfig,\n} from './getPrefix';\nimport {\n  getCanonicalPath,\n  getRewriteRules,\n  resolveLocalizedPath,\n} from './rewriteUtils';\n\n/**\n * Localizes an application path for a locale: resolves the `routing.rewrite`\n * rules, then applies the locale representation of the routing mode — a path\n * prefix, a `locale` search parameter, or nothing at all.\n *\n * Any query string and hash of the input are preserved.\n *\n * This is the relative half of {@link getLocalizedUrl}, which builds on it to\n * add an origin and cross-domain routing. For a relative input both return the\n * same value; this one never returns an absolute URL — the origin of an\n * absolute input is dropped and only its path is localized.\n *\n * Use `resolveLocalizedPath` instead to apply the rewrite rules alone, without\n * any locale representation.\n *\n * @example\n * ```ts\n * // routing: { mode: 'prefix-no-default', rewrite: { '/about': { fr: '/a-propos' } } }\n * getLocalizedPath('/about', 'fr');       // '/fr/a-propos'\n * getLocalizedPath('/about', 'en');       // '/about'  (default locale, no prefix)\n * getLocalizedPath('/', 'fr');            // '/fr'\n * getLocalizedPath('/contact', 'fr');     // '/fr/contact' (no rewrite rule matches)\n * getLocalizedPath('https://intlayer.org/about', 'fr'); // '/fr/a-propos' (origin dropped)\n *\n * // Manual rules, bypassing the configuration\n * getLocalizedPath('/contact', 'fr', {\n *   rewrite: { '/contact': { fr: '/contactez-nous' } },\n * });\n * // '/fr/contactez-nous'\n * ```\n *\n * @param canonicalPath - The internal application path (e.g. `/about`, `/product/123`).\n *   An absolute URL is accepted; only its path, query and hash are kept.\n * @param locale - The target locale. Defaults to the configured default locale.\n * @param options - Routing overrides (`locales`, `defaultLocale`, `mode`, `rewrite`,\n *   `domains`). Each one defaults to the project configuration. `domains` only\n *   suppresses the prefix of a locale served from its own domain — the origin\n *   itself is never emitted.\n * @returns The localized path for the target locale.\n */\nexport const getLocalizedPath = <\n  const CanonicalPath extends string,\n  const CurrentLocale extends LocalesValues = ResolvedDefaultLocale,\n>(\n  canonicalPath: CanonicalPath,\n  locale: CurrentLocale = internationalization?.defaultLocale as CurrentLocale,\n  options: RoutingOptions = {}\n): LocalizedPathname<CanonicalPath, CurrentLocale> => {\n  const { defaultLocale, mode, locales, rewrite, domains } =\n    resolveRoutingConfig(options);\n\n  const pathWithoutLocale = getPathWithoutLocale(canonicalPath, locales);\n  const rewriteRules = getRewriteRules(rewrite, 'url');\n\n  // Parsed against a dummy origin to split the path from its query and hash.\n  // An absolute input parses on its own, and only its path is kept.\n  const parsedPath = new URL(pathWithoutLocale, 'http://e.com');\n\n  const translatedPathname = resolveLocalizedPath(\n    getCanonicalPath(parsedPath.pathname, undefined, rewriteRules),\n    locale as Locale,\n    rewriteRules\n  ).path;\n\n  if (\n    !(\n      process.env.INTLAYER_ROUTING_MODE &&\n      process.env.INTLAYER_ROUTING_MODE !== 'no-prefix'\n    ) &&\n    mode === 'no-prefix'\n  ) {\n    return `${translatedPathname}${parsedPath.search}${parsedPath.hash}` as LocalizedPathname<\n      CanonicalPath,\n      CurrentLocale\n    >;\n  }\n\n  if (\n    !(\n      process.env.INTLAYER_ROUTING_MODE &&\n      process.env.INTLAYER_ROUTING_MODE !== 'search-params'\n    ) &&\n    mode === 'search-params'\n  ) {\n    const searchParams = new URLSearchParams(parsedPath.search);\n\n    searchParams.set('locale', locale.toString());\n\n    const queryParams = searchParams.toString();\n\n    return `${translatedPathname}${queryParams ? `?${queryParams}` : ''}${parsedPath.hash}` as LocalizedPathname<\n      CanonicalPath,\n      CurrentLocale\n    >;\n  }\n\n  const { prefix } = getPrefix(locale, {\n    defaultLocale,\n    mode,\n    locales,\n    domains,\n  });\n\n  let localizedPath = `/${prefix}${translatedPathname}`.replace(/\\/+/g, '/');\n\n  if (localizedPath.length > 1 && localizedPath.endsWith('/')) {\n    localizedPath = localizedPath.slice(0, -1);\n  }\n\n  return `${localizedPath}${parsedPath.search}${parsedPath.hash}` as LocalizedPathname<\n    CanonicalPath,\n    CurrentLocale\n  >;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2DA,MAAa,oBAIX,eACA,SAAwB,sBAAsB,eAC9C,UAA0B,CAAC,MACyB;CACpD,MAAM,EAAE,eAAe,MAAM,SAAS,SAAS,YAC7C,qBAAqB,OAAO;CAE9B,MAAM,oBAAoB,qBAAqB,eAAe,OAAO;CACrE,MAAM,eAAe,gBAAgB,SAAS,KAAK;CAInD,MAAM,aAAa,IAAI,IAAI,mBAAmB,cAAc;CAE5D,MAAM,qBAAqB,qBACzB,iBAAiB,WAAW,UAAU,QAAW,YAAY,GAC7D,QACA,YACF,CAAC,CAAC;CAEF,IACE,EACE,QAAQ,IAAI,yBACZ,QAAQ,IAAI,0BAA0B,gBAExC,SAAS,aAET,OAAO,GAAG,qBAAqB,WAAW,SAAS,WAAW;CAMhE,IACE,EACE,QAAQ,IAAI,yBACZ,QAAQ,IAAI,0BAA0B,oBAExC,SAAS,iBACT;EACA,MAAM,eAAe,IAAI,gBAAgB,WAAW,MAAM;EAE1D,aAAa,IAAI,UAAU,OAAO,SAAS,CAAC;EAE5C,MAAM,cAAc,aAAa,SAAS;EAE1C,OAAO,GAAG,qBAAqB,cAAc,IAAI,gBAAgB,KAAK,WAAW;CAInF;CAEA,MAAM,EAAE,WAAW,UAAU,QAAQ;EACnC;EACA;EACA;EACA;CACF,CAAC;CAED,IAAI,gBAAgB,IAAI,SAAS,qBAAqB,QAAQ,QAAQ,GAAG;CAEzE,IAAI,cAAc,SAAS,KAAK,cAAc,SAAS,GAAG,GACxD,gBAAgB,cAAc,MAAM,GAAG,EAAE;CAG3C,OAAO,GAAG,gBAAgB,WAAW,SAAS,WAAW;AAI3D"}

package/dist/esm/localization/getLocalizedPath.test-d.mjs

@@ -0,0 +1,83 @@
+import { getLocalizedPath } from "./getLocalizedPath.mjs";
+import { getLocalizedUrl } from "./getLocalizedUrl.mjs";
+import { describe, expectTypeOf, it } from "vitest";
+
+//#region src/localization/getLocalizedPath.test-d.ts
+/**
+* `getLocalizedPath` prefixes the rewritten path, so it reports the very type
+* its sibling reports for a relative URL. This package declares neither rewrite
+* rules nor a default locale, so the registry leaves both steps as no-ops.
+*/
+describe("getLocalizedPath", () => {
+	it("should report the same type as getLocalizedUrl", () => {
+		expectTypeOf(getLocalizedPath("/about", "fr")).toEqualTypeOf();
+		expectTypeOf(getLocalizedPath("/about", "fr")).toEqualTypeOf(getLocalizedUrl("/about", "fr"));
+	});
+	it("should keep the literal path when nothing rewrites or prefixes it", () => {
+		expectTypeOf(getLocalizedPath("/about", "fr")).toEqualTypeOf();
+	});
+	it("should drop the origin of an absolute URL", () => {
+		expectTypeOf(getLocalizedPath("https://intlayer.org/about", "fr")).toEqualTypeOf();
+	});
+	it("should widen to string when the path is not a literal", () => {
+		expectTypeOf(getLocalizedPath("/about", "fr")).toEqualTypeOf();
+	});
+});
+/**
+* The resolution itself, exercised against explicit rules — the same shape the
+* generated module augmentation feeds it as `__RoutingRegistry['rewrite']`.
+*/
+describe("LocalizedPath", () => {
+	it("should rewrite a static path", () => {
+		expectTypeOf().toEqualTypeOf();
+	});
+	it("should keep a path no rule matches", () => {
+		expectTypeOf().toEqualTypeOf();
+	});
+	it("should substitute a route parameter", () => {
+		expectTypeOf().toEqualTypeOf();
+	});
+	it("should substitute several route parameters", () => {
+		expectTypeOf().toEqualTypeOf();
+	});
+	it("should not match a parameter across a segment boundary", () => {
+		expectTypeOf().toEqualTypeOf();
+	});
+	it("should keep the path when the locale declares no pattern", () => {
+		expectTypeOf().toEqualTypeOf();
+	});
+	it("should distribute over a union of locales", () => {
+		expectTypeOf().toEqualTypeOf();
+	});
+	it("should widen a variadic rule to string, but only for the paths it could match", () => {
+		expectTypeOf().toEqualTypeOf();
+		expectTypeOf().toEqualTypeOf();
+	});
+	it("should keep every path when the project declares no rule", () => {
+		expectTypeOf().toEqualTypeOf();
+	});
+});
+/**
+* The return type of `getLocalizedPath`, exercised against an explicit routing
+* mode, default locale and locale set — this package declares none of them.
+*/
+describe("LocalizedPathname", () => {
+	it("should report the same type as LocalizedUrl for a relative path", () => {
+		expectTypeOf().toEqualTypeOf();
+		expectTypeOf().toEqualTypeOf();
+	});
+	it("should drop the origin of an absolute URL", () => {
+		expectTypeOf().toEqualTypeOf();
+		expectTypeOf().toEqualTypeOf();
+	});
+	it("should collapse an origin without a path to the root", () => {
+		expectTypeOf().toEqualTypeOf();
+		expectTypeOf().toEqualTypeOf();
+	});
+	it("should replace a locale segment carried by an absolute URL", () => {
+		expectTypeOf().toEqualTypeOf();
+	});
+});
+
+//#endregion
+//# sourceMappingURL=getLocalizedPath.test-d.mjs.map

package/dist/esm/localization/getLocalizedPath.test-d.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"getLocalizedPath.test-d.mjs","names":[],"sources":["../../../src/localization/getLocalizedPath.test-d.ts"],"sourcesContent":["import type {\n  LocalizedPath,\n  LocalizedPathname,\n  LocalizedUrl,\n} from '@intlayer/types/module_augmentation';\nimport { describe, expectTypeOf, it } from 'vitest';\nimport { getLocalizedPath } from './getLocalizedPath';\nimport { getLocalizedUrl } from './getLocalizedUrl';\n\n/**\n * `getLocalizedPath` prefixes the rewritten path, so it reports the very type\n * its sibling reports for a relative URL. This package declares neither rewrite\n * rules nor a default locale, so the registry leaves both steps as no-ops.\n */\ndescribe('getLocalizedPath', () => {\n  it('should report the same type as getLocalizedUrl', () => {\n    expectTypeOf(getLocalizedPath('/about', 'fr')).toEqualTypeOf<\n      LocalizedUrl<'/about', 'fr'>\n    >();\n    expectTypeOf(getLocalizedPath('/about', 'fr')).toEqualTypeOf(\n      getLocalizedUrl('/about', 'fr')\n    );\n  });\n\n  it('should keep the literal path when nothing rewrites or prefixes it', () => {\n    expectTypeOf(getLocalizedPath('/about', 'fr')).toEqualTypeOf<'/about'>();\n  });\n\n  it('should drop the origin of an absolute URL', () => {\n    expectTypeOf(\n      getLocalizedPath('https://intlayer.org/about', 'fr')\n    ).toEqualTypeOf<'/about'>();\n  });\n\n  it('should widen to string when the path is not a literal', () => {\n    const dynamicPath = '/about' as string;\n\n    expectTypeOf(getLocalizedPath(dynamicPath, 'fr')).toEqualTypeOf<string>();\n  });\n});\n\n/**\n * The resolution itself, exercised against explicit rules — the same shape the\n * generated module augmentation feeds it as `__RoutingRegistry['rewrite']`.\n */\ndescribe('LocalizedPath', () => {\n  type Rules = {\n    '/about': { en: '/about'; fr: '/a-propos' };\n    '/product/:id': { en: '/product/:id'; fr: '/produit/:id' };\n    '/shop/:category/:id': { fr: '/boutique/:category/:id' };\n    '/docs/:path+': { fr: '/documentation/:path+' };\n  };\n\n  it('should rewrite a static path', () => {\n    expectTypeOf<\n      LocalizedPath<'/about', 'fr', Rules>\n    >().toEqualTypeOf<'/a-propos'>();\n  });\n\n  it('should keep a path no rule matches', () => {\n    expectTypeOf<\n      LocalizedPath<'/contact', 'fr', Rules>\n    >().toEqualTypeOf<'/contact'>();\n  });\n\n  it('should substitute a route parameter', () => {\n    expectTypeOf<\n      LocalizedPath<'/product/123', 'fr', Rules>\n    >().toEqualTypeOf<'/produit/123'>();\n  });\n\n  it('should substitute several route parameters', () => {\n    expectTypeOf<\n      LocalizedPath<'/shop/shoes/123', 'fr', Rules>\n    >().toEqualTypeOf<'/boutique/shoes/123'>();\n  });\n\n  it('should not match a parameter across a segment boundary', () => {\n    expectTypeOf<\n      LocalizedPath<'/product/123/reviews', 'fr', Rules>\n    >().toEqualTypeOf<'/product/123/reviews'>();\n  });\n\n  it('should keep the path when the locale declares no pattern', () => {\n    expectTypeOf<\n      LocalizedPath<'/shop/shoes/123', 'en', Rules>\n    >().toEqualTypeOf<'/shop/shoes/123'>();\n  });\n\n  it('should distribute over a union of locales', () => {\n    expectTypeOf<LocalizedPath<'/about', 'en' | 'fr', Rules>>().toEqualTypeOf<\n      '/about' | '/a-propos'\n    >();\n  });\n\n  it('should widen a variadic rule to string, but only for the paths it could match', () => {\n    expectTypeOf<\n      LocalizedPath<'/docs/getting-started', 'fr', Rules>\n    >().toEqualTypeOf<string>();\n    expectTypeOf<\n      LocalizedPath<'/about', 'fr', Rules>\n    >().toEqualTypeOf<'/a-propos'>();\n  });\n\n  it('should keep every path when the project declares no rule', () => {\n    expectTypeOf<LocalizedPath<'/about', 'fr', {}>>().toEqualTypeOf<'/about'>();\n  });\n});\n\n/**\n * The return type of `getLocalizedPath`, exercised against an explicit routing\n * mode, default locale and locale set — this package declares none of them.\n */\ndescribe('LocalizedPathname', () => {\n  type Locales = 'en' | 'fr' | 'es';\n  type Path<P extends string, L extends Locales> = LocalizedPathname<\n    P,\n    L,\n    'prefix-no-default',\n    'en',\n    Locales\n  >;\n\n  it('should report the same type as LocalizedUrl for a relative path', () => {\n    expectTypeOf<Path<'/about', 'es'>>().toEqualTypeOf<\n      LocalizedUrl<'/about', 'es', 'prefix-no-default', 'en', Locales>\n    >();\n    expectTypeOf<Path<'/about', 'es'>>().toEqualTypeOf<'/es/about'>();\n  });\n\n  it('should drop the origin of an absolute URL', () => {\n    expectTypeOf<\n      Path<'https://intlayer.org/about', 'es'>\n    >().toEqualTypeOf<'/es/about'>();\n    expectTypeOf<\n      Path<'https://intlayer.org/about', 'en'>\n    >().toEqualTypeOf<'/about'>();\n  });\n\n  it('should collapse an origin without a path to the root', () => {\n    expectTypeOf<Path<'https://intlayer.org', 'en'>>().toEqualTypeOf<'/'>();\n    expectTypeOf<Path<'https://intlayer.org/', 'es'>>().toEqualTypeOf<'/es'>();\n  });\n\n  it('should replace a locale segment carried by an absolute URL', () => {\n    expectTypeOf<\n      Path<'https://intlayer.org/fr/about', 'es'>\n    >().toEqualTypeOf<'/es/about'>();\n  });\n});\n"],"mappings":";;;;;;;;;;AAcA,SAAS,0BAA0B;CACjC,GAAG,wDAAwD;EACzD,aAAa,iBAAiB,UAAU,IAAI,CAAC,CAAC,CAAC,cAE7C;EACF,aAAa,iBAAiB,UAAU,IAAI,CAAC,CAAC,CAAC,cAC7C,gBAAgB,UAAU,IAAI,CAChC;CACF,CAAC;CAED,GAAG,2EAA2E;EAC5E,aAAa,iBAAiB,UAAU,IAAI,CAAC,CAAC,CAAC,cAAwB;CACzE,CAAC;CAED,GAAG,mDAAmD;EACpD,aACE,iBAAiB,8BAA8B,IAAI,CACrD,CAAC,CAAC,cAAwB;CAC5B,CAAC;CAED,GAAG,+DAA+D;EAGhE,aAAa,iBAAiB,UAAa,IAAI,CAAC,CAAC,CAAC,cAAsB;CAC1E,CAAC;AACH,CAAC;;;;;AAMD,SAAS,uBAAuB;CAQ9B,GAAG,sCAAsC;EACvC,aAEE,CAAC,CAAC,cAA2B;CACjC,CAAC;CAED,GAAG,4CAA4C;EAC7C,aAEE,CAAC,CAAC,cAA0B;CAChC,CAAC;CAED,GAAG,6CAA6C;EAC9C,aAEE,CAAC,CAAC,cAA8B;CACpC,CAAC;CAED,GAAG,oDAAoD;EACrD,aAEE,CAAC,CAAC,cAAqC;CAC3C,CAAC;CAED,GAAG,gEAAgE;EACjE,aAEE,CAAC,CAAC,cAAsC;CAC5C,CAAC;CAED,GAAG,kEAAkE;EACnE,aAEE,CAAC,CAAC,cAAiC;CACvC,CAAC;CAED,GAAG,mDAAmD;EACpD,aAA0D,CAAC,CAAC,cAE1D;CACJ,CAAC;CAED,GAAG,uFAAuF;EACxF,aAEE,CAAC,CAAC,cAAsB;EAC1B,aAEE,CAAC,CAAC,cAA2B;CACjC,CAAC;CAED,GAAG,kEAAkE;EACnE,aAAgD,CAAC,CAAC,cAAwB;CAC5E,CAAC;AACH,CAAC;;;;;AAMD,SAAS,2BAA2B;CAUlC,GAAG,yEAAyE;EAC1E,aAAmC,CAAC,CAAC,cAEnC;EACF,aAAmC,CAAC,CAAC,cAA2B;CAClE,CAAC;CAED,GAAG,mDAAmD;EACpD,aAEE,CAAC,CAAC,cAA2B;EAC/B,aAEE,CAAC,CAAC,cAAwB;CAC9B,CAAC;CAED,GAAG,8DAA8D;EAC/D,aAAiD,CAAC,CAAC,cAAmB;EACtE,aAAkD,CAAC,CAAC,cAAqB;CAC3E,CAAC;CAED,GAAG,oEAAoE;EACrE,aAEE,CAAC,CAAC,cAA2B;CACjC,CAAC;AACH,CAAC"}

package/dist/esm/localization/getLocalizedUrl.mjs

@@ -1,8 +1,7 @@
 import { checkIsURLAbsolute } from "../utils/checkIsURLAbsolute.mjs";
-import { getPathWithoutLocale } from "./getPathWithoutLocale.mjs";
 import { getDomainHostname, getDomainOrigin } from "./domainUtils.mjs";
-import { getPrefix, resolveRoutingConfig } from "./getPrefix.mjs";
-import { getCanonicalPath, getLocalizedPath, getRewriteRules } from "./rewriteUtils.mjs";
+import { resolveRoutingConfig } from "./getPrefix.mjs";
+import { getLocalizedPath } from "./getLocalizedPath.mjs";
 import { internationalization } from "@intlayer/config/built";
 
 //#region src/localization/getLocalizedUrl.ts
@@ -12,6 +11,10 @@ import { internationalization } from "@intlayer/config/built";
 *
 * This function gets the locales, default locale, and routing mode from the configuration if not provided.
 *
+* The path itself is localized by {@link getLocalizedPath}; this function only
+* resolves the origin to put in front of it — the one of an absolute input, or
+* the domain mapped to the target locale.
+*
 * Example:
 *
 * ```ts
@@ -51,33 +54,14 @@ import { internationalization } from "@intlayer/config/built";
 * not overridden via `options`.
 */
 const getLocalizedUrl = (url, currentLocale = internationalization?.defaultLocale, options = {}) => {
-	const { defaultLocale, mode, locales, rewrite, domains, currentDomain } = resolveRoutingConfig(options);
-	const urlWithoutLocale = getPathWithoutLocale(url, locales);
-	const rewriteRules = getRewriteRules(rewrite, "url");
-	if (!(process.env.INTLAYER_ROUTING_MODE && process.env.INTLAYER_ROUTING_MODE !== "no-prefix") && mode === "no-prefix") return getLocalizedPath(getCanonicalPath(urlWithoutLocale, void 0, rewriteRules), currentLocale, rewriteRules).path;
-	const isAbsoluteUrl = checkIsURLAbsolute(urlWithoutLocale);
-	const parsedUrl = isAbsoluteUrl ? new URL(urlWithoutLocale) : new URL(urlWithoutLocale, "http://example.com");
-	const translatedPathname = getLocalizedPath(getCanonicalPath(parsedUrl.pathname, void 0, rewriteRules), currentLocale, rewriteRules).path;
+	const { domains, currentDomain } = resolveRoutingConfig(options);
+	const isAbsoluteUrl = checkIsURLAbsolute(url);
+	const parsedUrl = isAbsoluteUrl ? new URL(url) : new URL(url, "http://e.com");
 	const detectedCurrentHostname = process.env.INTLAYER_ROUTING_DOMAINS !== "false" ? getDomainHostname(currentDomain ?? (isAbsoluteUrl ? parsedUrl.hostname : void 0) ?? (typeof window !== "undefined" ? window?.location?.hostname : void 0) ?? "") || null : null;
 	const localeDomain = process.env.INTLAYER_ROUTING_DOMAINS !== "false" ? domains?.[currentLocale] : void 0;
 	const localeDomainHostname = localeDomain ? getDomainHostname(localeDomain) : null;
 	const normalizedDomain = localeDomainHostname !== null && (detectedCurrentHostname === null || localeDomainHostname !== detectedCurrentHostname) && localeDomain ? getDomainOrigin(localeDomain) : null;
-	const baseUrl = normalizedDomain ? normalizedDomain : isAbsoluteUrl ? `${parsedUrl.protocol}//${parsedUrl.host}` : "";
-	if (!(process.env.INTLAYER_ROUTING_MODE && process.env.INTLAYER_ROUTING_MODE !== "search-params") && mode === "search-params") {
-		const searchParams = new URLSearchParams(parsedUrl.search);
-		searchParams.set("locale", currentLocale.toString());
-		const queryParams = searchParams.toString();
-		return `${baseUrl}${queryParams ? `${translatedPathname}?${queryParams}` : translatedPathname}${parsedUrl.hash}`;
-	}
-	const { prefix } = getPrefix(currentLocale, {
-		defaultLocale,
-		mode,
-		locales,
-		domains
-	});
-	let localizedPath = `/${prefix}${translatedPathname}`.replace(/\/+/g, "/");
-	if (localizedPath.length > 1 && localizedPath.endsWith("/")) localizedPath = localizedPath.slice(0, -1);
-	return `${baseUrl}${localizedPath}${parsedUrl.search}${parsedUrl.hash}`;
+	return `${normalizedDomain ? normalizedDomain : isAbsoluteUrl ? `${parsedUrl.protocol}//${parsedUrl.host}` : ""}${getLocalizedPath(`${parsedUrl.pathname}${parsedUrl.search}${parsedUrl.hash}`, currentLocale, options)}`;
 };
 
 //#endregion

package/dist/esm/localization/getLocalizedUrl.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"getLocalizedUrl.mjs","names":[],"sources":["../../../src/localization/getLocalizedUrl.ts"],"sourcesContent":["import { internationalization } from '@intlayer/config/built';\n\n// ── Tree-shake constants ──────────────────────────────────────────────────────\n// When these env vars are injected at build time, bundlers eliminate the\n// branches guarded by these constants.\n\nimport type { Locale } from '@intlayer/types/allLocales';\nimport type {\n  LocalesValues,\n  LocalizedUrl,\n  ResolvedDefaultLocale,\n} from '@intlayer/types/module_augmentation';\nimport { checkIsURLAbsolute } from '../utils/checkIsURLAbsolute';\nimport { getDomainHostname, getDomainOrigin } from './domainUtils';\nimport { getPathWithoutLocale } from './getPathWithoutLocale';\nimport {\n  getPrefix,\n  type RoutingOptions,\n  resolveRoutingConfig,\n} from './getPrefix';\nimport {\n  getCanonicalPath,\n  getLocalizedPath,\n  getRewriteRules,\n} from './rewriteUtils';\n\nexport type { RoutingOptions };\n\n/**\n * Generate URL by prefixing the given URL with the referenced locale or adding search parameters\n * based on the routing mode. Handles both absolute and relative URLs appropriately.\n *\n * This function gets the locales, default locale, and routing mode from the configuration if not provided.\n *\n * Example:\n *\n * ```ts\n *  // prefix-no-default mode\n *  getLocalizedUrl('/about', 'fr', { locales: ['en', 'fr'], defaultLocale: 'en', mode: 'prefix-no-default' });\n *  // Returns '/fr/about' for the French locale\n *  // Returns '/about' for the English locale (default)\n *\n *  // prefix-all mode\n *  getLocalizedUrl('/about', 'en', { locales: ['en', 'fr'], defaultLocale: 'en', mode: 'prefix-all' });\n *  // Returns '/en/about' for the English locale\n *  // Returns '/fr/about' for the French locale\n *\n *  // search-params mode\n *  getLocalizedUrl('/about', 'fr', { locales: ['en', 'fr'], defaultLocale: 'en', mode: 'search-params' });\n *  // Returns '/about?locale=fr' for the French locale\n *\n *  // no-prefix mode\n *  getLocalizedUrl('/about', 'fr', { locales: ['en', 'fr'], defaultLocale: 'en', mode: 'no-prefix' });\n *  // Returns '/about' for any locale\n * ```\n *\n * @param url - The original URL string to be processed.\n * @param currentLocale - The current locale.\n * @param options - Configuration options\n * @param options.locales - Optional array of supported locales. Defaults to configured locales.\n * @param options.defaultLocale - The default locale. Defaults to configured default locale.\n * @param options.mode - URL routing mode for locale handling. Defaults to configured mode.\n * @param options.currentDomain - Hostname of the page being rendered. Used to decide\n *   whether to emit a relative URL (same domain) or an absolute URL (cross-domain).\n *   Auto-detected from the input URL or `window.location` when omitted.\n * @returns The localized URL for the current locale.\n */\n/**\n * The return type is narrowed to a template-literal type when both `url` and\n * `currentLocale` are string literals and the routing mode / defaultLocale are\n * not overridden via `options`.\n */\nexport const getLocalizedUrl = <\n  const T extends string,\n  const L extends LocalesValues = ResolvedDefaultLocale,\n>(\n  url: T,\n  currentLocale: L = internationalization?.defaultLocale as L,\n  options: RoutingOptions = {}\n): LocalizedUrl<T, L> => {\n  const { defaultLocale, mode, locales, rewrite, domains, currentDomain } =\n    resolveRoutingConfig(options);\n\n  const urlWithoutLocale = getPathWithoutLocale(url, locales);\n  const rewriteRules = getRewriteRules(rewrite, 'url');\n\n  if (\n    !(\n      process.env.INTLAYER_ROUTING_MODE &&\n      process.env.INTLAYER_ROUTING_MODE !== 'no-prefix'\n    ) &&\n    mode === 'no-prefix'\n  ) {\n    return getLocalizedPath(\n      getCanonicalPath(urlWithoutLocale, undefined, rewriteRules),\n      currentLocale as Locale,\n      rewriteRules\n    ).path as LocalizedUrl<T, L>;\n  }\n\n  const isAbsoluteUrl = checkIsURLAbsolute(urlWithoutLocale);\n  const parsedUrl = isAbsoluteUrl\n    ? new URL(urlWithoutLocale)\n    : new URL(urlWithoutLocale, 'http://example.com');\n\n  const translatedPathname = getLocalizedPath(\n    getCanonicalPath(parsedUrl.pathname, undefined, rewriteRules),\n    currentLocale as Locale,\n    rewriteRules\n  ).path;\n\n  // ── Domain routing ────────────────────────────────────────────────────────\n  // Resolve the \"current\" hostname so we can choose between a relative URL\n  // (same domain) and an absolute URL (cross-domain).\n  //\n  // Detection priority:\n  //   1. Explicit `currentDomain` option passed by the caller.\n  //   2. Hostname extracted from an absolute input URL.\n  //   3. `window.location.hostname` in browser environments.\n  // When none of these is available we fall back to generating an absolute\n  // URL for domain-mapped locales (safe for SSR/static generation): the\n  // locale prefix may already be stripped for domain-exclusive locales, so a\n  // relative URL would silently point to the wrong locale on the current\n  // domain.\n  const detectedCurrentHostname =\n    process.env.INTLAYER_ROUTING_DOMAINS !== 'false'\n      ? getDomainHostname(\n          currentDomain ??\n            (isAbsoluteUrl ? parsedUrl.hostname : undefined) ??\n            (typeof window !== 'undefined'\n              ? window?.location?.hostname\n              : undefined) ??\n            ''\n        ) || null\n      : null;\n\n  const localeDomain =\n    process.env.INTLAYER_ROUTING_DOMAINS !== 'false'\n      ? domains?.[currentLocale as LocalesValues]\n      : undefined;\n\n  const localeDomainHostname = localeDomain\n    ? getDomainHostname(localeDomain)\n    : null;\n\n  // Prepend the locale's domain when it differs from the current hostname,\n  // or when the current hostname is unknown (SSR without `currentDomain`).\n  const isCrossDomain =\n    localeDomainHostname !== null &&\n    (detectedCurrentHostname === null ||\n      localeDomainHostname !== detectedCurrentHostname);\n\n  const normalizedDomain =\n    isCrossDomain && localeDomain ? getDomainOrigin(localeDomain) : null;\n\n  const baseUrl = normalizedDomain\n    ? normalizedDomain\n    : isAbsoluteUrl\n      ? `${parsedUrl.protocol}//${parsedUrl.host}`\n      : '';\n  // ─────────────────────────────────────────────────────────────────────────\n\n  if (\n    !(\n      process.env.INTLAYER_ROUTING_MODE &&\n      process.env.INTLAYER_ROUTING_MODE !== 'search-params'\n    ) &&\n    mode === 'search-params'\n  ) {\n    const searchParams = new URLSearchParams(parsedUrl.search);\n\n    searchParams.set('locale', currentLocale.toString());\n\n    const queryParams = searchParams.toString();\n    const path = queryParams\n      ? `${translatedPathname}?${queryParams}`\n      : translatedPathname;\n\n    return `${baseUrl}${path}${parsedUrl.hash}` as LocalizedUrl<T, L>;\n  }\n\n  const { prefix } = getPrefix(currentLocale, {\n    defaultLocale,\n    mode,\n    locales,\n    domains,\n  });\n\n  let localizedPath = `/${prefix}${translatedPathname}`.replace(/\\/+/g, '/');\n\n  if (localizedPath.length > 1 && localizedPath.endsWith('/')) {\n    localizedPath = localizedPath.slice(0, -1);\n  }\n\n  return `${baseUrl}${localizedPath}${parsedUrl.search}${parsedUrl.hash}` as LocalizedUrl<\n    T,\n    L\n  >;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwEA,MAAa,mBAIX,KACA,gBAAmB,sBAAsB,eACzC,UAA0B,CAAC,MACJ;CACvB,MAAM,EAAE,eAAe,MAAM,SAAS,SAAS,SAAS,kBACtD,qBAAqB,OAAO;CAE9B,MAAM,mBAAmB,qBAAqB,KAAK,OAAO;CAC1D,MAAM,eAAe,gBAAgB,SAAS,KAAK;CAEnD,IACE,EACE,QAAQ,IAAI,yBACZ,QAAQ,IAAI,0BAA0B,gBAExC,SAAS,aAET,OAAO,iBACL,iBAAiB,kBAAkB,QAAW,YAAY,GAC1D,eACA,YACF,CAAC,CAAC;CAGJ,MAAM,gBAAgB,mBAAmB,gBAAgB;CACzD,MAAM,YAAY,gBACd,IAAI,IAAI,gBAAgB,IACxB,IAAI,IAAI,kBAAkB,oBAAoB;CAElD,MAAM,qBAAqB,iBACzB,iBAAiB,UAAU,UAAU,QAAW,YAAY,GAC5D,eACA,YACF,CAAC,CAAC;CAeF,MAAM,0BACJ,QAAQ,IAAI,6BAA6B,UACrC,kBACE,kBACG,gBAAgB,UAAU,WAAW,YACrC,OAAO,WAAW,cACf,QAAQ,UAAU,WAClB,WACJ,EACJ,KAAK,OACL;CAEN,MAAM,eACJ,QAAQ,IAAI,6BAA6B,UACrC,UAAU,iBACV;CAEN,MAAM,uBAAuB,eACzB,kBAAkB,YAAY,IAC9B;CASJ,MAAM,mBAJJ,yBAAyB,SACxB,4BAA4B,QAC3B,yBAAyB,4BAGV,eAAe,gBAAgB,YAAY,IAAI;CAElE,MAAM,UAAU,mBACZ,mBACA,gBACE,GAAG,UAAU,SAAS,IAAI,UAAU,SACpC;CAGN,IACE,EACE,QAAQ,IAAI,yBACZ,QAAQ,IAAI,0BAA0B,oBAExC,SAAS,iBACT;EACA,MAAM,eAAe,IAAI,gBAAgB,UAAU,MAAM;EAEzD,aAAa,IAAI,UAAU,cAAc,SAAS,CAAC;EAEnD,MAAM,cAAc,aAAa,SAAS;EAK1C,OAAO,GAAG,UAJG,cACT,GAAG,mBAAmB,GAAG,gBACzB,qBAEuB,UAAU;CACvC;CAEA,MAAM,EAAE,WAAW,UAAU,eAAe;EAC1C;EACA;EACA;EACA;CACF,CAAC;CAED,IAAI,gBAAgB,IAAI,SAAS,qBAAqB,QAAQ,QAAQ,GAAG;CAEzE,IAAI,cAAc,SAAS,KAAK,cAAc,SAAS,GAAG,GACxD,gBAAgB,cAAc,MAAM,GAAG,EAAE;CAG3C,OAAO,GAAG,UAAU,gBAAgB,UAAU,SAAS,UAAU;AAInE"}
+{"version":3,"file":"getLocalizedUrl.mjs","names":[],"sources":["../../../src/localization/getLocalizedUrl.ts"],"sourcesContent":["import { internationalization } from '@intlayer/config/built';\nimport type {\n  LocalesValues,\n  LocalizedUrl,\n  ResolvedDefaultLocale,\n} from '@intlayer/types/module_augmentation';\nimport { checkIsURLAbsolute } from '../utils/checkIsURLAbsolute';\nimport { getDomainHostname, getDomainOrigin } from './domainUtils';\nimport { getLocalizedPath } from './getLocalizedPath';\nimport { type RoutingOptions, resolveRoutingConfig } from './getPrefix';\n\n/**\n * Generate URL by prefixing the given URL with the referenced locale or adding search parameters\n * based on the routing mode. Handles both absolute and relative URLs appropriately.\n *\n * This function gets the locales, default locale, and routing mode from the configuration if not provided.\n *\n * The path itself is localized by {@link getLocalizedPath}; this function only\n * resolves the origin to put in front of it — the one of an absolute input, or\n * the domain mapped to the target locale.\n *\n * Example:\n *\n * ```ts\n *  // prefix-no-default mode\n *  getLocalizedUrl('/about', 'fr', { locales: ['en', 'fr'], defaultLocale: 'en', mode: 'prefix-no-default' });\n *  // Returns '/fr/about' for the French locale\n *  // Returns '/about' for the English locale (default)\n *\n *  // prefix-all mode\n *  getLocalizedUrl('/about', 'en', { locales: ['en', 'fr'], defaultLocale: 'en', mode: 'prefix-all' });\n *  // Returns '/en/about' for the English locale\n *  // Returns '/fr/about' for the French locale\n *\n *  // search-params mode\n *  getLocalizedUrl('/about', 'fr', { locales: ['en', 'fr'], defaultLocale: 'en', mode: 'search-params' });\n *  // Returns '/about?locale=fr' for the French locale\n *\n *  // no-prefix mode\n *  getLocalizedUrl('/about', 'fr', { locales: ['en', 'fr'], defaultLocale: 'en', mode: 'no-prefix' });\n *  // Returns '/about' for any locale\n * ```\n *\n * @param url - The original URL string to be processed.\n * @param currentLocale - The current locale.\n * @param options - Configuration options\n * @param options.locales - Optional array of supported locales. Defaults to configured locales.\n * @param options.defaultLocale - The default locale. Defaults to configured default locale.\n * @param options.mode - URL routing mode for locale handling. Defaults to configured mode.\n * @param options.currentDomain - Hostname of the page being rendered. Used to decide\n *   whether to emit a relative URL (same domain) or an absolute URL (cross-domain).\n *   Auto-detected from the input URL or `window.location` when omitted.\n * @returns The localized URL for the current locale.\n */\n/**\n * The return type is narrowed to a template-literal type when both `url` and\n * `currentLocale` are string literals and the routing mode / defaultLocale are\n * not overridden via `options`.\n */\nexport const getLocalizedUrl = <\n  const T extends string,\n  const L extends LocalesValues = ResolvedDefaultLocale,\n>(\n  url: T,\n  currentLocale: L = internationalization?.defaultLocale as L,\n  options: RoutingOptions = {}\n): LocalizedUrl<T, L> => {\n  const { domains, currentDomain } = resolveRoutingConfig(options);\n\n  const isAbsoluteUrl = checkIsURLAbsolute(url);\n  const parsedUrl = isAbsoluteUrl ? new URL(url) : new URL(url, 'http://e.com');\n\n  // ── Domain routing ────────────────────────────────────────────────────────\n  // Resolve the \"current\" hostname so we can choose between a relative URL\n  // (same domain) and an absolute URL (cross-domain).\n  //\n  // Detection priority:\n  //   1. Explicit `currentDomain` option passed by the caller.\n  //   2. Hostname extracted from an absolute input URL.\n  //   3. `window.location.hostname` in browser environments.\n  // When none of these is available we fall back to generating an absolute\n  // URL for domain-mapped locales (safe for SSR/static generation): the\n  // locale prefix may already be stripped for domain-exclusive locales, so a\n  // relative URL would silently point to the wrong locale on the current\n  // domain.\n  const detectedCurrentHostname =\n    process.env.INTLAYER_ROUTING_DOMAINS !== 'false'\n      ? getDomainHostname(\n          currentDomain ??\n            (isAbsoluteUrl ? parsedUrl.hostname : undefined) ??\n            (typeof window !== 'undefined'\n              ? window?.location?.hostname\n              : undefined) ??\n            ''\n        ) || null\n      : null;\n\n  const localeDomain =\n    process.env.INTLAYER_ROUTING_DOMAINS !== 'false'\n      ? domains?.[currentLocale as LocalesValues]\n      : undefined;\n\n  const localeDomainHostname = localeDomain\n    ? getDomainHostname(localeDomain)\n    : null;\n\n  // Prepend the locale's domain when it differs from the current hostname,\n  // or when the current hostname is unknown (SSR without `currentDomain`).\n  const isCrossDomain =\n    localeDomainHostname !== null &&\n    (detectedCurrentHostname === null ||\n      localeDomainHostname !== detectedCurrentHostname);\n\n  const normalizedDomain =\n    isCrossDomain && localeDomain ? getDomainOrigin(localeDomain) : null;\n\n  const baseUrl = normalizedDomain\n    ? normalizedDomain\n    : isAbsoluteUrl\n      ? `${parsedUrl.protocol}//${parsedUrl.host}`\n      : '';\n  // ─────────────────────────────────────────────────────────────────────────\n\n  const localizedPath = getLocalizedPath(\n    `${parsedUrl.pathname}${parsedUrl.search}${parsedUrl.hash}`,\n    currentLocale,\n    options\n  );\n\n  return `${baseUrl}${localizedPath}` as LocalizedUrl<T, L>;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2DA,MAAa,mBAIX,KACA,gBAAmB,sBAAsB,eACzC,UAA0B,CAAC,MACJ;CACvB,MAAM,EAAE,SAAS,kBAAkB,qBAAqB,OAAO;CAE/D,MAAM,gBAAgB,mBAAmB,GAAG;CAC5C,MAAM,YAAY,gBAAgB,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,KAAK,cAAc;CAe5E,MAAM,0BACJ,QAAQ,IAAI,6BAA6B,UACrC,kBACE,kBACG,gBAAgB,UAAU,WAAW,YACrC,OAAO,WAAW,cACf,QAAQ,UAAU,WAClB,WACJ,EACJ,KAAK,OACL;CAEN,MAAM,eACJ,QAAQ,IAAI,6BAA6B,UACrC,UAAU,iBACV;CAEN,MAAM,uBAAuB,eACzB,kBAAkB,YAAY,IAC9B;CASJ,MAAM,mBAJJ,yBAAyB,SACxB,4BAA4B,QAC3B,yBAAyB,4BAGV,eAAe,gBAAgB,YAAY,IAAI;CAelE,OAAO,GAbS,mBACZ,mBACA,gBACE,GAAG,UAAU,SAAS,IAAI,UAAU,SACpC,KAGgB,iBACpB,GAAG,UAAU,WAAW,UAAU,SAAS,UAAU,QACrD,eACA,OAG8B;AAClC"}

package/dist/esm/localization/getLocalizedUrl.test-d.mjs

@@ -0,0 +1,42 @@
+import { describe, expectTypeOf, it } from "vitest";
+
+//#region src/localization/getLocalizedUrl.test-d.ts
+/**
+* `LocalizedUrl` mirrors what `getLocalizedUrl` builds at runtime. The routing
+* mode, default locale and declared locales are passed explicitly here — this
+* package declares none of them, so the registry defaults would collapse every
+* locale onto the default one.
+*/
+describe("LocalizedUrl", () => {
+	it("should prefix a path with a non-default locale", () => {
+		expectTypeOf().toEqualTypeOf();
+	});
+	it("should collapse the root to a bare prefix, never a trailing slash", () => {
+		expectTypeOf().toEqualTypeOf();
+	});
+	it("should leave the default locale unprefixed", () => {
+		expectTypeOf().toEqualTypeOf();
+		expectTypeOf().toEqualTypeOf();
+	});
+	it("should drop the trailing slash of a non-root path", () => {
+		expectTypeOf().toEqualTypeOf();
+	});
+	it("should replace an existing locale segment", () => {
+		expectTypeOf().toEqualTypeOf();
+		expectTypeOf().toEqualTypeOf();
+	});
+	it("should prefix the pathname of an absolute URL, not its origin", () => {
+		expectTypeOf().toEqualTypeOf();
+		expectTypeOf().toEqualTypeOf();
+	});
+	it("should prefix every locale in prefix-all mode", () => {
+		expectTypeOf().toEqualTypeOf();
+		expectTypeOf().toEqualTypeOf();
+	});
+	it("should strip the locale in no-prefix mode", () => {
+		expectTypeOf().toEqualTypeOf();
+	});
+});
+
+//#endregion
+//# sourceMappingURL=getLocalizedUrl.test-d.mjs.map

package/dist/esm/localization/getLocalizedUrl.test-d.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"getLocalizedUrl.test-d.mjs","names":[],"sources":["../../../src/localization/getLocalizedUrl.test-d.ts"],"sourcesContent":["import type { LocalizedUrl } from '@intlayer/types/module_augmentation';\nimport { describe, expectTypeOf, it } from 'vitest';\n\n/**\n * `LocalizedUrl` mirrors what `getLocalizedUrl` builds at runtime. The routing\n * mode, default locale and declared locales are passed explicitly here — this\n * package declares none of them, so the registry defaults would collapse every\n * locale onto the default one.\n */\ndescribe('LocalizedUrl', () => {\n  type Locales = 'en' | 'fr' | 'es';\n  type Url<Path extends string, L extends Locales> = LocalizedUrl<\n    Path,\n    L,\n    'prefix-no-default',\n    'en',\n    Locales\n  >;\n\n  it('should prefix a path with a non-default locale', () => {\n    expectTypeOf<Url<'/about', 'es'>>().toEqualTypeOf<'/es/about'>();\n  });\n\n  it('should collapse the root to a bare prefix, never a trailing slash', () => {\n    expectTypeOf<Url<'/', 'es'>>().toEqualTypeOf<'/es'>();\n  });\n\n  it('should leave the default locale unprefixed', () => {\n    expectTypeOf<Url<'/about', 'en'>>().toEqualTypeOf<'/about'>();\n    expectTypeOf<Url<'/', 'en'>>().toEqualTypeOf<'/'>();\n  });\n\n  it('should drop the trailing slash of a non-root path', () => {\n    expectTypeOf<Url<'/about/', 'fr'>>().toEqualTypeOf<'/fr/about'>();\n  });\n\n  it('should replace an existing locale segment', () => {\n    expectTypeOf<Url<'/en/about', 'fr'>>().toEqualTypeOf<'/fr/about'>();\n    expectTypeOf<Url<'/fr', 'es'>>().toEqualTypeOf<'/es'>();\n  });\n\n  it('should prefix the pathname of an absolute URL, not its origin', () => {\n    expectTypeOf<\n      Url<'https://example.com/about', 'fr'>\n    >().toEqualTypeOf<'https://example.com/fr/about'>();\n    expectTypeOf<\n      Url<'https://example.com/', 'fr'>\n    >().toEqualTypeOf<'https://example.com/fr'>();\n  });\n\n  it('should prefix every locale in prefix-all mode', () => {\n    expectTypeOf<\n      LocalizedUrl<'/', 'en', 'prefix-all', 'en', Locales>\n    >().toEqualTypeOf<'/en'>();\n    expectTypeOf<\n      LocalizedUrl<'/about', 'en', 'prefix-all', 'en', Locales>\n    >().toEqualTypeOf<'/en/about'>();\n  });\n\n  it('should strip the locale in no-prefix mode', () => {\n    expectTypeOf<\n      LocalizedUrl<'/fr/about', 'fr', 'no-prefix', 'en', Locales>\n    >().toEqualTypeOf<'/about'>();\n  });\n});\n"],"mappings":";;;;;;;;;AASA,SAAS,sBAAsB;CAU7B,GAAG,wDAAwD;EACzD,aAAkC,CAAC,CAAC,cAA2B;CACjE,CAAC;CAED,GAAG,2EAA2E;EAC5E,aAA6B,CAAC,CAAC,cAAqB;CACtD,CAAC;CAED,GAAG,oDAAoD;EACrD,aAAkC,CAAC,CAAC,cAAwB;EAC5D,aAA6B,CAAC,CAAC,cAAmB;CACpD,CAAC;CAED,GAAG,2DAA2D;EAC5D,aAAmC,CAAC,CAAC,cAA2B;CAClE,CAAC;CAED,GAAG,mDAAmD;EACpD,aAAqC,CAAC,CAAC,cAA2B;EAClE,aAA+B,CAAC,CAAC,cAAqB;CACxD,CAAC;CAED,GAAG,uEAAuE;EACxE,aAEE,CAAC,CAAC,cAA8C;EAClD,aAEE,CAAC,CAAC,cAAwC;CAC9C,CAAC;CAED,GAAG,uDAAuD;EACxD,aAEE,CAAC,CAAC,cAAqB;EACzB,aAEE,CAAC,CAAC,cAA2B;CACjC,CAAC;CAED,GAAG,mDAAmD;EACpD,aAEE,CAAC,CAAC,cAAwB;CAC9B,CAAC;AACH,CAAC"}

package/dist/esm/localization/getPathWithoutLocale.mjs

@@ -44,7 +44,7 @@ const getPathWithoutLocale = (inputUrl, locales = internationalization?.locales)
 	const isAbsoluteUrl = checkIsURLAbsolute(inputUrl);
 	let fixedInputUrl = inputUrl;
 	if (inputUrl?.endsWith("/")) fixedInputUrl = inputUrl.slice(0, -1);
-	const url = isAbsoluteUrl ? new URL(fixedInputUrl) : new URL(fixedInputUrl, "http://example.com");
+	const url = isAbsoluteUrl ? new URL(fixedInputUrl) : new URL(fixedInputUrl, "http://e.com");
 	const pathname = url.pathname;
 	if (!pathname.startsWith("/")) url.pathname = `/${pathname}`;
 	if (!TREE_SHAKE_PREFIX_MODES) {
@@ -63,7 +63,7 @@ const getPathWithoutLocale = (inputUrl, locales = internationalization?.locales)
 		}
 	}
 	if (isAbsoluteUrl) return url.toString();
-	return url.toString().replace("http://example.com", "");
+	return url.toString().replace("http://e.com", "");
 };
 
 //#endregion

package/dist/esm/localization/getPathWithoutLocale.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"getPathWithoutLocale.mjs","names":[],"sources":["../../../src/localization/getPathWithoutLocale.ts"],"sourcesContent":["import { internationalization } from '@intlayer/config/built';\n\n// ── Tree-shake constants ──────────────────────────────────────────────────────\n// When these env vars are injected at build time, bundlers eliminate the\n// branches guarded by these constants.\n\n/**\n * True when the build-time routing mode is known and is not a prefix-based\n * mode (neither 'prefix-all' nor 'prefix-no-default').\n */\nconst TREE_SHAKE_PREFIX_MODES =\n  process.env.INTLAYER_ROUTING_MODE &&\n  process.env.INTLAYER_ROUTING_MODE !== 'prefix-all' &&\n  process.env.INTLAYER_ROUTING_MODE !== 'prefix-no-default';\n\n/**\n * True when the build-time routing mode is known and is NOT 'search-params'.\n */\nconst TREE_SHAKE_SEARCH_PARAMS =\n  process.env.INTLAYER_ROUTING_MODE &&\n  process.env.INTLAYER_ROUTING_MODE !== 'search-params';\n\nimport type {\n  DeclaredLocales,\n  LocalesValues,\n  PathWithoutLocale,\n} from '@intlayer/types/module_augmentation';\nimport { checkIsURLAbsolute } from '../utils/checkIsURLAbsolute';\n\n/**\n * Removes the locale segment from the given URL or pathname if present.\n * Also removes locale from search parameters if present.\n *\n * This function get the locales from the configuration if not provided.\n *\n * Example:\n *\n * ```ts\n * getPathWithoutLocale('/en/dashboard') // Returns '/dashboard'\n * getPathWithoutLocale('/fr/dashboard') // Returns '/dashboard'\n * getPathWithoutLocale('/dashboard') // Returns '/dashboard'\n * getPathWithoutLocale('dashboard') // Returns 'dashboard'\n * getPathWithoutLocale('/dashboard?locale=fr') // Returns '/dashboard'\n * getPathWithoutLocale('https://example.com/en/dashboard') // Returns 'https://example.com/dashboard'\n * getPathWithoutLocale('https://example.com/fr/dashboard') // Returns 'https://example.com/dashboard'\n * getPathWithoutLocale('https://example.com/dashboard') // Returns 'https://example.com/dashboard'\n * getPathWithoutLocale('https://example.com/dashboard?locale=fr') // Returns 'https://example.com/dashboard'\n * ```\n *\n * @param inputUrl - The complete URL string or pathname to process.\n * @param locales - Optional array of supported locales. Defaults to `localesDefault`.\n * @returns The URL string or pathname without the locale segment or locale search parameter.\n */\n/**\n * The return type is narrowed to a template-literal type when both `inputUrl`\n * and `locales` are string literals known at compile time. Absolute URLs fall\n * back to `string`.\n */\nexport const getPathWithoutLocale = <\n  const T extends string,\n  const L extends LocalesValues = DeclaredLocales,\n>(\n  inputUrl: T,\n  locales: L[] = internationalization?.locales as L[]\n): PathWithoutLocale<T, L> => {\n  // Determine if the original URL is absolute (includes protocol)\n  const isAbsoluteUrl = checkIsURLAbsolute(inputUrl);\n\n  let fixedInputUrl = inputUrl;\n\n  if (inputUrl?.endsWith('/')) {\n    fixedInputUrl = inputUrl.slice(0, -1);\n  }\n\n  // Initialize a URL object if the URL is absolute\n  // For relative URLs, use a dummy base to leverage the URL API\n  const url = isAbsoluteUrl\n    ? new URL(fixedInputUrl)\n    : new URL(fixedInputUrl, 'http://example.com');\n\n  const pathname = url.pathname;\n\n  // Ensure the pathname starts with '/'\n  if (!pathname.startsWith('/')) {\n    // If not, return the URL as is\n    url.pathname = `/${pathname}`;\n  }\n\n  // Only strip locale path prefix in prefix-based routing modes\n  if (!TREE_SHAKE_PREFIX_MODES) {\n    // Split the pathname to extract the first segment\n    const pathSegments = pathname.split('/');\n    const firstSegment = pathSegments[1]; // The segment after the first '/'\n\n    // Check if the first segment is a supported locale\n    if (locales?.includes(firstSegment as L)) {\n      // Remove the locale segment from the pathname\n      pathSegments.splice(1, 1); // Remove the first segment\n\n      // Reconstruct the pathname\n      const newPathname = pathSegments.join('/') ?? '/';\n      url.pathname = newPathname;\n    }\n  }\n\n  // Only strip locale from search parameters in search-params routing mode\n  if (!TREE_SHAKE_SEARCH_PARAMS) {\n    const searchParams = new URLSearchParams(url.search);\n    if (searchParams.has('locale')) {\n      searchParams.delete('locale');\n      url.search = searchParams.toString();\n    }\n  }\n\n  if (isAbsoluteUrl) {\n    return url.toString() as PathWithoutLocale<T, L>;\n  }\n\n  return url.toString().replace('http://example.com', '') as PathWithoutLocale<\n    T,\n    L\n  >;\n};\n"],"mappings":";;;;;;;;AAUA,MAAM,0BACJ,QAAQ,IAAI,yBACZ,QAAQ,IAAI,0BAA0B,gBACtC,QAAQ,IAAI,0BAA0B;;;;AAKxC,MAAM,2BACJ,QAAQ,IAAI,yBACZ,QAAQ,IAAI,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCxC,MAAa,wBAIX,UACA,UAAe,sBAAsB,YACT;CAE5B,MAAM,gBAAgB,mBAAmB,QAAQ;CAEjD,IAAI,gBAAgB;CAEpB,IAAI,UAAU,SAAS,GAAG,GACxB,gBAAgB,SAAS,MAAM,GAAG,EAAE;CAKtC,MAAM,MAAM,gBACR,IAAI,IAAI,aAAa,IACrB,IAAI,IAAI,eAAe,oBAAoB;CAE/C,MAAM,WAAW,IAAI;CAGrB,IAAI,CAAC,SAAS,WAAW,GAAG,GAE1B,IAAI,WAAW,IAAI;CAIrB,IAAI,CAAC,yBAAyB;EAE5B,MAAM,eAAe,SAAS,MAAM,GAAG;EACvC,MAAM,eAAe,aAAa;EAGlC,IAAI,SAAS,SAAS,YAAiB,GAAG;GAExC,aAAa,OAAO,GAAG,CAAC;GAIxB,IAAI,WADgB,aAAa,KAAK,GAAG,KAAK;EAEhD;CACF;CAGA,IAAI,CAAC,0BAA0B;EAC7B,MAAM,eAAe,IAAI,gBAAgB,IAAI,MAAM;EACnD,IAAI,aAAa,IAAI,QAAQ,GAAG;GAC9B,aAAa,OAAO,QAAQ;GAC5B,IAAI,SAAS,aAAa,SAAS;EACrC;CACF;CAEA,IAAI,eACF,OAAO,IAAI,SAAS;CAGtB,OAAO,IAAI,SAAS,CAAC,CAAC,QAAQ,sBAAsB,EAAE;AAIxD"}
+{"version":3,"file":"getPathWithoutLocale.mjs","names":[],"sources":["../../../src/localization/getPathWithoutLocale.ts"],"sourcesContent":["import { internationalization } from '@intlayer/config/built';\n\n// ── Tree-shake constants ──────────────────────────────────────────────────────\n// When these env vars are injected at build time, bundlers eliminate the\n// branches guarded by these constants.\n\n/**\n * True when the build-time routing mode is known and is not a prefix-based\n * mode (neither 'prefix-all' nor 'prefix-no-default').\n */\nconst TREE_SHAKE_PREFIX_MODES =\n  process.env.INTLAYER_ROUTING_MODE &&\n  process.env.INTLAYER_ROUTING_MODE !== 'prefix-all' &&\n  process.env.INTLAYER_ROUTING_MODE !== 'prefix-no-default';\n\n/**\n * True when the build-time routing mode is known and is NOT 'search-params'.\n */\nconst TREE_SHAKE_SEARCH_PARAMS =\n  process.env.INTLAYER_ROUTING_MODE &&\n  process.env.INTLAYER_ROUTING_MODE !== 'search-params';\n\nimport type {\n  DeclaredLocales,\n  LocalesValues,\n  PathWithoutLocale,\n} from '@intlayer/types/module_augmentation';\nimport { checkIsURLAbsolute } from '../utils/checkIsURLAbsolute';\n\n/**\n * Removes the locale segment from the given URL or pathname if present.\n * Also removes locale from search parameters if present.\n *\n * This function get the locales from the configuration if not provided.\n *\n * Example:\n *\n * ```ts\n * getPathWithoutLocale('/en/dashboard') // Returns '/dashboard'\n * getPathWithoutLocale('/fr/dashboard') // Returns '/dashboard'\n * getPathWithoutLocale('/dashboard') // Returns '/dashboard'\n * getPathWithoutLocale('dashboard') // Returns 'dashboard'\n * getPathWithoutLocale('/dashboard?locale=fr') // Returns '/dashboard'\n * getPathWithoutLocale('https://example.com/en/dashboard') // Returns 'https://example.com/dashboard'\n * getPathWithoutLocale('https://example.com/fr/dashboard') // Returns 'https://example.com/dashboard'\n * getPathWithoutLocale('https://example.com/dashboard') // Returns 'https://example.com/dashboard'\n * getPathWithoutLocale('https://example.com/dashboard?locale=fr') // Returns 'https://example.com/dashboard'\n * ```\n *\n * @param inputUrl - The complete URL string or pathname to process.\n * @param locales - Optional array of supported locales. Defaults to `localesDefault`.\n * @returns The URL string or pathname without the locale segment or locale search parameter.\n */\n/**\n * The return type is narrowed to a template-literal type when both `inputUrl`\n * and `locales` are string literals known at compile time. Absolute URLs fall\n * back to `string`.\n */\nexport const getPathWithoutLocale = <\n  const T extends string,\n  const L extends LocalesValues = DeclaredLocales,\n>(\n  inputUrl: T,\n  locales: L[] = internationalization?.locales as L[]\n): PathWithoutLocale<T, L> => {\n  // Determine if the original URL is absolute (includes protocol)\n  const isAbsoluteUrl = checkIsURLAbsolute(inputUrl);\n\n  let fixedInputUrl = inputUrl;\n\n  if (inputUrl?.endsWith('/')) {\n    fixedInputUrl = inputUrl.slice(0, -1);\n  }\n\n  // Initialize a URL object if the URL is absolute\n  // For relative URLs, use a dummy base to leverage the URL API\n  const url = isAbsoluteUrl\n    ? new URL(fixedInputUrl)\n    : new URL(fixedInputUrl, 'http://e.com');\n\n  const pathname = url.pathname;\n\n  // Ensure the pathname starts with '/'\n  if (!pathname.startsWith('/')) {\n    // If not, return the URL as is\n    url.pathname = `/${pathname}`;\n  }\n\n  // Only strip locale path prefix in prefix-based routing modes\n  if (!TREE_SHAKE_PREFIX_MODES) {\n    // Split the pathname to extract the first segment\n    const pathSegments = pathname.split('/');\n    const firstSegment = pathSegments[1]; // The segment after the first '/'\n\n    // Check if the first segment is a supported locale\n    if (locales?.includes(firstSegment as L)) {\n      // Remove the locale segment from the pathname\n      pathSegments.splice(1, 1); // Remove the first segment\n\n      // Reconstruct the pathname\n      const newPathname = pathSegments.join('/') ?? '/';\n      url.pathname = newPathname;\n    }\n  }\n\n  // Only strip locale from search parameters in search-params routing mode\n  if (!TREE_SHAKE_SEARCH_PARAMS) {\n    const searchParams = new URLSearchParams(url.search);\n    if (searchParams.has('locale')) {\n      searchParams.delete('locale');\n      url.search = searchParams.toString();\n    }\n  }\n\n  if (isAbsoluteUrl) {\n    return url.toString() as PathWithoutLocale<T, L>;\n  }\n\n  return url.toString().replace('http://e.com', '') as PathWithoutLocale<T, L>;\n};\n"],"mappings":";;;;;;;;AAUA,MAAM,0BACJ,QAAQ,IAAI,yBACZ,QAAQ,IAAI,0BAA0B,gBACtC,QAAQ,IAAI,0BAA0B;;;;AAKxC,MAAM,2BACJ,QAAQ,IAAI,yBACZ,QAAQ,IAAI,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCxC,MAAa,wBAIX,UACA,UAAe,sBAAsB,YACT;CAE5B,MAAM,gBAAgB,mBAAmB,QAAQ;CAEjD,IAAI,gBAAgB;CAEpB,IAAI,UAAU,SAAS,GAAG,GACxB,gBAAgB,SAAS,MAAM,GAAG,EAAE;CAKtC,MAAM,MAAM,gBACR,IAAI,IAAI,aAAa,IACrB,IAAI,IAAI,eAAe,cAAc;CAEzC,MAAM,WAAW,IAAI;CAGrB,IAAI,CAAC,SAAS,WAAW,GAAG,GAE1B,IAAI,WAAW,IAAI;CAIrB,IAAI,CAAC,yBAAyB;EAE5B,MAAM,eAAe,SAAS,MAAM,GAAG;EACvC,MAAM,eAAe,aAAa;EAGlC,IAAI,SAAS,SAAS,YAAiB,GAAG;GAExC,aAAa,OAAO,GAAG,CAAC;GAIxB,IAAI,WADgB,aAAa,KAAK,GAAG,KAAK;EAEhD;CACF;CAGA,IAAI,CAAC,0BAA0B;EAC7B,MAAM,eAAe,IAAI,gBAAgB,IAAI,MAAM;EACnD,IAAI,aAAa,IAAI,QAAQ,GAAG;GAC9B,aAAa,OAAO,QAAQ;GAC5B,IAAI,SAAS,aAAa,SAAS;EACrC;CACF;CAEA,IAAI,eACF,OAAO,IAAI,SAAS;CAGtB,OAAO,IAAI,SAAS,CAAC,CAAC,QAAQ,gBAAgB,EAAE;AAClD"}

package/dist/esm/localization/getPrefix.mjs

@@ -16,6 +16,19 @@ const resolveRoutingConfig = (options = {}) => ({
 	...options
 });
 /**
+* Narrows an arbitrary string to a declared locale by membership test.
+*
+* `locales` is typed as `DeclaredLocales[]`, so a plain `includes` rejects the
+* `string` values that actually need testing (a URL segment, a query param, a
+* stored value). This keeps the check honest and hands back a narrowed type
+* instead of forcing a cast at every call site.
+*
+* @param value - The candidate locale, from a URL segment / storage / header.
+* @param locales - The locales declared by the configuration.
+* @returns Whether `value` is one of the declared locales.
+*/
+const isDeclaredLocale = (value, locales) => !!value && (locales ?? internationalization.locales).includes(value);
+/**
 * Determines the URL prefix for a given locale based on the routing mode configuration.
 *
 * Example:
@@ -50,7 +63,7 @@ const resolveRoutingConfig = (options = {}) => ({
 */
 const getPrefix = (locale, options = {}) => {
 	const { defaultLocale, mode, locales, domains } = resolveRoutingConfig(options);
-	if (process.env.INTLAYER_ROUTING_MODE && process.env.INTLAYER_ROUTING_MODE !== "prefix-all" && process.env.INTLAYER_ROUTING_MODE !== "prefix-no-default" || !locale || !locales.includes(locale)) return {
+	if (process.env.INTLAYER_ROUTING_MODE && process.env.INTLAYER_ROUTING_MODE !== "prefix-all" && process.env.INTLAYER_ROUTING_MODE !== "prefix-no-default" || !locale || !isDeclaredLocale(locale, locales)) return {
 		prefix: "",
 		localePrefix: void 0
 	};
@@ -69,5 +82,5 @@ const getPrefix = (locale, options = {}) => {
 };
 
 //#endregion
-export { getPrefix, resolveRoutingConfig };
+export { getPrefix, isDeclaredLocale, resolveRoutingConfig };
 //# sourceMappingURL=getPrefix.mjs.map