intor 2.5.0 → 2.6.0

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

@@ -2,37 +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'
- * //   canonicalPathname: '/about',
- * //   templatedPathname: '/app/{locale}/about',
- * // }
- * ```
- *
- * @public
- */
 const localizePathname = (rawPathname, config, locale) => {
-    // 1. Canonicalize: normalize and remove routing-specific prefixes
-    const canonicalPathname = canonicalizePathname(rawPathname, config);
-    // 2. Standardize: convert to internal pathname shape with locale placeholder
-    const standardizedPathname = standardizePathname(canonicalPathname, config);
-    // 3. Materialize: apply routing rules to produce the final pathname
-    const materializedPathname = materializePathname(standardizedPathname, config, locale);
-    return {
-        canonicalPathname,
-        templatedPathname: standardizedPathname,
-        pathname: materializedPathname,
-    };
+  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

@@ -3,51 +3,16 @@ import 'logry';
 import 'p-limit';
 import 'intor-translator';
 
-/**
- * Materializes a standardized pathname into a concrete, locale-aware URL.
- *
- * This function resolves the `{locale}` placeholder according to the
- * configured `localePrefix` strategy and produces the final pathname.
- *
- * Behavior:
- * - "all": always injects the locale segment
- * - "except-default": injects the locale unless it equals `defaultLocale`
- * - "none": removes the locale placeholder entirely
- *
- * Invariants:
- * - `standardizedPathname` must be produced by `standardizePathname`
- * - The pathname must contain exactly one `{locale}` placeholder
- * - The placeholder must appear as the first path segment
- *
- * This function performs structural transformation only.
- * It does not normalize or sanitize the resulting pathname.
- *
- * @example
- * ```ts
- * // config.routing.localePrefix: "all"
- * materializePathname("/app/{locale}/about", config, "en");
- * // => /app/en/about
- *
- * // config.routing.localePrefix: "none"
- * materializePathname("/app/{locale}/about", config, "en");
- * // => /app/about
- * ```
- */
 const materializePathname = (standardizedPathname, config, locale) => {
-    const { localePrefix } = config.routing;
-    const removeLocale = () => {
-        const result = standardizedPathname.replace(`/${LOCALE_PLACEHOLDER}`, "");
-        return result === "" ? "/" : result;
-    };
-    const injectLocale = () => standardizedPathname.replace(LOCALE_PLACEHOLDER, locale);
-    // localePrefix: "none"
-    if (localePrefix === "none")
-        return removeLocale();
-    // localePrefix: "all"
-    if (localePrefix === "all")
-        return injectLocale();
-    // localePrefix: "except-default"
-    return locale === config.defaultLocale ? removeLocale() : injectLocale();
+  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

@@ -3,37 +3,13 @@ import 'logry';
 import 'p-limit';
 import 'intor-translator';
 
-/**
- * Standardizes a canonical pathname into an internal routing template.
- *
- * Standardized representation:
- * - Prepends the deployment prefix (`basePath`) if defined
- * - Injects the `{locale}` placeholder as the first path segment
- * - Preserves the canonical pathname structure
- *
- * Input must be a canonical pathname.
- *
- * Output is an internal routing template and
- * is not a locale-resolved URL.
- *
- * @example
- * ```ts
- * // config.routing.basePath: "/app",
- * standardizePathname("/about", config);
- * // => "/app/{locale}/about"
- * ```
- */
 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}`;
+  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/export/next/server/index.js

@@ -1,3 +1,4 @@
 export { intor } from '../../../src/adapters/next/server/intor.js';
 export { getLocale } from '../../../src/adapters/next/server/get-locale.js';
 export { getTranslator } from '../../../src/adapters/next/server/get-translator.js';
+export { readIntorUrlState } from '../../../src/adapters/next/server/read-intor-url-state.js';

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

@@ -1,60 +1,51 @@
 import { NextResponse } from 'next/server';
-import { INTOR_HEADERS } from '../../core/constants/headers.js';
 import { normalizeQuery } from '../../core/utils/normalizers/normalize-query.js';
 import 'logry';
 import 'p-limit';
 import 'intor-translator';
 import { resolveInbound } from '../../routing/inbound/resolve-inbound.js';
 import { getLocaleFromAcceptLanguage } from '../../routing/locale/get-locale-from-accept-language.js';
+import { INTOR_HEADER_KEYS } from './header-keys.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.
- *
- * @public
- */
 function createIntorHandler(config) {
-    return 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 cookie = request.cookies.get(config.cookie.name)?.value;
-        const { locale, localeSource, pathname, shouldRedirect } = resolveInbound(config, rawPathname, {
-            host,
-            query: normalizeQuery(Object.fromEntries(searchParams.entries())),
-            ...(cookie !== undefined ? { cookie } : {}),
-            ...(localeFromAcceptLanguage !== undefined
-                ? { detected: localeFromAcceptLanguage }
-                : {}),
-        }, { 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,
+      search
+    } = request.nextUrl;
+    const acceptLanguageHeader = request.headers.get("accept-language");
+    const localeFromAcceptLanguage = getLocaleFromAcceptLanguage(
+      acceptLanguageHeader,
+      config.supportedLocales
+    );
+    const hasRedirected = request.headers.get(INTOR_HEADER_KEYS.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();
+    if (shouldRedirect) {
+      url.pathname = pathname;
+      url.search = search;
+    }
+    const response = shouldRedirect ? NextResponse.redirect(url) : NextResponse.next();
+    response.headers.set(INTOR_HEADER_KEYS.LOCALE, locale);
+    response.headers.set(INTOR_HEADER_KEYS.LOCALE_SOURCE, localeSource);
+    response.headers.set(INTOR_HEADER_KEYS.PATHNAME, pathname);
+    response.headers.set(INTOR_HEADER_KEYS.SEARCH, search);
+    if (shouldRedirect) response.headers.set(INTOR_HEADER_KEYS.REDIRECTED, "1");
+    return response;
+  };
 }
 
 export { createIntorHandler };

package/dist/next/src/adapters/next/header-keys.js

@@ -0,0 +1,9 @@
+const INTOR_HEADER_KEYS = {
+  LOCALE: "x-intor-locale",
+  LOCALE_SOURCE: "x-intor-locale-source",
+  PATHNAME: "x-intor-pathname",
+  SEARCH: "x-intor-search",
+  REDIRECTED: "x-intor-redirected"
+};
+
+export { INTOR_HEADER_KEYS };

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

@@ -1,8 +1,7 @@
 "use client";
-import { jsx } from 'react/jsx-runtime';
 import NextLink from 'next/link';
 import { usePathname } from 'next/navigation';
-import 'react';
+import * as React from 'react';
 import 'logry';
 import 'p-limit';
 import 'intor-translator';
@@ -10,32 +9,38 @@ import { executeNavigation } from '../../client/shared/navigation/execute-naviga
 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.
- *
- * @public
- */
-const Link = ({ href, locale, children, onClick, ...props }) => {
-    const { config, locale: currentLocale, setLocale } = useIntorContext();
-    const currentPathname = usePathname();
-    // Resolve navigation result for this link
-    const outboundResult = resolveOutbound(config, currentLocale, currentPathname, {
-        ...(href !== undefined ? { destination: href } : {}),
-        ...(locale !== undefined ? { 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

@@ -5,23 +5,20 @@ 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.
- *
- * @public
- */
 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
+  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 !== undefined ? { locale } : {}),
-    });
-    return redirect$1(destination, type);
+      destination: url,
+      ...locale !== void 0 ? { locale } : {}
+    }
+  );
+  return redirect$1(destination, type);
 };
 
 export { redirect };

package/dist/next/src/adapters/next/server/get-locale.js

@@ -1,34 +1,23 @@
 import { headers, cookies } from 'next/headers';
-import { INTOR_HEADERS } from '../../../core/constants/headers.js';
 import { matchLocale } from '../../../core/locale/match-locale.js';
 import 'logry';
 import 'p-limit';
 import 'intor-translator';
+import { INTOR_HEADER_KEYS } from '../header-keys.js';
 
-/**
- * Get the locale for the current execution context.
- *
- * Uses inbound routing context when available, otherwise falls back to persisted state.
- *
- * @public
- */
 const getLocale = async (config) => {
-    const headersStore = await headers();
-    // Inbound routing context (authoritative)
-    const headerLocale = headersStore.get(INTOR_HEADERS.LOCALE);
-    if (headerLocale) {
-        return headerLocale;
-    }
-    // Persisted state
-    const cookieStore = await cookies();
-    const cookieLocale = cookieStore.get(config.cookie.name)?.value;
-    if (cookieLocale) {
-        const matched = matchLocale(cookieLocale, config.supportedLocales);
-        if (matched)
-            return matched;
-    }
-    // Explicit default
-    return config.defaultLocale;
+  const headersList = await headers();
+  const headerLocale = headersList.get(INTOR_HEADER_KEYS.LOCALE);
+  if (headerLocale) {
+    return headerLocale;
+  }
+  const cookieStore = await cookies();
+  const cookieLocale = cookieStore.get(config.cookie.name)?.value;
+  if (cookieLocale) {
+    const matched = matchLocale(cookieLocale, config.supportedLocales);
+    if (matched) return matched;
+  }
+  return config.defaultLocale;
 };
 
 export { getLocale };

package/dist/next/src/adapters/next/server/get-translator.js

@@ -1,16 +1,9 @@
 import { getTranslator as getTranslator$1 } from 'intor/server';
 import { getLocale } from './get-locale.js';
 
-/**
- * Get a server-side translator for the current execution context.
- *
- * - Automatically resolves the locale from the framework context.
- *
- * @public
- */
 async function getTranslator(config, params) {
-    const locale = await getLocale(config);
-    return getTranslator$1(config, { locale, ...(params ?? {}) });
+  const locale = await getLocale(config);
+  return getTranslator$1(config, { locale, ...params ?? {} });
 }
 
 export { getTranslator };

package/dist/next/src/adapters/next/server/intor.js

@@ -1,20 +1,12 @@
 import { intor as intor$1 } from 'intor/server';
 import { getLocale } from './get-locale.js';
 
-/**
- * Initializes Intor for the current execution context.
- *
- * - Automatically resolves the locale from the framework context.
- * - Permits cache writes during server execution.
- *
- * @public
- */
 async function intor(config, options) {
-    const { readers, allowCacheWrite = true } = options ?? {};
-    return await intor$1(config, await getLocale(config), {
-        ...(readers !== undefined ? { readers } : {}),
-        allowCacheWrite,
-    });
+  const { readers, allowCacheWrite = true } = options ?? {};
+  return await intor$1(config, await getLocale(config), {
+    ...readers !== void 0 ? { readers } : {},
+    allowCacheWrite
+  });
 }
 
 export { intor };

package/dist/next/src/adapters/next/server/read-intor-url-state.js

@@ -0,0 +1,13 @@
+import { headers } from 'next/headers';
+import { INTOR_HEADER_KEYS } from '../header-keys.js';
+
+async function readIntorUrlState() {
+  const headersList = await headers();
+  return {
+    locale: headersList.get(INTOR_HEADER_KEYS.LOCALE) ?? null,
+    pathname: headersList.get(INTOR_HEADER_KEYS.PATHNAME) ?? "/",
+    search: headersList.get(INTOR_HEADER_KEYS.SEARCH) ?? ""
+  };
+}
+
+export { readIntorUrlState };

package/dist/next/src/adapters/next/use-router.js

@@ -6,76 +6,57 @@ import { executeNavigation } from '../../client/shared/navigation/execute-naviga
 import { useIntorContext } from 'intor/react/internal';
 import { resolveOutbound } from '../../routing/outbound/resolve-outbound.js';
 
-/**
- * Locale-aware router hook for the current execution context.
- *
- * - Resolves a locale-aware navigation destination.
- * - Commits locale changes only on actual navigation.
- * - Keeps routing logic pure and side-effects explicit.
- *
- * @public
- */
 function useRouter() {
-    const { config, locale: currentLocale, setLocale } = useIntorContext();
-    const currentPathname = usePathname();
-    const nextRouter = useRouter$1();
-    function resolve(href, locale) {
-        return resolveOutbound(config, currentLocale, currentPathname, {
-            destination: href,
-            ...(locale !== undefined ? { locale } : {}),
-        });
+  const { config, locale: currentLocale, setLocale } = useIntorContext();
+  const currentPathname = usePathname();
+  const nextRouter = useRouter$1();
+  function resolve(href, locale) {
+    return resolveOutbound(config, currentLocale, currentPathname, {
+      destination: href,
+      ...locale !== void 0 ? { locale } : {}
+    });
+  }
+  function execute(outboundResult) {
+    executeNavigation(outboundResult, { config, currentLocale, setLocale });
+  }
+  function push(href, options) {
+    const outboundResult = resolve(href, options?.locale);
+    execute(outboundResult);
+    if (!options) {
+      nextRouter.push(outboundResult.destination);
+      return;
     }
-    function execute(outboundResult) {
-        executeNavigation(outboundResult, { config, currentLocale, setLocale });
+    const { locale: _, ...rest } = options;
+    nextRouter.push(outboundResult.destination, rest);
+  }
+  function replace(href, options) {
+    const outboundResult = resolve(href, options?.locale);
+    execute(outboundResult);
+    if (!options) {
+      nextRouter.replace(outboundResult.destination);
+      return;
     }
-    // --------------------------------------------------
-    // push
-    // --------------------------------------------------
-    function push(href, options) {
-        const outboundResult = resolve(href, options?.locale);
-        execute(outboundResult);
-        if (!options) {
-            nextRouter.push(outboundResult.destination);
-            return;
-        }
-        const { locale: _, ...rest } = options;
-        nextRouter.push(outboundResult.destination, rest);
+    const { locale: _, ...rest } = options;
+    nextRouter.replace(outboundResult.destination, rest);
+  }
+  function prefetch(href, options) {
+    const outboundResult = resolve(href, options?.locale);
+    if (outboundResult.kind !== "client") return;
+    if (!options) {
+      nextRouter.prefetch(outboundResult.destination);
+      return;
     }
-    // --------------------------------------------------
-    // replace
-    // --------------------------------------------------
-    function replace(href, options) {
-        const outboundResult = resolve(href, options?.locale);
-        execute(outboundResult);
-        if (!options) {
-            nextRouter.replace(outboundResult.destination);
-            return;
-        }
-        const { locale: _, ...rest } = options;
-        nextRouter.replace(outboundResult.destination, rest);
-    }
-    // --------------------------------------------------
-    // prefetch (NO side effects)
-    // --------------------------------------------------
-    function prefetch(href, options) {
-        const outboundResult = resolve(href, options?.locale);
-        if (outboundResult.kind !== "client")
-            return;
-        if (!options) {
-            nextRouter.prefetch(outboundResult.destination);
-            return;
-        }
-        const { locale: _, ...rest } = options;
-        nextRouter.prefetch(outboundResult.destination, rest);
-    }
-    return {
-        push,
-        replace,
-        prefetch,
-        back: () => nextRouter.back(),
-        forward: () => nextRouter.forward(),
-        refresh: () => nextRouter.refresh(),
-    };
+    const { locale: _, ...rest } = options;
+    nextRouter.prefetch(outboundResult.destination, rest);
+  }
+  return {
+    push,
+    replace,
+    prefetch,
+    back: () => nextRouter.back(),
+    forward: () => nextRouter.forward(),
+    refresh: () => nextRouter.refresh()
+  };
 }
 
 export { useRouter };