intor 2.4.17 → 2.5.1

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

@@ -1,4 +1,3 @@
-import '../../../core/error/intor-error.js';
 import { parseCookieHeader } from '../../../core/utils/parse-cookie-header.js';
 import { normalizeQuery } from '../../../core/utils/normalizers/normalize-query.js';
 import 'logry';
@@ -7,23 +6,28 @@ import 'intor-translator';
 import { getLocaleFromAcceptLanguage } from '../../locale/get-locale-from-accept-language.js';
 import { resolveInbound } from '../resolve-inbound.js';
 
-async 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);
-    return resolveInbound(config, url.pathname, {
-        host: url.hostname,
-        query: normalizedQuery,
-        cookie: cookieLocale,
-        detected: localeFromAcceptLanguage || config.defaultLocale,
-    });
+function resolveInboundFromRequest(config, request) {
+  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

@@ -2,44 +2,31 @@ import { getLocaleFromPathname } from '../locale/get-locale-from-pathname.js';
 import { getLocaleFromHost } from '../locale/get-locale-from-host.js';
 import { getLocaleFromQuery } from '../locale/get-locale-from-query.js';
 import { resolveLocale } from './resolve-locale/resolve-locale.js';
-import { resolvePath } from './resolve-path/resolve-path.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.
- */
-async 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 { locale, localeSource } = resolveLocale(config, {
-        path: { locale: pathLocale },
-        host: { locale: getLocaleFromHost(host) },
-        query: { locale: getLocaleFromQuery(query, queryKey) },
-        cookie: { locale: cookie },
-        detected: { locale: detected },
-    });
-    // ------------------------------------------------------
-    // Resolve localized pathname and redirect requirement
-    // ------------------------------------------------------
-    const { pathname, shouldRedirect } = resolvePath(config, rawPathname, {
-        locale,
-        hasPathLocale: !!pathLocale,
-        hasPersisted: !!cookie});
-    return {
-        locale,
-        localeSource,
-        pathname,
-        shouldRedirect,
-    };
+function resolveInbound(config, rawPathname, localeInputs, options) {
+  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

@@ -1,35 +1,33 @@
-import '../../../core/error/intor-error.js';
 import { matchLocale } from '../../../core/locale/match-locale.js';
 import 'logry';
 import 'p-limit';
 import 'intor-translator';
 
-/**
- * Resolve the active locale from inbound routing configuration.
- *
- * Iterates through configured locale sources and returns the first normalized, supported locale.
- *
- * Falls back to the detected locale or the default locale if none match.
- */
 function resolveLocale(config, context) {
-    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: normalized,
-            localeSource: source,
-        };
-    }
-    // Fallback: detected is always available
-    const fallback = matchLocale(context.detected.locale, config.supportedLocales) ||
-        config.defaultLocale;
+  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: fallback,
-        localeSource: "detected",
+      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

@@ -0,0 +1,36 @@
+import { localizePathname } from '../../pathname/localize-pathname.js';
+import { all } from './strategies/all.js';
+import { exceptDefault } from './strategies/except-default.js';
+import { none } from './strategies/none.js';
+
+const assertNever = (x) => {
+  throw new Error(`Unhandled prefix strategy: ${String(x)}`);
+};
+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 { 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

@@ -0,0 +1,15 @@
+function all(config, context) {
+  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

@@ -0,0 +1,16 @@
+function exceptDefault(config, context) {
+  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

@@ -0,0 +1,5 @@
+function none() {
+  return { type: "pass" };
+}
+
+export { none };

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

@@ -1,38 +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 [rawLang, rawQ] = part.split(";");
-        const lang = rawLang.trim();
-        const q = rawQ ? 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.toSorted((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

@@ -1,47 +1,20 @@
-import '../../core/error/intor-error.js';
 import { normalizePathname } from '../../core/utils/normalizers/normalize-pathname.js';
 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

@@ -1,47 +1,36 @@
 import { LOCALE_PLACEHOLDER } from '../../core/constants/locale-placeholder.js';
-import '../../core/error/intor-error.js';
 import { normalizePathname } from '../../core/utils/normalizers/normalize-pathname.js';
 import 'logry';
 import 'p-limit';
 import 'intor-translator';
 
-/**
- * Returns a canonical, locale-agnostic pathname.
- *
- * Accepts `{locale}` as a locale placeholder segment.
- *
- * @example
- * ```ts
- * // config.supportedLocales: ["en-US"]
- * // config.routing.basePath: "/app"
- * // config.routing.prefix: "all"
- * canonicalizePathname("/app/en-US/about", config);
- * // => "/about"
- *```
- */
 function canonicalizePathname(rawPathname, config) {
-    const { routing, supportedLocales } = config;
-    const { basePath } = routing;
-    const normalizedPathname = normalizePathname(rawPathname);
-    // Strip basePath
-    let prefixedPathname = normalizedPathname;
-    if (basePath && normalizedPathname === basePath) {
-        prefixedPathname = "/";
+  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);
     }
-    else if (basePath && normalizedPathname.startsWith(basePath + "/")) {
-        prefixedPathname = normalizedPathname.slice(basePath.length);
-    }
-    // Detect locale segment
-    const firstSegment = prefixedPathname.split("/").find(Boolean);
-    const locale = firstSegment === LOCALE_PLACEHOLDER
-        ? LOCALE_PLACEHOLDER
-        : firstSegment && supportedLocales.includes(firstSegment)
-            ? firstSegment
-            : undefined;
-    // Strip locale segment
-    return locale
-        ? prefixedPathname.slice(locale.length + 1) || "/"
-        : prefixedPathname;
+  }
+  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 };

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

@@ -2,35 +2,19 @@ import { canonicalizePathname } from './canonicalize-pathname.js';
 import { materializePathname } from './materialize-pathname.js';
 import { standardizePathname } from './standardize-pathname.js';
 
-/**
- * Localizes a pathname by composing canonicalization,
- * standardization, and locale prefix strategies.
- *
- * @example
- * ```ts
- * // config.supportedLocales: ["en-US"]
- * // config.routing.basePath: "/app"
- * // config.routing.prefix: "all"
- * localizePathname("/app/en-US/about", config, "en-US");
- * // => {
- * //   pathname: '/app/en-US/about'
- * //   unprefixedPathname: '/about',
- * //   templatedPathname: '/app/{locale}/about',
- * // }
- * ```
- */
 const localizePathname = (rawPathname, config, locale) => {
-    // 1. Canonicalize: normalize and remove routing-specific prefixes
-    const canonicalized = canonicalizePathname(rawPathname, config);
-    // 2. Standardize: convert to internal pathname shape with locale placeholder
-    const standardized = standardizePathname(canonicalized, config);
-    // 3. Materialize: apply routing rules to produce the final pathname
-    const materialized = materializePathname(standardized, config, locale);
-    return {
-        pathname: materialized,
-        unprefixedPathname: canonicalized,
-        templatedPathname: standardized,
-    };
+  const canonicalPathname = canonicalizePathname(rawPathname, config);
+  const standardizedPathname = standardizePathname(canonicalPathname, config);
+  const materializedPathname = materializePathname(
+    standardizedPathname,
+    config,
+    locale
+  );
+  return {
+    canonicalPathname,
+    templatedPathname: standardizedPathname,
+    pathname: materializedPathname
+  };
 };
 
 export { localizePathname };

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

@@ -1,42 +1,18 @@
 import { LOCALE_PLACEHOLDER } from '../../core/constants/locale-placeholder.js';
-import '../../core/error/intor-error.js';
-import { normalizePathname } from '../../core/utils/normalizers/normalize-pathname.js';
 import 'logry';
 import 'p-limit';
 import 'intor-translator';
 
-/**
- * Materializes a standardized pathname by applying
- * the configured locale prefix behavior.
- *
- * @example
- * ```ts
- * // config.routing.localePrefix: "all"
- * materializePathname("/app/{locale}/about", config, "en-US");
- * // => /app/en-US/about
- *
- * // config.routing.localePrefix: "none"
- * materializePathname("/app/{locale}/about", config, "en-US");
- * // => /app/about
- * ```
- */
 const materializePathname = (standardizedPathname, config, locale) => {
-    const { localePrefix } = config.routing;
-    if (localePrefix !== "none" && !locale) {
-        throw new Error('No locale when using localePrefix "all", "except-default"');
-    }
-    // localePrefix: "all"
-    if (localePrefix === "all") {
-        return normalizePathname(standardizedPathname.replaceAll(LOCALE_PLACEHOLDER, locale));
-    }
-    // localePrefix: "except-default"
-    if (localePrefix === "except-default") {
-        return locale === config.defaultLocale
-            ? normalizePathname(standardizedPathname.replaceAll(`/${LOCALE_PLACEHOLDER}`, ""))
-            : normalizePathname(standardizedPathname.replaceAll(LOCALE_PLACEHOLDER, locale));
-    }
-    // localePrefix: "none"
-    return normalizePathname(standardizedPathname.replaceAll(`/${LOCALE_PLACEHOLDER}`, ""));
+  const { localePrefix } = config.routing;
+  const removeLocale = () => {
+    const result = standardizedPathname.replace(`/${LOCALE_PLACEHOLDER}`, "");
+    return result === "" ? "/" : result;
+  };
+  const injectLocale = () => standardizedPathname.replace(LOCALE_PLACEHOLDER, locale);
+  if (localePrefix === "none") return removeLocale();
+  if (localePrefix === "all") return injectLocale();
+  return locale === config.defaultLocale ? removeLocale() : injectLocale();
 };
 
 export { materializePathname };