intor 2.4.17 → 2.5.1

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 '../../../core/error/intor-error.js';
 import { matchLocale } from '../../../core/locale/match-locale.js';
 import 'logry';
 import 'p-limit';
 import 'intor-translator';
 
-/**
- * Get the locale for the current execution context.
- *
- * @note Uses inbound routing context when available, otherwise falls back to persisted state.
- * @platform Next.js
- */
 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 headersStore = await headers();
+  const headerLocale = headersStore.get(INTOR_HEADERS.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,30 +1,9 @@
-import '../../../core/error/intor-error.js';
-import 'logry';
-import 'p-limit';
-import 'intor-translator';
-import 'node:path';
-import 'node:fs/promises';
-import { getTranslator as getTranslator$1 } from '../../../server/helpers/get-translator.js';
+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.
- *
- * @platform Next.js
- */
 async function getTranslator(config, params) {
-    const { loader, readers, allowCacheWrite, handlers, plugins, preKey } = params || {};
-    return getTranslator$1(config, {
-        locale: await getLocale(config),
-        loader,
-        readers,
-        allowCacheWrite,
-        handlers,
-        plugins,
-        preKey,
-    });
+  const locale = await getLocale(config);
+  return getTranslator$1(config, { locale, ...params ?? {} });
 }
 
 export { getTranslator };

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

@@ -1,24 +1,12 @@
-import '../../../core/error/intor-error.js';
-import 'logry';
-import 'p-limit';
-import 'intor-translator';
-import { intor as intor$1 } from '../../../server/intor/intor.js';
-import 'node:path';
-import 'node:fs/promises';
+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.
- * @platform Next.js
- */
 async function intor(config, options) {
-    return await intor$1(config, await getLocale(config), {
-        readers: options?.readers,
-        allowCacheWrite: options?.allowCacheWrite ?? true,
-    });
+  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/use-router.js

@@ -1,55 +1,62 @@
 import { usePathname, useRouter as useRouter$1 } from 'next/navigation';
-import { executeNavigation } from '../../client/shared/navigation/execute-navigation.js';
-import { useIntorContext } from 'intor/react';
-import '../../core/error/intor-error.js';
 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';
 
-/**
- * Locale-aware router hook 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 useRouter = () => {
-    const { config, locale: currentLocale, setLocale } = useIntorContext();
-    const currentPathname = usePathname();
-    const { push: nextRouterPush, replace: nextRouterReplace, prefetch: nextRouterPrefetch, ...rest } = useRouter$1();
-    // --------------------------------------------------
-    // push
-    // --------------------------------------------------
-    const push = (href, options) => {
-        const outboundResult = resolveOutbound(config, currentLocale, currentPathname, { destination: href, locale: options?.locale });
-        executeNavigation(outboundResult, { config, currentLocale, setLocale });
-        nextRouterPush(outboundResult.destination, options);
-    };
-    // --------------------------------------------------
-    // replace
-    // --------------------------------------------------
-    const replace = (href, options) => {
-        const outboundResult = resolveOutbound(config, currentLocale, currentPathname, { destination: href, locale: options?.locale });
-        executeNavigation(outboundResult, { config, currentLocale, setLocale });
-        nextRouterReplace(outboundResult.destination, options);
-    };
-    // --------------------------------------------------
-    // prefetch
-    // --------------------------------------------------
-    const prefetch = (href, options) => {
-        const { kind, destination } = resolveOutbound(config, currentLocale, currentPathname, { destination: href, locale: options?.locale });
-        if (kind !== "client")
-            return; // Prefetch only makes sense for client-side navigation
-        nextRouterPrefetch(destination, options);
-    };
-    return {
-        push,
-        replace,
-        prefetch,
-        ...rest,
-    };
-};
+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 !== 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;
+    }
+    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;
+    }
+    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;
+    }
+    const { locale: _, ...rest } = options;
+    nextRouter.prefetch(outboundResult.destination, rest);
+  }
+  return {
+    push,
+    replace,
+    prefetch,
+    back: () => nextRouter.back(),
+    forward: () => nextRouter.forward(),
+    refresh: () => nextRouter.refresh()
+  };
+}
 
 export { useRouter };

package/dist/next/src/client/shared/navigation/execute-navigation.js

@@ -1,51 +1,32 @@
-import '../../../core/error/intor-error.js';
 import 'logry';
 import 'p-limit';
 import 'intor-translator';
 import { shouldSyncLocale } from '../../../policies/should-sync-locale.js';
 import { setLocaleCookie } from '../utils/locale/set-locale-cookie.js';
 
-/**
- * Executes a resolved outbound routing result.
- *
- * Applies all imperative side effects required to realize the outbound decision,
- * including locale synchronization, cookie persistence, and full page reloads.
- *
- * This function must be called after `resolveOutbound`.
- */
 function executeNavigation(outboundResult, context, e) {
-    const { config, currentLocale, setLocale } = context;
-    const { cookie } = config;
-    const { destination, kind, locale } = outboundResult;
-    // ------------------------------------------------------
-    // External navigation: let browser handle it
-    // ------------------------------------------------------
-    if (kind === "external") {
-        return;
-    }
-    // ------------------------------------------------------
-    // Full reload: commit locale side effects, then perform document reload
-    // ------------------------------------------------------
-    if (kind === "reload") {
-        e?.preventDefault();
-        if (shouldSyncLocale(locale, currentLocale)) {
-            if (cookie.persist) {
-                setLocaleCookie(cookie, locale);
-            }
-        }
-        globalThis.location.href = destination;
-        return;
-    }
-    // ------------------------------------------------------
-    // Client-side navigation only
-    // ------------------------------------------------------
+  const { config, currentLocale, setLocale } = context;
+  const { cookie } = config;
+  const { destination, kind, locale } = outboundResult;
+  if (kind === "external") {
+    return;
+  }
+  if (kind === "reload") {
+    e?.preventDefault();
     if (shouldSyncLocale(locale, currentLocale)) {
-        // Eagerly persist locale to avoid stale cookie during client-side navigation.
-        if (cookie.persist) {
-            setLocaleCookie(cookie, locale);
-        }
-        setLocale(locale);
+      if (cookie.persist) {
+        setLocaleCookie(cookie, locale);
+      }
+    }
+    globalThis.location.href = destination;
+    return;
+  }
+  if (shouldSyncLocale(locale, currentLocale)) {
+    if (cookie.persist) {
+      setLocaleCookie(cookie, locale);
     }
+    setLocale(locale);
+  }
 }
 
 export { executeNavigation };

package/dist/next/src/client/shared/utils/build-cookie-string.js

@@ -1,30 +1,22 @@
-/**
- * Build a serialized cookie string.
- */
 const buildCookieString = (cookieOptions, value) => {
-    const { name, maxAge, path, domain, sameSite, secure } = cookieOptions;
-    // Cookie name and encoded value
-    const parts = [`${name}=${encodeURIComponent(value)}`];
-    // Add expiration and max-age if provided
-    if (maxAge) {
-        const expires = new Date(Date.now() + maxAge * 1000).toUTCString();
-        parts.push(`expires=${expires}`, `max-age=${maxAge}`);
-    }
-    // Set path (default to "/")
-    parts.push(`path=${path ?? "/"}`);
-    // Add domain if specified
-    if (domain) {
-        parts.push(`domain=${domain}`);
-    }
-    // Add SameSite policy (e.g., Lax, Strict)
-    if (sameSite) {
-        parts.push(`SameSite=${sameSite[0].toUpperCase()}${sameSite.slice(1).toLowerCase()}`);
-    }
-    // Add Secure flag if not explicitly disabled
-    if (secure !== false) {
-        parts.push(`Secure`);
-    }
-    return parts.join("; ");
+  const { name, maxAge, path, domain, sameSite, secure } = cookieOptions;
+  const parts = [`${name}=${encodeURIComponent(value)}`];
+  if (maxAge !== void 0) {
+    const expires = new Date(Date.now() + maxAge * 1e3).toUTCString();
+    parts.push(`expires=${expires}`, `max-age=${maxAge}`);
+  }
+  parts.push(`path=${path ?? "/"}`);
+  if (domain) {
+    parts.push(`domain=${domain}`);
+  }
+  if (sameSite) {
+    const normalized = sameSite.charAt(0).toUpperCase() + sameSite.slice(1).toLowerCase();
+    parts.push(`SameSite=${normalized}`);
+  }
+  if (secure !== false) {
+    parts.push(`Secure`);
+  }
+  return parts.join("; ");
 };
 
 export { buildCookieString };

package/dist/next/src/client/shared/utils/locale/set-locale-cookie.js

@@ -1,15 +1,8 @@
 import { buildCookieString } from '../build-cookie-string.js';
 
-/**
- * Persist locale to a cookie.
- *
- * This function relies on `document.cookie`.
- */
 const setLocaleCookie = (cookieOptions, locale) => {
-    if (typeof document === "undefined")
-        return;
-    // Build and apply the cookie string
-    document.cookie = buildCookieString(cookieOptions, locale);
+  if (typeof document === "undefined") return;
+  document.cookie = buildCookieString(cookieOptions, locale);
 };
 
 export { setLocaleCookie };

package/dist/next/src/core/constants/headers.js

@@ -1,8 +1,8 @@
 const INTOR_HEADERS = {
-    LOCALE: "x-intor-locale",
-    LOCALE_SOURCE: "x-intor-locale-source",
-    PATHNAME: "x-intor-pathname",
-    REDIRECTED: "x-intor-redirected",
+  LOCALE: "x-intor-locale",
+  LOCALE_SOURCE: "x-intor-locale-source",
+  PATHNAME: "x-intor-pathname",
+  REDIRECTED: "x-intor-redirected"
 };
 
 export { INTOR_HEADERS };

package/dist/next/src/core/constants/locale-placeholder.js

@@ -1,4 +1,3 @@
-// Default locale placeholder
 const LOCALE_PLACEHOLDER = "{locale}";
 
 export { LOCALE_PLACEHOLDER };

package/dist/next/src/core/locale/canonicalize-locale.js

@@ -1,23 +1,12 @@
-/**
- * Canonicalizes a BCP 47 locale string.
- *
- * - Uses `Intl.getCanonicalLocales` when available.
- * - Returns the original input if `Intl` is unavailable.
- * - Returns `undefined` for invalid locale input.
- *
- * This function performs normalization only.
- * It does not perform matching or fallback.
- */
 function canonicalizeLocale(input) {
-    try {
-        if (typeof Intl === "undefined" || !Intl.getCanonicalLocales) {
-            return input;
-        }
-        return Intl.getCanonicalLocales(input)[0];
-    }
-    catch {
-        return;
+  try {
+    if (typeof Intl === "undefined" || !Intl.getCanonicalLocales) {
+      return input;
     }
+    return Intl.getCanonicalLocales(input)[0];
+  } catch {
+    return;
+  }
 }
 
 export { canonicalizeLocale };

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