intor 2.5.0 → 2.6.0

package/dist/core/src/routing/inbound/helpers/resolve-inbound-from-request.js

@@ -6,35 +6,28 @@ import 'intor-translator';
 import { getLocaleFromAcceptLanguage } from '../../locale/get-locale-from-accept-language.js';
 import { resolveInbound } from '../resolve-inbound.js';
 
-/**
- * Resolves inbound routing state from a Web standard `Request`.
- *
- * @public
- */
 function resolveInboundFromRequest(config, request) {
-    const url = new URL(request.url);
-    const headers = request.headers;
-    // Cookie
-    const cookies = parseCookieHeader(headers.get("cookie") ?? undefined);
-    const cookieLocale = cookies[config.cookie.name];
-    // Query
-    const normalizedQuery = normalizeQuery(Object.fromEntries(url.searchParams));
-    // Accept-Language
-    const acceptLanguage = headers.get("accept-language") ?? undefined;
-    const localeFromAcceptLanguage = getLocaleFromAcceptLanguage(acceptLanguage, config.supportedLocales);
-    const inbounResult = resolveInbound(config, url.pathname, {
-        host: url.hostname,
-        query: normalizedQuery,
-        ...(cookieLocale !== undefined ? { cookie: cookieLocale } : {}),
-        ...(localeFromAcceptLanguage !== undefined
-            ? { detected: localeFromAcceptLanguage }
-            : {}),
-    });
-    return {
-        locale: inbounResult.locale,
-        localeSource: inbounResult.localeSource,
-        pathname: inbounResult.pathname,
-    };
+  const url = new URL(request.url);
+  const headers = request.headers;
+  const cookies = parseCookieHeader(headers.get("cookie") ?? void 0);
+  const cookieLocale = cookies[config.cookie.name];
+  const normalizedQuery = normalizeQuery(Object.fromEntries(url.searchParams));
+  const acceptLanguage = headers.get("accept-language") ?? void 0;
+  const localeFromAcceptLanguage = getLocaleFromAcceptLanguage(
+    acceptLanguage,
+    config.supportedLocales
+  );
+  const inbounResult = resolveInbound(config, url.pathname, {
+    host: url.hostname,
+    query: normalizedQuery,
+    ...cookieLocale !== void 0 ? { cookie: cookieLocale } : {},
+    ...localeFromAcceptLanguage !== void 0 ? { detected: localeFromAcceptLanguage } : {}
+  });
+  return {
+    locale: inbounResult.locale,
+    localeSource: inbounResult.localeSource,
+    pathname: inbounResult.pathname
+  };
 }
 
 export { resolveInboundFromRequest };

package/dist/core/src/routing/inbound/resolve-inbound.js

@@ -4,44 +4,29 @@ import { getLocaleFromQuery } from '../locale/get-locale-from-query.js';
 import { resolveLocale } from './resolve-locale/resolve-locale.js';
 import { resolvePathname } from './resolve-pathname/resolve-pathname.js';
 
-/**
- * Resolves inbound routing state.
- *
- * - Resolves the effective locale from inbound inputs
- * - Localizes the pathname based on the resolved locale
- * - Indicates whether a redirect is required
- *
- * No side effects. No navigation.
- */
 function resolveInbound(config, rawPathname, localeInputs, options) {
-    const { queryKey } = config.routing.inbound;
-    const { host, query, cookie, detected } = localeInputs;
-    // ------------------------------------------------------
-    // Resolve locale from inbound inputs
-    // ------------------------------------------------------
-    const pathLocale = getLocaleFromPathname(rawPathname, config);
-    const hostLocale = getLocaleFromHost(host);
-    const queryLocale = getLocaleFromQuery(query, queryKey);
-    const { locale, localeSource } = resolveLocale(config, {
-        ...(pathLocale !== undefined && { path: { locale: pathLocale } }),
-        ...(hostLocale !== undefined && { host: { locale: hostLocale } }),
-        ...(queryLocale !== undefined && { query: { locale: queryLocale } }),
-        ...(cookie !== undefined && { cookie: { locale: cookie } }),
-        ...(detected !== undefined && { detected: { locale: detected } }),
-    });
-    // ------------------------------------------------------
-    // Resolve localized pathname and redirect requirement
-    // ------------------------------------------------------
-    const { pathname, shouldRedirect } = resolvePathname(config, rawPathname, {
-        locale,
-        hasPathLocale: !!pathLocale,
-        hasPersisted: !!cookie});
-    return {
-        locale,
-        localeSource,
-        pathname,
-        shouldRedirect,
-    };
+  const { queryKey } = config.routing.inbound;
+  const { host, query, cookie, detected } = localeInputs;
+  const pathLocale = getLocaleFromPathname(rawPathname, config);
+  const hostLocale = getLocaleFromHost(host);
+  const queryLocale = getLocaleFromQuery(query, queryKey);
+  const { locale, localeSource } = resolveLocale(config, {
+    ...pathLocale !== void 0 && { path: { locale: pathLocale } },
+    ...hostLocale !== void 0 && { host: { locale: hostLocale } },
+    ...queryLocale !== void 0 && { query: { locale: queryLocale } },
+    ...cookie !== void 0 && { cookie: { locale: cookie } },
+    ...detected !== void 0 && { detected: { locale: detected } }
+  });
+  const { pathname, shouldRedirect } = resolvePathname(config, rawPathname, {
+    locale,
+    hasPathLocale: !!pathLocale,
+    hasPersisted: !!cookie});
+  return {
+    locale,
+    localeSource,
+    pathname,
+    shouldRedirect
+  };
 }
 
 export { resolveInbound };

package/dist/core/src/routing/inbound/resolve-locale/resolve-locale.js

@@ -3,48 +3,31 @@ import 'logry';
 import 'p-limit';
 import 'intor-translator';
 
-/**
- * Resolves the active locale from inbound routing configuration.
- *
- * Resolution order:
- * 1. Configured locale signals (path / query / host / cookie)
- * 2. Runtime detection signal ("detected")
- * 3. Invariant fallback ("default")
- *
- * Always returns a supported locale.
- */
 function resolveLocale(config, context) {
-    const { localeSources } = config.routing.inbound;
-    // ------------------------------------------------------
-    // 1. Configured resolution signals (policy-ordered)
-    // ------------------------------------------------------
-    for (const source of localeSources) {
-        const locale = context[source]?.locale;
-        const normalized = matchLocale(locale, config.supportedLocales);
-        if (!normalized)
-            continue;
-        return {
-            locale: normalized,
-            localeSource: source,
-        };
-    }
-    // ------------------------------------------------------
-    // 2. Detection fallback (runtime signal)
-    // ------------------------------------------------------
-    const detected = matchLocale(context.detected?.locale, config.supportedLocales);
-    if (detected) {
-        return {
-            locale: detected,
-            localeSource: "detected",
-        };
-    }
-    // ------------------------------------------------------
-    // 3. Final invariant fallback (guaranteed)
-    // ------------------------------------------------------
+  const { localeSources } = config.routing.inbound;
+  for (const source of localeSources) {
+    const locale = context[source]?.locale;
+    const normalized = matchLocale(locale, config.supportedLocales);
+    if (!normalized) continue;
     return {
-        locale: config.defaultLocale,
-        localeSource: "default",
+      locale: normalized,
+      localeSource: source
     };
+  }
+  const detected = matchLocale(
+    context.detected?.locale,
+    config.supportedLocales
+  );
+  if (detected) {
+    return {
+      locale: detected,
+      localeSource: "detected"
+    };
+  }
+  return {
+    locale: config.defaultLocale,
+    localeSource: "default"
+  };
 }
 
 export { resolveLocale };

package/dist/core/src/routing/inbound/resolve-pathname/resolve-pathname.js

@@ -4,39 +4,33 @@ import { exceptDefault } from './strategies/except-default.js';
 import { none } from './strategies/none.js';
 
 const assertNever = (x) => {
-    throw new Error(`Unhandled prefix strategy: ${String(x)}`);
+  throw new Error(`Unhandled prefix strategy: ${String(x)}`);
 };
-/**
- * Resolves the canonical pathname based on locale prefix behavior.
- *
- * The resolved pathname represents the final, normalized form
- * used for routing and navigation.
- */
 const resolvePathname = (config, rawPathname, context) => {
-    const { localePrefix } = config.routing;
-    let directive;
-    switch (localePrefix) {
-        case "all": {
-            directive = all(config, context);
-            break;
-        }
-        case "except-default": {
-            directive = exceptDefault(config, context);
-            break;
-        }
-        case "none": {
-            directive = none();
-            break;
-        }
-        default: {
-            return assertNever(localePrefix);
-        }
+  const { localePrefix } = config.routing;
+  let directive;
+  switch (localePrefix) {
+    case "all": {
+      directive = all(config, context);
+      break;
     }
-    const { pathname } = localizePathname(rawPathname, config, context.locale);
-    return {
-        pathname,
-        shouldRedirect: directive.type === "redirect",
-    };
+    case "except-default": {
+      directive = exceptDefault(config, context);
+      break;
+    }
+    case "none": {
+      directive = none();
+      break;
+    }
+    default: {
+      return assertNever(localePrefix);
+    }
+  }
+  const { pathname } = localizePathname(rawPathname, config, context.locale);
+  return {
+    pathname,
+    shouldRedirect: directive.type === "redirect"
+  };
 };
 
 export { resolvePathname };

package/dist/core/src/routing/inbound/resolve-pathname/strategies/all.js

@@ -1,28 +1,15 @@
-/**
- * Resolve pathname decision for routing prefix strategy: "all".
- */
 function all(config, context) {
-    const { hasPathLocale, hasPersisted} = context;
-    const { redirect } = config.routing.inbound.firstVisit;
-    const isFirstVisit = !hasPersisted;
-    // ----------------------------------------------------------
-    // URL already canonical
-    // ----------------------------------------------------------
-    if (hasPathLocale) {
-        return { type: "pass" };
-    }
-    // ----------------------------------------------------------
-    // Apply first-visit redirect policy
-    // ----------------------------------------------------------
-    if (isFirstVisit) {
-        if (!redirect)
-            return { type: "pass" };
-        return { type: "redirect" };
-    }
-    // ----------------------------------------------------------
-    // Redirect to the locale-prefixed URL
-    // ----------------------------------------------------------
+  const { hasPathLocale, hasPersisted} = context;
+  const { redirect } = config.routing.inbound.firstVisit;
+  const isFirstVisit = !hasPersisted;
+  if (hasPathLocale) {
+    return { type: "pass" };
+  }
+  if (isFirstVisit) {
+    if (!redirect) return { type: "pass" };
     return { type: "redirect" };
+  }
+  return { type: "redirect" };
 }
 
 export { all };

package/dist/core/src/routing/inbound/resolve-pathname/strategies/except-default.js

@@ -1,29 +1,16 @@
-/**
- * Resolve pathname decision for routing prefix strategy: "except-default".
- */
 function exceptDefault(config, context) {
-    const { hasPathLocale, hasPersisted} = context;
-    const { redirect } = config.routing.inbound.firstVisit;
-    const isFirstVisit = !hasPersisted;
-    const isDefaultLocale = context.locale === config.defaultLocale;
-    // ----------------------------------------------------------
-    // URL already canonical
-    // ----------------------------------------------------------
-    if (hasPathLocale) {
-        return { type: "pass" };
-    }
-    // ----------------------------------------------------------
-    // Apply first-visit redirect policy
-    // ----------------------------------------------------------
-    if (isFirstVisit) {
-        if (!redirect)
-            return { type: "pass" };
-        return isDefaultLocale ? { type: "pass" } : { type: "redirect" };
-    }
-    // ----------------------------------------------------------
-    // Redirect non-default locale to the locale-prefixed URL
-    // ----------------------------------------------------------
+  const { hasPathLocale, hasPersisted} = context;
+  const { redirect } = config.routing.inbound.firstVisit;
+  const isFirstVisit = !hasPersisted;
+  const isDefaultLocale = context.locale === config.defaultLocale;
+  if (hasPathLocale) {
+    return { type: "pass" };
+  }
+  if (isFirstVisit) {
+    if (!redirect) return { type: "pass" };
     return isDefaultLocale ? { type: "pass" } : { type: "redirect" };
+  }
+  return isDefaultLocale ? { type: "pass" } : { type: "redirect" };
 }
 
 export { exceptDefault };

package/dist/core/src/routing/inbound/resolve-pathname/strategies/none.js

@@ -1,8 +1,5 @@
-/**
- * Resolve pathname decision for routing prefix strategy: "none".
- */
 function none() {
-    return { type: "pass" };
+  return { type: "pass" };
 }
 
 export { none };

package/dist/core/src/routing/locale/get-locale-from-accept-language.js

@@ -1,40 +1,25 @@
-/**
- * Get locale candidate from the `Accept-Language` header.
- *
- * Parses language priorities and returns the highest-priority
- * language present in `supportedLocales`, without normalization.
- *
- * @example
- * ```ts
- * getLocaleFromAcceptLanguage("en-US,en;q=0.8,zh-TW;q=0.9", ["en-US", "zh-TW"])
- * // => "en-US"
- *
- * getLocaleFromAcceptLanguage("fr,ja;q=0.9", ["en", "zh-TW"])
- * // => undefined
- * ```
- */
 const getLocaleFromAcceptLanguage = (acceptLanguageHeader, supportedLocales) => {
-    if (!acceptLanguageHeader || supportedLocales.length === 0) {
-        return;
-    }
-    const supportedLocalesSet = new Set(supportedLocales);
-    // 1. Parse Accept-Language header into language + priority pairs
-    const parsedLanguages = acceptLanguageHeader.split(",").map((part) => {
-        const segments = part.split(";");
-        const rawLang = segments[0];
-        const rawQ = segments[1];
-        const lang = rawLang.trim();
-        const q = rawQ !== undefined ? Number.parseFloat(rawQ.split("=")[1] ?? "") : 1;
-        return {
-            lang,
-            q: Number.isNaN(q) ? 0 : q, // Invalid q values have lowest priority
-        };
-    });
-    // 2. Sort by priority (highest first)
-    const sortedByPriority = parsedLanguages.sort((a, b) => b.q - a.q);
-    // 3. Pick the first language explicitly supported
-    const preferred = sortedByPriority.find(({ lang }) => supportedLocalesSet.has(lang))?.lang;
-    return preferred;
+  if (!acceptLanguageHeader || supportedLocales.length === 0) {
+    return;
+  }
+  const supportedLocalesSet = new Set(supportedLocales);
+  const parsedLanguages = acceptLanguageHeader.split(",").map((part) => {
+    const segments = part.split(";");
+    const rawLang = segments[0];
+    const rawQ = segments[1];
+    const lang = rawLang.trim();
+    const q = rawQ !== void 0 ? Number.parseFloat(rawQ.split("=")[1] ?? "") : 1;
+    return {
+      lang,
+      q: Number.isNaN(q) ? 0 : q
+      // Invalid q values have lowest priority
+    };
+  });
+  const sortedByPriority = parsedLanguages.sort((a, b) => b.q - a.q);
+  const preferred = sortedByPriority.find(
+    ({ lang }) => supportedLocalesSet.has(lang)
+  )?.lang;
+  return preferred;
 };
 
 export { getLocaleFromAcceptLanguage };

package/dist/core/src/routing/locale/get-locale-from-host.js

@@ -1,32 +1,9 @@
-/**
- * Get locale candidate from hostname.
- *
- * Returns the left-most hostname label, without validation or normalization.
- *
- * @example
- * ```ts
- * getLocaleFromHost("en.example.com")
- * // => "en"
- *
- * getLocaleFromHost("example.com")
- * // => "example"
- *
- * getLocaleFromHost("api.jp.example.com")
- * // => "api"
- *
- * getLocaleFromHost("localhost")
- * // => undefined
- * ```
- */
 function getLocaleFromHost(host) {
-    if (!host)
-        return;
-    // Remove port (e.g. localhost:3000)
-    const hostname = host.split(":")[0];
-    const parts = hostname.split(".");
-    if (parts.length < 2)
-        return;
-    return parts[0];
+  if (!host) return;
+  const hostname = host.split(":")[0];
+  const parts = hostname.split(".");
+  if (parts.length < 2) return;
+  return parts[0];
 }
 
 export { getLocaleFromHost };

package/dist/core/src/routing/locale/get-locale-from-pathname.js

@@ -3,44 +3,18 @@ import 'logry';
 import 'p-limit';
 import 'intor-translator';
 
-/**
- * Get locale from pathname.
- *
- * Extracts the first pathname segment (after basePath) as a locale
- * if it exactly matches one of the supported locales.
- *
- * @example
- * ```ts
- * getLocaleFromPathname(config, "/en/about")
- * // => "en"
- * getLocaleFromPathname(config, "/zh-TW")
- * // => "zh-TW"
- * getLocaleFromPathname(config, "/about")
- * // => undefined
- *
- * // config.routing.basePath: "/app"
- * getLocaleFromPathname(config, "/app/en/dashboard")
- * // => "en"
- * ```
- */
 function getLocaleFromPathname(pathname, config) {
-    const { routing, supportedLocales } = config;
-    const { basePath } = routing;
-    // 1. Normalize pathname
-    const normalizedPathname = normalizePathname(pathname);
-    // 2. Strip basePath
-    let prefixedPathname = normalizedPathname;
-    if (basePath && normalizedPathname === basePath) {
-        prefixedPathname = "/";
-    }
-    else if (basePath && normalizedPathname.startsWith(basePath + "/")) {
-        prefixedPathname = normalizedPathname.slice(basePath.length);
-    }
-    // 3. Detect locale segment
-    const firstSegment = prefixedPathname.split("/").find(Boolean);
-    return firstSegment && supportedLocales.includes(firstSegment)
-        ? firstSegment
-        : undefined;
+  const { routing, supportedLocales } = config;
+  const { basePath } = routing;
+  const normalizedPathname = normalizePathname(pathname);
+  let prefixedPathname = normalizedPathname;
+  if (basePath && normalizedPathname === basePath) {
+    prefixedPathname = "/";
+  } else if (basePath && normalizedPathname.startsWith(basePath + "/")) {
+    prefixedPathname = normalizedPathname.slice(basePath.length);
+  }
+  const firstSegment = prefixedPathname.split("/").find(Boolean);
+  return firstSegment && supportedLocales.includes(firstSegment) ? firstSegment : void 0;
 }
 
 export { getLocaleFromPathname };

package/dist/core/src/routing/locale/get-locale-from-query.js

@@ -1,21 +1,6 @@
-/**
- * Get locale candidate from URL query parameters.
- *
- * Extracts the value of the configured query key, without
- * validation or normalization.
- *
- * @example
- * ```ts
- * getLocaleFromQuery({ locale: "en" }, "locale")
- * // => "en"
- *
- * getLocaleFromQuery({}, "locale")
- * // => undefined
- */
 function getLocaleFromQuery(query, queryKey) {
-    if (!query)
-        return;
-    return query[queryKey];
+  if (!query) return;
+  return query[queryKey];
 }
 
 export { getLocaleFromQuery };

package/dist/core/src/routing/pathname/canonicalize-pathname.js

@@ -4,75 +4,33 @@ import 'logry';
 import 'p-limit';
 import 'intor-translator';
 
-/**
- * Returns the internal canonical pathname.
- *
- * Canonical representation is the locale-neutral and deployment-neutral
- * internal routing form used for identity and routing computation.
- *
- * Guarantees:
- * - Pathname is normalized
- * - Deployment prefix (`basePath`) is removed
- * - Leading locale segment or `{locale}` placeholder is removed
- * - Only the first path segment is evaluated for locale stripping
- * - Result always starts with "/"
- * - Root is represented as "/"
- *
- * Accepts `{locale}` as a locale placeholder segment.
- *
- * @example
- * ```ts
- * // config.supportedLocales: ["en"]
- * // config.routing.basePath: "/app"
- * // config.routing.prefix: "all"
- * canonicalizePathname("/app/en/about", config);
- * // => "/about"
- *```
- */
 function canonicalizePathname(rawPathname, config) {
-    const { routing, supportedLocales } = config;
-    const normalizedPathname = normalizePathname(rawPathname);
-    // ---------------------------------------------------------------------------
-    // Strip basePath (deployment prefix)
-    // ---------------------------------------------------------------------------
-    const basePath = routing.basePath === "/" ? "" : routing.basePath;
-    let path = normalizedPathname;
-    if (basePath) {
-        if (path === basePath) {
-            path = "/";
-        }
-        else if (path.startsWith(basePath + "/")) {
-            path = path.slice(basePath.length);
-        }
+  const { routing, supportedLocales } = config;
+  const normalizedPathname = normalizePathname(rawPathname);
+  const basePath = routing.basePath === "/" ? "" : routing.basePath;
+  let path = normalizedPathname;
+  if (basePath) {
+    if (path === basePath) {
+      path = "/";
+    } else if (path.startsWith(basePath + "/")) {
+      path = path.slice(basePath.length);
     }
-    // ---------------------------------------------------------------------------
-    // Detect first segment (allocation-minimized)
-    // ---------------------------------------------------------------------------
-    if (path === "/")
-        return "/";
-    const segmentStart = 1; // skip leading "/"
-    const nextSlash = path.indexOf("/", segmentStart);
-    const firstSegment = nextSlash === -1
-        ? path.slice(segmentStart)
-        : path.slice(segmentStart, nextSlash);
-    // ---------------------------------------------------------------------------
-    // Determine if first segment is locale representation
-    // ---------------------------------------------------------------------------
-    let localeLength;
-    if (firstSegment === LOCALE_PLACEHOLDER) {
-        localeLength = firstSegment.length;
-    }
-    else if (supportedLocales.includes(firstSegment)) {
-        localeLength = firstSegment.length;
-    }
-    // ---------------------------------------------------------------------------
-    // Strip locale segment (if any)
-    // ---------------------------------------------------------------------------
-    if (localeLength !== undefined) {
-        const stripped = path.slice(localeLength + 1);
-        return stripped || "/";
-    }
-    return path;
+  }
+  if (path === "/") return "/";
+  const segmentStart = 1;
+  const nextSlash = path.indexOf("/", segmentStart);
+  const firstSegment = nextSlash === -1 ? path.slice(segmentStart) : path.slice(segmentStart, nextSlash);
+  let localeLength;
+  if (firstSegment === LOCALE_PLACEHOLDER) {
+    localeLength = firstSegment.length;
+  } else if (supportedLocales.includes(firstSegment)) {
+    localeLength = firstSegment.length;
+  }
+  if (localeLength !== void 0) {
+    const stripped = path.slice(localeLength + 1);
+    return stripped || "/";
+  }
+  return path;
 }
 
 export { canonicalizePathname };