intor 2.5.0 → 2.6.0

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

@@ -1,34 +1,18 @@
-/**
- * Resolve pathname decision for routing prefix strategy: "all".
- */
 function all(config, context) {
-    const { hasPathLocale, hasPersisted, hasRedirected } = context;
-    const { redirect } = config.routing.inbound.firstVisit;
-    const isFirstVisit = !hasPersisted;
-    // ----------------------------------------------------------
-    // URL already canonical
-    // ----------------------------------------------------------
-    if (hasPathLocale) {
-        return { type: "pass" };
-    }
-    // ----------------------------------------------------------
-    // Prevent infinite redirect in the same navigation flow
-    // ----------------------------------------------------------
-    if (hasRedirected) {
-        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, hasRedirected } = context;
+  const { redirect } = config.routing.inbound.firstVisit;
+  const isFirstVisit = !hasPersisted;
+  if (hasPathLocale) {
+    return { type: "pass" };
+  }
+  if (hasRedirected) {
+    return { type: "pass" };
+  }
+  if (isFirstVisit) {
+    if (!redirect) return { type: "pass" };
     return { type: "redirect" };
+  }
+  return { type: "redirect" };
 }
 
 export { all };

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

@@ -1,35 +1,19 @@
-/**
- * Resolve pathname decision for routing prefix strategy: "except-default".
- */
 function exceptDefault(config, context) {
-    const { hasPathLocale, hasPersisted, hasRedirected } = context;
-    const { redirect } = config.routing.inbound.firstVisit;
-    const isFirstVisit = !hasPersisted;
-    const isDefaultLocale = context.locale === config.defaultLocale;
-    // ----------------------------------------------------------
-    // URL already canonical
-    // ----------------------------------------------------------
-    if (hasPathLocale) {
-        return { type: "pass" };
-    }
-    // ----------------------------------------------------------
-    // Prevent infinite redirect in the same navigation flow
-    // ----------------------------------------------------------
-    if (hasRedirected) {
-        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, hasRedirected } = context;
+  const { redirect } = config.routing.inbound.firstVisit;
+  const isFirstVisit = !hasPersisted;
+  const isDefaultLocale = context.locale === config.defaultLocale;
+  if (hasPathLocale) {
+    return { type: "pass" };
+  }
+  if (hasRedirected) {
+    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/next/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/next/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/next/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/next/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/next/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/next/src/routing/outbound/decide-strategy.js

@@ -1,14 +1,14 @@
 import { shouldFullReload } from '../../policies/shoud-full-reload.js';
 
-/**
- * Decide how a resolved navigation target should be executed.
- */
-function decideStrategy(config, target) {
-    // External destinations are always handled by the browser
-    if (target.isExternal) {
-        return "external";
-    }
-    return shouldFullReload(config) ? "reload" : "client";
+function decideStrategy(config, target, currentLocale) {
+  if (target.isExternal) {
+    return "external";
+  }
+  const isLocaleChange = target.locale !== currentLocale;
+  if (isLocaleChange && shouldFullReload(config)) {
+    return "reload";
+  }
+  return "client";
 }
 
 export { decideStrategy };

package/dist/next/src/routing/outbound/determine-target.js

@@ -4,52 +4,36 @@ import { deriveHostDestination } from './utils/derive-host-destination.js';
 import { deriveQueryDestination } from './utils/derive-query-destination.js';
 import { isExternalDestination } from './utils/is-external-destination.js';
 
-/**
- * Determines the outbound routing target.
- */
 function determineTarget(config, currentLocale, currentPathname, intent) {
-    const { supportedLocales, routing } = config;
-    // ----------------------------------------------------------------
-    // Resolve effective locale
-    // ----------------------------------------------------------------
-    const locale = intent?.locale && supportedLocales.includes(intent?.locale)
-        ? intent?.locale
-        : currentLocale;
-    // ----------------------------------------------------------------
-    // Resolve raw destination and external flag
-    // ----------------------------------------------------------------
-    // Use the unprefixed logical path as the navigation base.
-    // Locale prefixes are applied later by inbound canonicalization.
-    const rawDestination = intent?.destination ?? canonicalizePathname(currentPathname, config);
-    const isExternal = isExternalDestination(rawDestination);
-    // ----------------------------------------------------------------
-    // Project destination by navigation carrier
-    // ----------------------------------------------------------------
-    let destination = rawDestination;
-    if (!isExternal) {
-        switch (routing.outbound.localeCarrier) {
-            case "path": {
-                destination = localizePathname(rawDestination, config, locale).pathname;
-                break;
-            }
-            case "host": {
-                destination = deriveHostDestination(rawDestination, config, locale);
-                break;
-            }
-            case "query": {
-                destination = deriveQueryDestination(rawDestination, config, locale);
-                break;
-            }
-            default: {
-                destination = rawDestination;
-            }
-        }
+  const { supportedLocales, routing } = config;
+  const locale = intent?.locale && supportedLocales.includes(intent?.locale) ? intent?.locale : currentLocale;
+  const rawDestination = intent?.destination ?? canonicalizePathname(currentPathname, config);
+  const isExternal = isExternalDestination(rawDestination);
+  let destination = rawDestination;
+  if (!isExternal) {
+    switch (routing.outbound.localeCarrier) {
+      case "path": {
+        destination = localizePathname(rawDestination, config, locale).pathname;
+        break;
+      }
+      case "host": {
+        destination = deriveHostDestination(rawDestination, config, locale);
+        break;
+      }
+      case "query": {
+        destination = deriveQueryDestination(rawDestination, config, locale);
+        break;
+      }
+      default: {
+        destination = rawDestination;
+      }
     }
-    return {
-        locale,
-        destination,
-        isExternal,
-    };
+  }
+  return {
+    locale,
+    destination,
+    isExternal
+  };
 }
 
 export { determineTarget };

package/dist/next/src/routing/outbound/resolve-outbound.js

@@ -1,23 +1,19 @@
 import { decideStrategy } from './decide-strategy.js';
 import { determineTarget } from './determine-target.js';
 
-/**
- * Resolve an outbound routing attempt into an executable result.
- */
 function resolveOutbound(config, currentLocale, currentPathname, intent) {
-    // --------------------------------------------------
-    // Determine outbound target
-    // --------------------------------------------------
-    const target = determineTarget(config, currentLocale, currentPathname, intent);
-    // --------------------------------------------------
-    // Decide outbound strategy
-    // --------------------------------------------------
-    const strategy = decideStrategy(config, target);
-    return {
-        locale: target.locale,
-        destination: target.destination,
-        kind: strategy,
-    };
+  const target = determineTarget(
+    config,
+    currentLocale,
+    currentPathname,
+    intent
+  );
+  const strategy = decideStrategy(config, target, currentLocale);
+  return {
+    locale: target.locale,
+    destination: target.destination,
+    kind: strategy
+  };
 }
 
 export { resolveOutbound };

package/dist/next/src/routing/outbound/utils/derive-host-destination.js

@@ -1,13 +1,9 @@
-/**
- * Derives a locale-specific destination using host-based navigation.
- */
 const deriveHostDestination = (rawDestination, config, locale) => {
-    const { host } = config.routing.outbound;
-    const resolvedHost = host.map[locale] ?? host.default;
-    if (!resolvedHost)
-        return rawDestination;
-    const url = new URL(rawDestination, "http://localhost");
-    return `${url.protocol}//${resolvedHost}${url.pathname}${url.search}`;
+  const { host } = config.routing.outbound;
+  const resolvedHost = host.map[locale] ?? host.default;
+  if (!resolvedHost) return rawDestination;
+  const url = new URL(rawDestination, "http://localhost");
+  return `${url.protocol}//${resolvedHost}${url.pathname}${url.search}`;
 };
 
 export { deriveHostDestination };

package/dist/next/src/routing/outbound/utils/derive-query-destination.js

@@ -1,11 +1,8 @@
-/**
- *  Derives a locale-specific destination using query-based navigation.
- */
 const deriveQueryDestination = (rawDestination, config, locale) => {
-    const { queryKey } = config.routing.outbound;
-    const url = new URL(rawDestination, "http://localhost");
-    url.searchParams.set(queryKey, locale);
-    return `${url.pathname}${url.search}`;
+  const { queryKey } = config.routing.outbound;
+  const url = new URL(rawDestination, "http://localhost");
+  url.searchParams.set(queryKey, locale);
+  return `${url.pathname}${url.search}`;
 };
 
 export { deriveQueryDestination };

package/dist/next/src/routing/outbound/utils/is-external-destination.js

@@ -1,11 +1,5 @@
-/**
- * Determines whether a navigation target should bypass app routing.
- *
- * Any value with an explicit scheme (e.g. http:, https:, mailto:)
- * is treated as external navigation.
- */
 const isExternalDestination = (destination) => {
-    return /^[a-zA-Z][a-zA-Z\d+\-.]*:/.test(destination);
+  return /^[a-zA-Z][a-zA-Z\d+\-.]*:/.test(destination);
 };
 
 export { isExternalDestination };

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