intor 2.4.17 → 2.5.1

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

package/dist/hono/src/routing/pathname/standardize-pathname.js

@@ -1,34 +1,15 @@
 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';
 
-/**
- * Standardizes a canonical pathname into an internal routing template
- * by applying the base path and injecting a locale placeholder.
- *
- * @example
- * ```ts
- * // config.routing.basePath: "/app",
- * // config.routing.prefix: "all"
- * standardizePathname("/about", config);
- * // => "/app/{locale}/about"
- * ```
- */
-const standardizePathname = (canonicalizedPathname, config) => {
-    const { basePath } = config.routing;
-    // Normalize each segment before join to avoid redundant slashes
-    const parts = [
-        normalizePathname(basePath),
-        LOCALE_PLACEHOLDER,
-        normalizePathname(canonicalizedPathname),
-    ];
-    // Avoid double slashes between segments
-    const standardizedPathname = parts.join("/").replaceAll(/\/{2,}/g, "/");
-    // Final normalization to ensure leading slash, no trailing
-    return normalizePathname(standardizedPathname);
+const standardizePathname = (canonicalPathname, config) => {
+  const { routing } = config;
+  const basePath = routing.basePath && routing.basePath !== "/" ? routing.basePath : "";
+  if (canonicalPathname === "/") {
+    return basePath ? `${basePath}/${LOCALE_PLACEHOLDER}` : `/${LOCALE_PLACEHOLDER}`;
+  }
+  return basePath ? `${basePath}/${LOCALE_PLACEHOLDER}${canonicalPathname}` : `/${LOCALE_PLACEHOLDER}${canonicalPathname}`;
 };
 
 export { standardizePathname };

package/dist/next/src/adapters/next/create-intor-handler.js

@@ -1,6 +1,5 @@
 import { NextResponse } from 'next/server';
 import { INTOR_HEADERS } from '../../core/constants/headers.js';
-import '../../core/error/intor-error.js';
 import { normalizeQuery } from '../../core/utils/normalizers/normalize-query.js';
 import 'logry';
 import 'p-limit';
@@ -8,51 +7,36 @@ import 'intor-translator';
 import { resolveInbound } from '../../routing/inbound/resolve-inbound.js';
 import { getLocaleFromAcceptLanguage } from '../../routing/locale/get-locale-from-accept-language.js';
 
-/**
- * Resolves locale-aware routing for the current execution context.
- *
- * The resolved routing state is exposed via response headers.
- *
- * - Acts as the canonical routing authority, guaranteeing a canonical routing result for every request.
- *
- * @platform Next.js
- */
 function createIntorHandler(config) {
-    return async function intorHandler(request) {
-        const { host, searchParams, pathname: rawPathname } = request.nextUrl;
-        // Locale from Accept-Language header
-        const acceptLanguageHeader = request.headers.get("accept-language");
-        const localeFromAcceptLanguage = getLocaleFromAcceptLanguage(acceptLanguageHeader, config.supportedLocales);
-        // Check whether this navigation flow has already redirected
-        const hasRedirected = request.headers.get(INTOR_HEADERS.REDIRECTED) === "1";
-        // ----------------------------------------------------------
-        // Resolve inbound routing decision (pure computation)
-        // ----------------------------------------------------------
-        const { locale, localeSource, pathname, shouldRedirect } = await resolveInbound(config, rawPathname, {
-            host,
-            query: normalizeQuery(Object.fromEntries(searchParams.entries())),
-            cookie: request.cookies.get(config.cookie.name)?.value,
-            detected: localeFromAcceptLanguage || config.defaultLocale,
-        }, { hasRedirected });
-        // ----------------------------------------------------------
-        // Prepare Next.js response (redirect or pass-through)
-        // ----------------------------------------------------------
-        const url = request.nextUrl.clone();
-        url.pathname = pathname;
-        const response = shouldRedirect
-            ? NextResponse.redirect(url)
-            : NextResponse.next();
-        // ----------------------------------------------------------
-        // Attach routing metadata to response headers
-        // ----------------------------------------------------------
-        response.headers.set(INTOR_HEADERS.LOCALE, locale);
-        response.headers.set(INTOR_HEADERS.LOCALE_SOURCE, localeSource);
-        response.headers.set(INTOR_HEADERS.PATHNAME, pathname);
-        // Mark redirect to prevent infinite loops in this flow
-        if (shouldRedirect)
-            response.headers.set(INTOR_HEADERS.REDIRECTED, "1");
-        return response;
-    };
+  return function intorHandler(request) {
+    const { host, searchParams, pathname: rawPathname } = request.nextUrl;
+    const acceptLanguageHeader = request.headers.get("accept-language");
+    const localeFromAcceptLanguage = getLocaleFromAcceptLanguage(
+      acceptLanguageHeader,
+      config.supportedLocales
+    );
+    const hasRedirected = request.headers.get(INTOR_HEADERS.REDIRECTED) === "1";
+    const cookie = request.cookies.get(config.cookie.name)?.value;
+    const { locale, localeSource, pathname, shouldRedirect } = resolveInbound(
+      config,
+      rawPathname,
+      {
+        host,
+        query: normalizeQuery(Object.fromEntries(searchParams.entries())),
+        ...cookie !== void 0 ? { cookie } : {},
+        ...localeFromAcceptLanguage !== void 0 ? { detected: localeFromAcceptLanguage } : {}
+      },
+      { hasRedirected }
+    );
+    const url = request.nextUrl.clone();
+    url.pathname = pathname;
+    const response = shouldRedirect ? NextResponse.redirect(url) : NextResponse.next();
+    response.headers.set(INTOR_HEADERS.LOCALE, locale);
+    response.headers.set(INTOR_HEADERS.LOCALE_SOURCE, localeSource);
+    response.headers.set(INTOR_HEADERS.PATHNAME, pathname);
+    if (shouldRedirect) response.headers.set(INTOR_HEADERS.REDIRECTED, "1");
+    return response;
+  };
 }
 
 export { createIntorHandler };

package/dist/next/src/adapters/next/link.js

@@ -1,42 +1,46 @@
 "use client";
-import { jsx } from 'react/jsx-runtime';
-import { formatUrl } from 'next/dist/shared/lib/router/utils/format-url';
 import NextLink from 'next/link';
 import { usePathname } from 'next/navigation';
-import 'react';
-import { executeNavigation } from '../../client/shared/navigation/execute-navigation.js';
-import { useIntorContext } from 'intor/react';
-import '../../core/error/intor-error.js';
+import * as React from 'react';
 import 'logry';
 import 'p-limit';
 import 'intor-translator';
+import { executeNavigation } from '../../client/shared/navigation/execute-navigation.js';
+import { useIntorContext } from 'intor/react/internal';
 import { resolveOutbound } from '../../routing/outbound/resolve-outbound.js';
 
-/**
- * Render a locale-aware link for the current execution context.
- *
- * - Resolves a locale-aware navigation destination.
- * - Determines whether navigation should be executed client-side or via full reload.
- *
- * @platform Next.js
- */
-const Link = ({ href, locale, children, onClick, ...props }) => {
-    const { config, locale: currentLocale, setLocale } = useIntorContext();
-    const currentPathname = usePathname();
-    // Normalize href into a string destination
-    const rawDestination = typeof href === "string" ? href : href ? formatUrl(href) : undefined;
-    // Resolve navigation result for this link
-    const outboundResult = resolveOutbound(config, currentLocale, currentPathname, { destination: rawDestination, locale });
-    // --------------------------------------------------
-    // Execute navigation on user interaction
-    // --------------------------------------------------
-    const handleClick = (e) => {
-        onClick?.(e);
-        if (e.defaultPrevented)
-            return;
-        executeNavigation(outboundResult, { config, currentLocale, setLocale }, e);
-    };
-    return (jsx(NextLink, { href: outboundResult.destination, onClick: handleClick, ...props, children: children }));
+const Link = ({
+  href,
+  locale,
+  children,
+  onClick,
+  ...props
+}) => {
+  const { config, locale: currentLocale, setLocale } = useIntorContext();
+  const currentPathname = usePathname();
+  const outboundResult = resolveOutbound(
+    config,
+    currentLocale,
+    currentPathname,
+    {
+      ...href !== void 0 ? { destination: href } : {},
+      ...locale !== void 0 ? { locale } : {}
+    }
+  );
+  const handleClick = (e) => {
+    onClick?.(e);
+    if (e.defaultPrevented) return;
+    executeNavigation(outboundResult, { config, currentLocale, setLocale }, e);
+  };
+  return /* @__PURE__ */ React.createElement(
+    NextLink,
+    {
+      href: outboundResult.destination,
+      onClick: handleClick,
+      ...props
+    },
+    children
+  );
 };
 
 export { Link };

package/dist/next/src/adapters/next/redirect.js

@@ -1,29 +1,24 @@
 import { redirect as redirect$1 } from 'next/navigation';
-import '../../core/error/intor-error.js';
 import 'logry';
 import 'p-limit';
 import 'intor-translator';
 import { resolveOutbound } from '../../routing/outbound/resolve-outbound.js';
 import { getLocale } from './server/get-locale.js';
 
-/**
- * Redirect to a locale-aware destination for the current execution context.
- *
- * - Bypasses localization for external destinations.
- * - Automatically resolves the effective locale from the execution context.
- *
- * @platform Next.js
- */
-const redirect = async (config, url, { locale, type }) => {
-    const currentLocale = await getLocale(config);
-    const { destination, kind } = resolveOutbound(config, currentLocale, url, {
-        locale,
-    });
-    if (kind === "external") {
-        redirect$1(url);
-        return;
+const redirect = async (config, url, options) => {
+  const { locale, type } = options ?? {};
+  const currentLocale = await getLocale(config);
+  const { destination } = resolveOutbound(
+    config,
+    currentLocale,
+    "",
+    // server redirect does not depend on current pathname
+    {
+      destination: url,
+      ...locale !== void 0 ? { locale } : {}
     }
-    return redirect$1(destination, type);
+  );
+  return redirect$1(destination, type);
 };
 
 export { redirect };