@salesforce/storefront-next-runtime 0.3.1 → 0.4.0-alpha.0

package/dist/site-context.d.ts

@@ -1,8 +1,8 @@
 import { n as Site$1, r as Url, t as Locale$1 } from "./types.js";
 import { PropsWithChildren } from "react";
 import * as react_jsx_runtime2 from "react/jsx-runtime";
-import * as react_router0 from "react-router";
-import { Cookie, MiddlewareFunction, RouterContextProvider } from "react-router";
+import * as react_router10 from "react-router";
+import { Cookie, CookieOptions, MiddlewareFunction, RouterContextProvider } from "react-router";
 import { RouteConfigEntry } from "@react-router/dev/routes";
 
 //#region src/site-context/types.d.ts
@@ -18,8 +18,10 @@ type Site = Omit<Site$1, 'supportedLocales'> & {
 type SiteContext = {
   site: Site;
   locale: Locale;
+  currency: string;
   siteCookie: Cookie;
   localeCookie: Cookie;
+  currencyCookie: Cookie;
 };
 /**
  * Configuration passed into the site context middleware
@@ -31,6 +33,18 @@ type SiteConfig = {
   defaultLocale: string;
   siteDetectionConfig?: DetectionConfig;
   localeDetectionConfig?: DetectionConfig;
+  currencyCookieName?: string;
+  cookieOptions?: CookieOptions;
+};
+/**
+ * Resolved settings used by site/locale/currency resolution (all detection options have values).
+ */
+type SiteSettings = SiteConfig & {
+  siteDetectionConfig: Required<DetectionConfig>;
+  localeDetectionConfig: Required<DetectionConfig>;
+  siteCookie: Cookie;
+  localeCookie: Cookie;
+  currencyCookie: Cookie;
 };
 /** Detection method identifier (used for both site and locale detection) */
 type DetectionMethod = 'path' | 'querystring' | 'cookie' | 'header';
@@ -45,23 +59,56 @@ type DetectionConfig = {
 //#endregion
 //#region src/site-context/site-context.d.ts
 /**
- * Provides the current site to the component tree.
- * Follows the same pattern as CurrencyProvider.
+ * The value provided by {@link SiteProvider} and returned by {@link useSite}.
+ */
+type SiteContextValue = {
+  /**
+   * The resolved site configuration object for the current request.
+   * Contains the site's supported locales, supported currencies, and default values.
+   */
+  site: Site;
+  /**
+   * The full locale object from the site's `supportedLocales` list for the current request.
+   * Contains structured locale metadata: `id` (e.g. `"en-GB"`), optional `alias` (e.g. `"en"`),
+   * and optional `preferredCurrency`.
+   *
+   */
+  locale: Locale;
+  /**
+   * The current i18next language string (e.g. `"en-GB"`, `"fr-FR"`).
+   * This is the value returned by `i18next.language` and drives which translation
+   * namespace is active. Passed as a prop because the SDK has no react-i18next dependency.
+   *
+   * @see {@link SiteContextValue.locale} for the full locale object from site config.
+   */
+  language: string;
+  /**
+   * The active currency code for the current session (e.g. `"USD"`, `"GBP"`).
+   * Resolved from the locale's `preferredCurrency`, a currency cookie, or the site's
+   * `defaultCurrency`.
+   */
+  currency: string;
+};
+/**
+ * Provides the current site context (site, locale, language, currency) to the component tree.
  *
- * Mounted in the template (e.g., app-wrapper.tsx or root.tsx) with the resolved
- * site value from the loader/middleware.
+ * Mounted in the template's root.tsx with the resolved values from the
+ * loader/middleware. The SDK has no react-i18next dependency, so `language`
+ * is passed as a prop from the template.
  */
 declare function SiteProvider({
-  value,
+  site,
+  locale,
+  language,
+  currency,
   children
-}: PropsWithChildren<{
-  value: Site;
-}>): react_jsx_runtime2.JSX.Element;
+}: PropsWithChildren<SiteContextValue>): react_jsx_runtime2.JSX.Element;
 /**
- * React hook to get the current site.
- * Returns undefined when no SiteProvider is mounted.
+ * React hook to get the current site context.
+ * Returns `{ site, locale, language, currency }`.
+ * @throws If called outside of a SiteProvider
  */
-declare function useSite(): Site | undefined;
+declare function useSite(): SiteContextValue;
 //#endregion
 //#region src/site-context/apply-url-config.d.ts
 /**
@@ -135,7 +182,35 @@ declare function buildUrl({
 }): string;
 //#endregion
 //#region src/site-context/middleware.d.ts
-declare const siteContext: react_router0.RouterContext<SiteContext | null>;
+declare const siteContext: react_router10.RouterContext<SiteContext | null>;
+/**
+ * Resolved site context result from {@link resolveSiteContext}.
+ */
+type ResolvedSiteContext = {
+  site: Site;
+  locale: Locale;
+  currency: string;
+};
+/**
+ * Resolve site, locale, and currency from a request in one call.
+ *
+ * This is the recommended public entry point for site-context resolution.
+ * It encapsulates the required resolution order (site → locale → currency)
+ * so consumers don't need to manage the dependency chain manually.
+ *
+ * The individual resolvers (`resolveSite`, `resolveLocale`, `resolveCurrency`)
+ * are available as advanced utilities for cases that need fine-grained control.
+ *
+ * @param request - Incoming HTTP request
+ * @param settings - Fully resolved site settings (with detection config and cookies)
+ * @returns Resolved site, locale, and currency
+ *
+ * @example
+ * ```typescript
+ * const { site, locale, currency } = await resolveSiteContext(request, settings);
+ * ```
+ */
+declare function resolveSiteContext(request: Request, settings: SiteSettings): Promise<ResolvedSiteContext>;
 /**
  * Helper function to get site context cookies from router context.
  * Useful in server actions and loaders that need to read/set cookies.
@@ -155,8 +230,9 @@ declare const siteContext: react_router0.RouterContext<SiteContext | null>;
  * ```
  */
 declare function getSiteContextCookies(context: Readonly<RouterContextProvider>): {
-  siteCookie: react_router0.Cookie;
-  localeCookie: react_router0.Cookie;
+  siteCookie: react_router10.Cookie;
+  localeCookie: react_router10.Cookie;
+  currencyCookie: react_router10.Cookie;
 } | null;
 /**
  * Creates a site context middleware that resolves the current site from
@@ -175,5 +251,5 @@ declare function createSiteContextMiddleware(config: SiteConfig): MiddlewareFunc
  */
 declare const requestToLocaleMap: WeakMap<Request, string>;
 //#endregion
-export { type DetectionConfig, type Locale, type Site, type SiteConfig, type SiteContext, SiteProvider, applyUrlConfig, buildUrl, createSiteContextMiddleware, getSiteContextCookies, requestToLocaleMap, resolvePrefix, sanitizePrefix, siteContext, stripPathPrefix, useSite };
+export { type DetectionConfig, type Locale, type ResolvedSiteContext, type Site, type SiteConfig, type SiteContext, type SiteContextValue, SiteProvider, type SiteSettings, applyUrlConfig, buildUrl, createSiteContextMiddleware, getSiteContextCookies, requestToLocaleMap, resolvePrefix, resolveSiteContext, sanitizePrefix, siteContext, stripPathPrefix, useSite };
 //# sourceMappingURL=site-context.d.ts.map

package/dist/site-context.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"site-context.d.ts","names":[],"sources":["../src/site-context/types.ts","../src/site-context/site-context.tsx","../src/site-context/apply-url-config.ts","../src/site-context/build-url.ts","../src/site-context/middleware.ts","../src/site-context/cookies.ts"],"sourcesContent":[],"mappings":";;;;;;;;;AAiCgB,KAbJ,MAAA,GAAS,QAaL,GAAA;EACE,KAAA,CAAA,EAAA,MAAA;CAAM;AAOZ,KAjBA,IAAA,GAAO,IAiBG,CAjBE,MAiBF,EAAA,kBAAA,CAAA,GAAA;EACX,IAAA,CAAA,EAAA,MAAA;EAGe,KAAA,CAAA,EAAA,MAAA;EACE,gBAAA,EAnBN,MAmBM,EAAA;CAAe;AAc/B,KA9BA,WAAA,GA8Be;EAGf,IAAA,EAhCF,IAgCE;UA/BA;cACI;gBACE;ACPlB,CAAA;;;;;AAAoF,KDcxE,UAAA,GCdwE;EAAA,KAAA,EDezE,ICfyE,EAAA;EASpE,aAAO,EAAA,MAAA;;wBDSG;0BACE;AE0E5B,CAAA;ACnBA;AAmBgB,KH5DJ,eAAA,GG4DY,MAAA,GAAA,aAAA,GAAA,QAAA,GAAA,QAAA;AACpB,KH1DQ,eAAA,GG0DR;EACA,KAAA,EH1DO,eG0DP,EAAA;EACA,mBAAA,CAAA,EAAA,MAAA;EAGY,iBAAA,CAAA,EAAA,MAAA;EACJ,YAAA,CAAA,EAAA,MAAA;EAAM,YAAA,CAAA,EAAA,MAAA;WH1DL;;;;;;;AA5Bb;;;;AAK2C,iBCnB3B,YAAA,CDmB2B;EAAA,KAAA;EAAA;AAiB3C,CAjB2C,ECnBO,iBDmBP,CAAA;EAc/B,KAAA,ECjCiE,IDiCjE;AAGZ,CAAA,CAAA,CAAA,ECpCoF,kBAAA,CAAA,GAAA,CAAA,ODqCzE;;;;ACrCX;AAA+B,iBASf,OAAA,CAAA,CATe,EASJ,IATI,GAAA,SAAA;;;;AC6F/B;;;;;;;;AC/DA;AA0BA;AAkBA;AAmBA;;AAEI,iBDFY,cAAA,CCEZ,OAAA,EAAA;EACA,MAAA,EDFQ,gBCER,EAAA;EAGY,SAAA,CAAA,EDJA,GCIA;EACJ,WAAA,EAAA,MAAA;CAAM,CAAA,EDHd,gBCGc,EAAA;;;;;AF3FlB;;iBEqBgB,aAAA,yBAAsC;;AD+DtD;;;;;;;;AC/DA;AA0BA;AAkBA;AAmBA;;;AAGI,iBAxCY,eAAA,CAwCZ,QAAA,EAAA,MAAA,EAAA,aAAA,EAAA,MAAA,CAAA,EAAA,MAAA;;;;;;iBAtBY,cAAA;AC9EhB;AAsBA;;;;;;AAoEA;;;;;iBDOgB,QAAA;;;;;;cAMA;EEnFH,MAAA,EFoFD,MEpFC,CAAA,MAAmD,EAAA,MAAA,CAAA;;;;ALVhD,cIVH,WJUG,EIVQ,aAAA,CAAA,aJUR,CIVQ,WJUR,GAAA,IAAA,CAAA;;;AAQhB;;;;;AAmBA;AAGA;;;;ACpCA;;;;;;AAAoF,iBGkBpE,qBAAA,CHlBoE,OAAA,EGkBrC,QHlBqC,CGkB5B,qBHlB4B,CAAA,CAAA,EAAA;EASpE,UAAO,EGSgC,aAAA,CAAA,MHTxB;;;;ACoF/B;;;;;;iBEPgB,2BAAA,SAAoC,aAAa,mBAAmB;;;;;;;;AH7EpE,cIOH,kBJPkB,EIOA,OJPA,CIOA,OJPA,EAAA,MAAA,CAAA"}
+{"version":3,"file":"site-context.d.ts","names":[],"sources":["../src/site-context/types.ts","../src/site-context/site-context.tsx","../src/site-context/apply-url-config.ts","../src/site-context/build-url.ts","../src/site-context/middleware.ts","../src/site-context/cookies.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/site-context.js

@@ -1,419 +1,4 @@
+import { a as requestToLocaleMap, c as sanitizePrefix, d as useSite, i as siteContext, l as stripPathPrefix, n as getSiteContextCookies, o as buildUrl, r as resolveSiteContext, s as resolvePrefix, t as createSiteContextMiddleware, u as SiteProvider } from "./site-context2.js";
 import { t as applyUrlConfig } from "./apply-url-config.js";
-import { createContext, useContext } from "react";
-import { jsx } from "react/jsx-runtime";
-import { createContext as createContext$1, createCookie } from "react-router";
 
-//#region src/site-context/site-context.tsx
-const SiteContext = createContext(void 0);
-/**
-* Provides the current site to the component tree.
-* Follows the same pattern as CurrencyProvider.
-*
-* Mounted in the template (e.g., app-wrapper.tsx or root.tsx) with the resolved
-* site value from the loader/middleware.
-*/
-function SiteProvider({ value, children }) {
-	return /* @__PURE__ */ jsx(SiteContext.Provider, {
-		value,
-		children
-	});
-}
-/**
-* React hook to get the current site.
-* Returns undefined when no SiteProvider is mounted.
-*/
-function useSite() {
-	return useContext(SiteContext);
-}
-
-//#endregion
-//#region src/site-context/build-url.ts
-/**
-* Parses search config string into key-value pairs, preserving ':param' placeholders.
-* '?lng=:localeId&site=:siteId' → { lng: ':localeId', site: ':siteId' }
-*/
-function parseSearchConfig(search) {
-	const searchParams = new URLSearchParams(search);
-	const result = {};
-	for (const [key, value] of searchParams) result[key] = value;
-	return result;
-}
-/**
-* Extracts parameter names from a prefix string.
-* '/:siteId/:localeId' → ['siteId', 'localeId']
-*/
-function extractPrefixParams(prefix) {
-	const matches = prefix.match(/:(\w+)/g);
-	return matches ? matches.map((m) => m.slice(1)) : [];
-}
-/**
-* Splits a URL string into its component parts.
-* '/product/123?color=red#details' → { pathname: '/product/123', search: 'color=red', hash: '#details' }
-*/
-function decomposeUrl(url) {
-	const hashIdx = url.indexOf("#");
-	const hash = hashIdx >= 0 ? url.slice(hashIdx) : "";
-	const withoutHash = hashIdx >= 0 ? url.slice(0, hashIdx) : url;
-	const searchIdx = withoutHash.indexOf("?");
-	const search = searchIdx >= 0 ? withoutHash.slice(searchIdx + 1) : "";
-	return {
-		pathname: searchIdx >= 0 ? withoutHash.slice(0, searchIdx) : withoutHash,
-		search,
-		hash
-	};
-}
-/**
-* Resolves a prefix template by replacing parameter placeholders with values.
-* ('/:siteId/:localeId', { siteId: 'global', localeId: 'en-GB' }) → '/global/en-GB'
-*/
-function resolvePrefix(prefix, params) {
-	let resolved = prefix;
-	for (const paramName of extractPrefixParams(prefix)) {
-		const value = params[paramName];
-		if (value) resolved = resolved.replace(`:${paramName}`, value);
-	}
-	return resolved;
-}
-/**
-* Strips the URL prefix segments from a pathname based on a prefix pattern.
-* Since all routes are configured with the prefix baked in, segment counting is sufficient.
-*
-* @param pathname - Full pathname (e.g. '/global/en-GB/checkout')
-* @param prefixPattern - URL prefix pattern from config (e.g. '/:siteId/:localeId')
-* @returns Pathname with prefix stripped (e.g. '/checkout'), or original if
-*          the pathname has fewer segments than the prefix
-*
-* @example
-* stripPathPrefix('/global/en-GB/checkout', '/:siteId/:localeId') // → '/checkout'
-* stripPathPrefix('/checkout', '/:siteId/:localeId')              // → '/checkout' (fewer segments → unchanged)
-* stripPathPrefix('/checkout', '')                                 // → '/checkout' (no prefix configured)
-* stripPathPrefix('/', '/:siteId/:localeId')                      // → '/'
-*/
-function stripPathPrefix(pathname, prefixPattern) {
-	if (!prefixPattern) return pathname;
-	const prefixSegmentCount = prefixPattern.split("/").filter(Boolean).length;
-	const pathSegments = pathname.split("/").filter(Boolean);
-	if (pathSegments.length <= prefixSegmentCount) return pathSegments.length === prefixSegmentCount ? "/" : pathname;
-	return `/${pathSegments.slice(prefixSegmentCount).join("/")}`;
-}
-/**
-* Sanitize a resolved prefix from a pathname if present.
-* sanitizePrefix('/global/en-GB/product/123', '/global/en-GB') → '/product/123'
-* sanitizePrefix('/product/123', '/global/en-GB') → '/product/123'   (no-op)
-*/
-function sanitizePrefix(pathname, pathPrefix) {
-	if (!pathPrefix) return pathname;
-	if (pathname === pathPrefix) return "";
-	if (pathname.startsWith(`${pathPrefix}/`)) return pathname.slice(pathPrefix.length);
-	return pathname;
-}
-/**
-* Builds a fully-qualified URL with site context prefix and search params.
-*
-* Only keys defined in urlConfig.search are set by site context. Any other query params
-* already present on the `to` URL (including duplicate keys) are preserved as-is.
-* e.g. to='/api/search?refine=color:blue&refine=size:M', search='?lng=:localeId'
-*   → '/api/search?refine=color:blue&refine=size:M&lng=en-GB'
-*
-* @example
-* buildUrl({ to: '/product/123', urlConfig: { prefix: '/:siteId', search: '?lng=:localeId' }, params: { siteId: 'global', localeId: 'en-GB' } })
-* // → '/global/product/123?lng=en-GB'
-*/
-function buildUrl({ to, urlConfig, params }) {
-	if (!urlConfig) return to;
-	if (!to || to === "#" || to.startsWith("http") || to.startsWith("//")) return to;
-	const { pathname, search: existingSearch, hash } = decomposeUrl(to);
-	const pathPrefix = urlConfig.prefix && urlConfig.prefix !== "/" ? resolvePrefix(urlConfig.prefix, params) : "";
-	const path = pathPrefix ? `${pathPrefix}${sanitizePrefix(pathname, pathPrefix)}` : pathname;
-	const searchParams = new URLSearchParams(existingSearch);
-	if (urlConfig.search) {
-		const searchConfig = parseSearchConfig(urlConfig.search);
-		for (const [queryKey, value] of Object.entries(searchConfig)) if (value.startsWith(":")) {
-			const paramValue = params[value.slice(1)];
-			if (paramValue) searchParams.set(queryKey, paramValue);
-		} else searchParams.set(queryKey, value);
-	}
-	const search = searchParams.toString();
-	return `${path}${search ? `?${search}` : ""}${hash}`;
-}
-
-//#endregion
-//#region src/site-context/utils.ts
-/**
-* Extract a string value from the URL path segment at the given index.
-*/
-function lookupFromPath(pathname, pathIndex) {
-	const pathSegments = pathname.split("/").filter(Boolean);
-	if (pathSegments.length <= pathIndex) return null;
-	return pathSegments[pathIndex];
-}
-/**
-* Detect a string value from cookie using the given cookie parser.
-*
-* Returns a promise that resolves to the cookie value.
-*/
-async function readCookieFromRequest(request, cookie) {
-	const cookies = request.headers.get("Cookie");
-	if (!cookies) return null;
-	return await cookie.parse(cookies);
-}
-
-//#endregion
-//#region src/site-context/site-detection.ts
-/**
-* Detect site reference from cookie.
-*/
-async function readSiteFromCookie(request, cookie) {
-	return readCookieFromRequest(request, cookie);
-}
-/**
-* Get site object using the site id or alias
-* 1. Check siteIdentifier against each site's alias; if matched, return that site.
-* 2. Else check against each site's id; if matched, return that site.
-* 3. If no match, return null.
-*/
-function getSiteFromIdOrAlias(siteIdentifier, sites) {
-	if (!siteIdentifier) return null;
-	return sites.find((site) => site.alias === siteIdentifier || site.id === siteIdentifier) ?? null;
-}
-/**
-* Resolve site using the configured detection order.
-* Returns the first valid site from the first source that yields a valid value.
-*/
-async function resolveSite(request, settings) {
-	const { sites, defaultSiteId, siteDetectionConfig, siteCookie } = settings;
-	const requestUrl = new URL(request.url);
-	const basePathOffset = process.env.MRT_ENV_BASE_PATH ? process.env.MRT_ENV_BASE_PATH.split("/").filter(Boolean).length : 0;
-	const resolvers = {
-		path: () => Promise.resolve(lookupFromPath(requestUrl.pathname, siteDetectionConfig.lookupFromPathIndex + basePathOffset)),
-		querystring: () => Promise.resolve(requestUrl.searchParams.get(siteDetectionConfig.lookupQuerystring)),
-		header: () => Promise.resolve(request.headers.get(siteDetectionConfig.lookupHeader)),
-		cookie: async () => readSiteFromCookie(request, siteCookie)
-	};
-	for (const method of siteDetectionConfig.order) {
-		const resolvedSite = getSiteFromIdOrAlias(await resolvers[method]?.(), sites);
-		if (resolvedSite) return resolvedSite;
-	}
-	const site = getSiteFromIdOrAlias(defaultSiteId, sites);
-	if (!site) throw new Error(`Default site ${defaultSiteId} not found.`);
-	return site;
-}
-
-//#endregion
-//#region src/site-context/configs.ts
-/**
-* Default site detection configuration
-*/
-const DEFAULT_SITE_DETECTION = {
-	order: [
-		"path",
-		"querystring",
-		"cookie",
-		"header"
-	],
-	lookupFromPathIndex: 0,
-	lookupQuerystring: "site",
-	lookupCookie: "site_id",
-	lookupHeader: "X-Site-Id",
-	caches: ["cookie"]
-};
-/**
-* Default locale detection configuration
-*/
-const DEFAULT_LOCALE_DETECTION = {
-	order: [
-		"path",
-		"querystring",
-		"cookie",
-		"header"
-	],
-	lookupFromPathIndex: 1,
-	lookupQuerystring: "lng",
-	lookupCookie: "lng",
-	lookupHeader: "Accept-Language",
-	caches: ["cookie"]
-};
-
-//#endregion
-//#region src/site-context/cookies.ts
-/**
-* Cookie options for site context cookies
-*/
-const COOKIE_OPTIONS = {
-	path: "/",
-	sameSite: "lax",
-	secure: process.env.NODE_ENV === "production",
-	httpOnly: true
-};
-/**
-* Creates a cookie instance with the given name.
-*
-* @param name - Cookie name
-* @returns Cookie instance configured with site context options
-*/
-function createSiteContextCookie(name) {
-	return createCookie(name, COOKIE_OPTIONS);
-}
-/**
-* WeakMap to pass resolved locale from site context middleware to i18next's findLocale.
-* WeakMap allows garbage collection when requests are done.
-* This is necessary because findLocale() only receives the Request object, not the router context.
-*/
-const requestToLocaleMap = /* @__PURE__ */ new WeakMap();
-
-//#endregion
-//#region src/site-context/locale-detection.ts
-/**
-* Read locale from cookie.
-*/
-async function readLocaleFromCookie(request, cookie) {
-	return readCookieFromRequest(request, cookie);
-}
-/**
-* Get locale object using the locale id or alias.
-* 1. Check localeIdOrAlias against each locale's alias; if matched, return that locale.
-* 2. Else check against each locale's id; if matched, return that locale.
-* 3. If no match, return null (caller should use defaultLocale).
-*
-* @param localeIdentifier - The locale id or alias to get the locale from. Null is allowed because this may come from
-* extrenal sources such as cookies, headers, or query parameters.
-* @param locales - The list of locales to search through.
-* @returns The locale object if found, otherwise null.
-*/
-function getLocaleFromIdOrAlias(localeIdentifier, locales) {
-	if (!localeIdentifier) return null;
-	return locales.find((locale) => locale.alias === localeIdentifier || locale.id === localeIdentifier) ?? null;
-}
-/**
-* Resolve locale using the configured detection order.
-* Returns the first valid locale from the first source that yields a valid value.
-*/
-async function resolveLocale(request, settings, site) {
-	const { defaultLocale, localeDetectionConfig, localeCookie } = settings;
-	const { supportedLocales } = site;
-	let locale = null;
-	const requestUrl = new URL(request.url);
-	const basePathOffset = process.env.MRT_ENV_BASE_PATH ? process.env.MRT_ENV_BASE_PATH.split("/").filter(Boolean).length : 0;
-	const resolvers = {
-		path: () => Promise.resolve(lookupFromPath(requestUrl.pathname, localeDetectionConfig.lookupFromPathIndex + basePathOffset)),
-		querystring: () => Promise.resolve(requestUrl.searchParams.get(localeDetectionConfig.lookupQuerystring)),
-		header: () => Promise.resolve(request.headers.get(localeDetectionConfig.lookupHeader)),
-		cookie: async () => readLocaleFromCookie(request, localeCookie)
-	};
-	for (const method of localeDetectionConfig.order) {
-		const resolvedLocale = getLocaleFromIdOrAlias(await resolvers[method]?.(), supportedLocales);
-		if (resolvedLocale) return resolvedLocale;
-	}
-	if (!locale) locale = getLocaleFromIdOrAlias(defaultLocale, supportedLocales);
-	if (!locale) throw new Error(`Default locale ${defaultLocale} not found in the list of supported locales for site ${site.id}.`);
-	return locale;
-}
-
-//#endregion
-//#region src/site-context/middleware.ts
-const siteContext = createContext$1(null);
-/**
-* Helper function to get site context cookies from router context.
-* Useful in server actions and loaders that need to read/set cookies.
-*
-* @param context - Router context provider
-* @returns Object with siteCookie and localeCookie instances, or null if context not set
-*
-* @example
-* ```typescript
-* export const action: ActionFunction = async ({ request, context }) => {
-*     const cookies = getSiteContextCookies(context);
-*     if (cookies) {
-*         const cookieHeader = await cookies.localeCookie.serialize(locale);
-*         // ... use cookieHeader
-*     }
-* };
-* ```
-*/
-function getSiteContextCookies(context) {
-	const siteCtx = context.get(siteContext);
-	if (!siteCtx) return null;
-	return {
-		siteCookie: siteCtx.siteCookie,
-		localeCookie: siteCtx.localeCookie
-	};
-}
-/**
-* Helper function to determine if cookies should be set based on:
-* 1. Whether caching is enabled for each cookie type
-* 2. Whether the resolved value differs from the existing cookie
-* 3. Whether cookies were already set by actions/loaders in the response
-*
-* @param request - Incoming request
-* @param response - Response from next()
-* @param settings - Site context settings with cookie instances and detection config
-* @param site - Resolved site for this request
-* @param locale - Resolved locale for this request
-* @returns Object with shouldSetSiteCookie and shouldSetLocaleCookie booleans
-*/
-async function shouldSetCookies(request, response, settings, site, locale) {
-	const cacheSite = settings.siteDetectionConfig.caches?.includes("cookie");
-	const cacheLocale = settings.localeDetectionConfig.caches?.includes("cookie");
-	if (!cacheSite && !cacheLocale) return {
-		shouldSetSiteCookie: false,
-		shouldSetLocaleCookie: false
-	};
-	const responseSetCookies = response.headers.getSetCookie?.() || [];
-	const isSettingSiteCookieInResponse = responseSetCookies.some((cookie) => cookie.startsWith(`${settings.siteCookie.name}=`));
-	const isSettingLocaleCookieInResponse = responseSetCookies.some((cookie) => cookie.startsWith(`${settings.localeCookie.name}=`));
-	const requestCookieHeader = request.headers.get("Cookie");
-	const [existingSiteCookie, existingLocaleCookie] = await Promise.all([settings.siteCookie.parse(requestCookieHeader), settings.localeCookie.parse(requestCookieHeader)]);
-	return {
-		shouldSetSiteCookie: cacheSite && !isSettingSiteCookieInResponse && existingSiteCookie !== site.id,
-		shouldSetLocaleCookie: cacheLocale && !isSettingLocaleCookieInResponse && existingLocaleCookie !== locale.id
-	};
-}
-/**
-* Creates a site context middleware that resolves the current site from
-* the request (path, cookie, header, query, or default) and stores the
-* result in the router context.
-*
-* Does not import or read from app config context; the consumer supplies config.
-*/
-function createSiteContextMiddleware(config) {
-	const siteDetectionConfig = {
-		...DEFAULT_SITE_DETECTION,
-		...config.siteDetectionConfig
-	};
-	const localeDetectionConfig = {
-		...DEFAULT_LOCALE_DETECTION,
-		...config.localeDetectionConfig
-	};
-	const siteCookie = createSiteContextCookie(siteDetectionConfig.lookupCookie);
-	const localeCookie = createSiteContextCookie(localeDetectionConfig.lookupCookie);
-	const settings = {
-		...config,
-		siteDetectionConfig,
-		localeDetectionConfig,
-		siteCookie,
-		localeCookie
-	};
-	const siteContextMiddleware = async ({ request, context }, next) => {
-		const site = await resolveSite(request, settings);
-		const locale = await resolveLocale(request, settings, site);
-		context.set(siteContext, {
-			site,
-			locale,
-			siteCookie: settings.siteCookie,
-			localeCookie: settings.localeCookie
-		});
-		requestToLocaleMap.set(request, locale.id);
-		const response = await next();
-		const { shouldSetSiteCookie, shouldSetLocaleCookie } = await shouldSetCookies(request, response, settings, site, locale);
-		if (!shouldSetSiteCookie && !shouldSetLocaleCookie) return response;
-		const [siteSetCookie, localeSetCookie] = await Promise.all([shouldSetSiteCookie ? settings.siteCookie.serialize(site.id, { path: "/" }) : Promise.resolve(null), shouldSetLocaleCookie ? settings.localeCookie.serialize(locale.id, { path: "/" }) : Promise.resolve(null)]);
-		if (siteSetCookie) response.headers.append("Set-Cookie", siteSetCookie);
-		if (localeSetCookie) response.headers.append("Set-Cookie", localeSetCookie);
-		return response;
-	};
-	return siteContextMiddleware;
-}
-
-//#endregion
-export { SiteProvider, applyUrlConfig, buildUrl, createSiteContextMiddleware, getSiteContextCookies, requestToLocaleMap, resolvePrefix, sanitizePrefix, siteContext, stripPathPrefix, useSite };
-//# sourceMappingURL=site-context.js.map
+export { SiteProvider, applyUrlConfig, buildUrl, createSiteContextMiddleware, getSiteContextCookies, requestToLocaleMap, resolvePrefix, resolveSiteContext, sanitizePrefix, siteContext, stripPathPrefix, useSite };