intor 2.4.17 → 2.5.1

package/dist/express/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/express/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/express/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/express/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/fastify/src/adapters/fastify/create-intor-handler.js

@@ -1,4 +1,4 @@
-import '../../core/error/intor-error.js';
+import { getTranslator } from 'intor/server';
 import { parseCookieHeader } from '../../core/utils/parse-cookie-header.js';
 import { normalizeQuery } from '../../core/utils/normalizers/normalize-query.js';
 import 'logry';
@@ -6,51 +6,43 @@ 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 'node:path';
-import 'node:fs/promises';
-import { getTranslator } from '../../server/helpers/get-translator.js';
 
-/**
- * Resolves locale-aware routing for the current execution context.
- *
- * - Binds resolved routing state to the request.
- * - Convenience routing shortcuts are also bound to the request for downstream consumption.
- *
- * @platform Fastify
- */
 function createIntorHandler(config, options) {
-    return async function intorHandler(request) {
-        // Locale from Accept-Language header
-        const acceptLanguage = request.headers["accept-language"];
-        const localeFromAcceptLanguage = getLocaleFromAcceptLanguage(acceptLanguage, config.supportedLocales);
-        // ----------------------------------------------------------
-        // Resolve inbound routing decision (pure computation)
-        // ----------------------------------------------------------
-        const { locale, localeSource, pathname } = await resolveInbound(config, request.raw.url?.split("?")[0] ?? "/", {
-            host: request.hostname,
-            query: normalizeQuery(request.query),
-            cookie: parseCookieHeader(request.headers.cookie)[config.cookie.name],
-            detected: localeFromAcceptLanguage || config.defaultLocale,
-        });
-        // --------------------------------------------------
-        // Bind inbound routing context
-        // --------------------------------------------------
-        request.intor = { locale, localeSource, pathname };
-        const { hasKey, t, tRich } = await getTranslator(config, {
-            locale,
-            handlers: options?.handlers,
-            plugins: options?.plugins,
-            readers: options?.readers,
-            allowCacheWrite: true,
-        });
-        // DX shortcuts (enabled by default)
-        if (options?.shortcuts !== false) {
-            request.locale = locale;
-            request.hasKey = hasKey;
-            request.t = t;
-            request.tRich = tRich;
-        }
-    };
+  return async function intorHandler(request) {
+    const acceptLanguage = request.headers["accept-language"];
+    const localeFromAcceptLanguage = getLocaleFromAcceptLanguage(
+      acceptLanguage,
+      config.supportedLocales
+    );
+    const cookie = parseCookieHeader(request.headers.cookie)[config.cookie.name];
+    const rawPathname = new URL(request.raw.url ?? "/", "http://localhost").pathname;
+    const { locale, localeSource, pathname } = resolveInbound(
+      config,
+      rawPathname,
+      {
+        host: request.hostname,
+        query: normalizeQuery(request.query),
+        ...cookie !== void 0 ? { cookie } : {},
+        ...localeFromAcceptLanguage !== void 0 ? { detected: localeFromAcceptLanguage } : {}
+      }
+    );
+    request.intor = { locale, localeSource, pathname };
+    const { loader, handlers, hooks, readers } = options ?? {};
+    const { hasKey, t, tRich } = await getTranslator(config, {
+      locale,
+      ...loader !== void 0 ? { loader } : {},
+      ...readers !== void 0 ? { readers } : {},
+      allowCacheWrite: true,
+      ...handlers !== void 0 ? { handlers } : {},
+      ...hooks !== void 0 ? { hooks } : {}
+    });
+    if (options?.shortcuts !== false) {
+      request.locale = locale;
+      request.hasKey = hasKey;
+      request.t = t;
+      request.tRich = tRich;
+    }
+  };
 }
 
 export { createIntorHandler };

package/dist/fastify/src/adapters/fastify/get-translator.js

@@ -1,29 +1,8 @@
-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';
 
-/**
- * Get a server-side translator for the current execution context.
- *
- * - Automatically resolves the locale from the framework context.
- *
- * @platform Fastify
- */
 async function getTranslator(config, request, params) {
-    const { loader, readers, allowCacheWrite, handlers, plugins, preKey } = params || {};
-    return getTranslator$1(config, {
-        locale: request.intor?.locale || config.defaultLocale,
-        loader,
-        readers,
-        allowCacheWrite,
-        handlers,
-        plugins,
-        preKey,
-    });
+  const locale = request.intor?.locale ?? config.defaultLocale;
+  return getTranslator$1(config, { locale, ...params ?? {} });
 }
 
 export { getTranslator };

package/dist/fastify/src/adapters/fastify/intor-fastify-plugin.js

@@ -1,34 +1,40 @@
+import fp from 'fastify-plugin';
 import { createIntorHandler } from './create-intor-handler.js';
 
-/**
- * Intor Fastify adapter plugin
- */
-function intorFastifyPlugin(fastify, options) {
-    const { config, shortcuts = true, handlers, plugins, readers } = options;
-    // --------------------------------------------------
-    // Declare request structure (once per instance)
-    // --------------------------------------------------
-    decorateRequest(fastify, "intor");
-    if (shortcuts) {
-        decorateRequest(fastify, "locale");
-        decorateRequest(fastify, "hasKey");
-        decorateRequest(fastify, "t");
-        decorateRequest(fastify, "tRich");
-    }
-    // --------------------------------------------------
-    // Bind inbound handler
-    // --------------------------------------------------
-    fastify.addHook("onRequest", createIntorHandler(config, { handlers, plugins, readers, shortcuts }));
-}
-/** Fastify plugin metadata (without fastify-plugin) */
-intorFastifyPlugin[Symbol.for("fastify.display-name")] =
-    "@intor/fastify";
-intorFastifyPlugin[Symbol.for("skip-override")] = true;
-/** Internal helpers */
 function decorateRequest(fastify, key) {
-    if (fastify.hasRequestDecorator?.(key))
-        return;
-    fastify.decorateRequest(key, null);
+  if (fastify.hasRequestDecorator?.(key)) return;
+  fastify.decorateRequest(key, null);
 }
+const intorFastifyPluginImpl = (fastify, options, done) => {
+  const {
+    config,
+    loader,
+    readers,
+    handlers,
+    hooks,
+    shortcuts = true
+  } = options;
+  decorateRequest(fastify, "intor");
+  if (shortcuts) {
+    decorateRequest(fastify, "locale");
+    decorateRequest(fastify, "hasKey");
+    decorateRequest(fastify, "t");
+    decorateRequest(fastify, "tRich");
+  }
+  fastify.addHook(
+    "onRequest",
+    createIntorHandler(config, {
+      ...loader !== void 0 ? { loader } : {},
+      ...readers !== void 0 ? { readers } : {},
+      ...handlers !== void 0 ? { handlers } : {},
+      ...hooks !== void 0 ? { hooks } : {},
+      shortcuts
+    })
+  );
+  done();
+};
+const intorFastifyPlugin = fp(intorFastifyPluginImpl, {
+  name: "@intor/fastify"
+});
 
 export { intorFastifyPlugin };

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

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

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