intor 2.4.17 → 2.5.1

package/dist/express/src/core/locale/match-locale.js

@@ -1,57 +1,35 @@
 import { canonicalizeLocale } from './canonicalize-locale.js';
 import { parseLocale } from './parse-locale.js';
 
-/**
- * Matches a locale candidate against a list of supported locales.
- *
- * Resolution order:
- * 1. Exact canonical match
- * 2. Same language + same script
- * 3. Same language only (only if candidate has no script)
- *
- * Returns `undefined` if no match is found.
- *
- * Notes:
- * - Matching is deterministic and order-sensitive.
- * - Does not perform automatic fallback to default locale.
- * - Does not cross script boundaries.
- */
 function matchLocale(locale, supportedLocales = []) {
-    if (!locale || supportedLocales.length === 0)
-        return;
-    const canonicalCandidate = canonicalizeLocale(locale);
-    if (!canonicalCandidate)
-        return;
-    const candidateParts = parseLocale(canonicalCandidate);
-    const supportedCanonical = supportedLocales.flatMap((original) => {
-        const canonical = canonicalizeLocale(original);
-        if (!canonical)
-            return [];
-        return [{ original, canonical, parts: parseLocale(canonical) }];
-    });
-    // 1. Exact match
-    for (const s of supportedCanonical) {
-        if (s.canonical === canonicalCandidate) {
-            return s.original;
-        }
-    }
-    // 2. Same language + same script
-    if (candidateParts.script) {
-        for (const s of supportedCanonical) {
-            if (s.parts.language === candidateParts.language &&
-                s.parts.script === candidateParts.script) {
-                return s.original;
-            }
-        }
-        return;
+  if (!locale || supportedLocales.length === 0) return;
+  const canonicalCandidate = canonicalizeLocale(locale);
+  if (!canonicalCandidate) return;
+  const candidateParts = parseLocale(canonicalCandidate);
+  const supportedCanonical = supportedLocales.flatMap((original) => {
+    const canonical = canonicalizeLocale(original);
+    if (!canonical) return [];
+    return [{ original, canonical, parts: parseLocale(canonical) }];
+  });
+  for (const s of supportedCanonical) {
+    if (s.canonical === canonicalCandidate) {
+      return s.original;
     }
-    // 3. Same language only
+  }
+  if (candidateParts.script) {
     for (const s of supportedCanonical) {
-        if (s.parts.language === candidateParts.language) {
-            return s.original;
-        }
+      if (s.parts.language === candidateParts.language && s.parts.script === candidateParts.script) {
+        return s.original;
+      }
     }
     return;
+  }
+  for (const s of supportedCanonical) {
+    if (s.parts.language === candidateParts.language) {
+      return s.original;
+    }
+  }
+  return;
 }
 
 export { matchLocale };

package/dist/express/src/core/locale/parse-locale.js

@@ -1,27 +1,17 @@
-/**
- * Parses a canonical locale tag into structural components.
- *
- * - Uses `Intl.Locale` when available.
- * - Falls back to minimal parsing (language only) if unavailable.
- *
- * This function does not validate or match locales.
- */
 function parseLocale(tag) {
-    try {
-        if (typeof Intl !== "undefined" && typeof Intl.Locale === "function") {
-            const locale = new Intl.Locale(tag);
-            return {
-                language: locale.language,
-                script: locale.script,
-                region: locale.region,
-            };
-        }
+  try {
+    if (typeof Intl !== "undefined" && typeof Intl.Locale === "function") {
+      const locale = new Intl.Locale(tag);
+      return {
+        language: locale.language,
+        ...locale.script !== void 0 ? { script: locale.script } : {},
+        ...locale.region !== void 0 ? { region: locale.region } : {}
+      };
     }
-    catch {
-        // fallback below
-    }
-    const parts = tag.split("-");
-    return { language: parts[0].toLowerCase() };
+  } catch {
+  }
+  const parts = tag.split("-");
+  return { language: parts[0].toLowerCase() };
 }
 
 export { parseLocale };

package/dist/express/src/core/utils/normalizers/normalize-pathname.js

@@ -1,43 +1,24 @@
-/**
- * Normalize a raw pathname string to ensure consistent formatting.
- *
- * - Trims leading and trailing whitespace (code points ≤ 32).
- * - Collapses consecutive slashes into a single slash.
- * - Ensures a single leading slash and removes redundant trailing slashes.
- * - Optionally removes the leading slash.
- * - Avoids intermediate array allocations for performance.
- */
-const normalizePathname = (rawPathname, options = {}) => {
-    const length = rawPathname.length;
-    let start = 0;
-    let end = length - 1;
-    // Trim leading whitespace
-    while (start <= end && (rawPathname.codePointAt(start) ?? 0) <= 32)
-        start++;
-    // Trim trailing whitespace
-    while (end >= start && (rawPathname.codePointAt(end) ?? 0) <= 32)
-        end--;
-    if (start > end)
-        return "/"; // Only whitespace
-    let result = "";
-    let hasSlash = false;
-    for (let i = start; i <= end; i++) {
-        const char = rawPathname[i];
-        if (char === "/") {
-            if (!hasSlash) {
-                hasSlash = true;
-            }
-        }
-        else {
-            result += hasSlash || result === "" ? "/" + char : char;
-            hasSlash = false;
-        }
+const normalizePathname = (rawPathname) => {
+  const length = rawPathname.length;
+  let start = 0;
+  let end = length - 1;
+  while (start <= end && rawPathname.codePointAt(start) <= 32) start++;
+  while (end >= start && rawPathname.codePointAt(end) <= 32) end--;
+  if (start > end) return "/";
+  let result = "";
+  let hasSlash = false;
+  for (let i = start; i <= end; i++) {
+    const char = rawPathname[i];
+    if (char === "/") {
+      if (!hasSlash) {
+        hasSlash = true;
+      }
+    } else {
+      result += hasSlash || result === "" ? "/" + char : char;
+      hasSlash = false;
     }
-    // If the result has a leading slash and we want to remove it, do so
-    if (options.removeLeadingSlash && result.startsWith("/")) {
-        result = result.slice(1);
-    }
-    return result || "/";
+  }
+  return result || "/";
 };
 
 export { normalizePathname };

package/dist/express/src/core/utils/normalizers/normalize-query.js

@@ -1,25 +1,11 @@
-/**
- * Normalize a raw query object into a string-only map.
- *
- * This utility is used to sanitize framework-specific query inputs
- * into a stable shape that the routing core
- * can safely consume.
- *
- * Behavior:
- * - Keeps only entries whose values are strings
- * - Ignores arrays, objects, and other non-string values
- * - Does not throw or attempt to coerce values
- *
- * This function is intentionally conservative by design.
- */
 function normalizeQuery(query) {
-    const normalized = {};
-    for (const [key, value] of Object.entries(query)) {
-        if (typeof value === "string") {
-            normalized[key] = value;
-        }
+  const normalized = {};
+  for (const [key, value] of Object.entries(query)) {
+    if (typeof value === "string") {
+      normalized[key] = value;
     }
-    return normalized;
+  }
+  return normalized;
 }
 
 export { normalizeQuery };

package/dist/express/src/core/utils/parse-cookie-header.js

@@ -1,22 +1,15 @@
-/**
- * Parse a raw HTTP Cookie header into a key-value record.
- */
 function parseCookieHeader(cookieHeader) {
-    if (!cookieHeader)
-        return {};
-    const record = {};
-    // Split the Cookie header into individual key-value pairs
-    const pairs = cookieHeader.split(";");
-    for (const pair of pairs) {
-        // Locate the first "=" to separate key and value
-        const index = pair.indexOf("=");
-        if (index === -1)
-            continue;
-        const key = pair.slice(0, index).trim();
-        const value = pair.slice(index + 1).trim();
-        record[key] = decodeURIComponent(value);
-    }
-    return record;
+  if (!cookieHeader) return {};
+  const record = {};
+  const pairs = cookieHeader.split(";");
+  for (const pair of pairs) {
+    const index = pair.indexOf("=");
+    if (index === -1) continue;
+    const key = pair.slice(0, index).trim();
+    const value = pair.slice(index + 1).trim();
+    record[key] = decodeURIComponent(value);
+  }
+  return record;
 }
 
 export { parseCookieHeader };

package/dist/express/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/express/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/express/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/express/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/express/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/express/src/routing/inbound/resolve-pathname/strategies/none.js

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

package/dist/express/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/express/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/express/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/express/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 };