intor 2.4.17 → 2.5.1

package/dist/core/src/core/messages/utils/nest-object-from-path.js

@@ -1,21 +1,9 @@
-/**
- * Wraps a value inside nested objects according to a given path.
- *
- * @example
- * ```ts
- * const value = { a: "A" };
- *
- * nestObjectFromPath(["auth", "verify"], value); // → { auth: { verify: { a: "A" } } }
- *
- * nestObjectFromPath([], value); // →  { a: "A" }
- * ```
- */
 function nestObjectFromPath(path, value) {
-    let obj = value;
-    for (let i = path.length - 1; i >= 0; i--) {
-        obj = { [path[i]]: obj };
-    }
-    return obj;
+  let obj = value;
+  for (let i = path.length - 1; i >= 0; i--) {
+    obj = { [path[i]]: obj };
+  }
+  return obj;
 }
 
 export { nestObjectFromPath };

package/dist/core/src/core/render/create-html-renderer.js

@@ -1,44 +1,36 @@
 import { escapeHtml } from './utils/escape-html.js';
 import { renderAttributes } from './utils/render-attributes.js';
 
-/**
- * Create an HTML string renderer for semantic rich messages.
- *
- * - Transforms semantic rich AST nodes into escaped HTML strings.
- * - Can be used in any HTML-based environment.
- *
- * This renderer is intentionally minimal and stateless.
- */
 const createHtmlRenderer = (tagRenderers) => {
-    return {
-        /** Render plain text nodes */
-        text(value) {
-            return escapeHtml(value);
-        },
-        /** Render semantic tag nodes */
-        tag(name, attributes, children) {
-            const tagRenderer = tagRenderers?.[name];
-            if (tagRenderer) {
-                return typeof tagRenderer === "function"
-                    ? tagRenderer(children)
-                    : tagRenderer;
-            }
-            // Default behavior: render as native HTML tag
-            return `<${name}${renderAttributes(attributes)}>${children.join("")}</${name}>`;
-        },
-        /** Render raw (non-tokenized) message values as escaped HTML strings */
-        raw(value) {
-            if (value == null)
-                return "";
-            if (typeof value === "string" || typeof value === "number") {
-                return escapeHtml(String(value));
-            }
-            if (Array.isArray(value)) {
-                return value.map((v) => escapeHtml(String(v))).join("");
-            }
-            throw new Error("[intor] HTML renderer cannot render raw non-primitive values.");
-        },
-    };
+  return {
+    /** Render plain text nodes */
+    text(value) {
+      return escapeHtml(value);
+    },
+    /** Render semantic tag nodes */
+    tag(name, attributes, children) {
+      const tagRenderer = tagRenderers?.[name];
+      if (tagRenderer) {
+        return typeof tagRenderer === "function" ? tagRenderer(children) : tagRenderer;
+      }
+      return `<${name}${renderAttributes(attributes)}>${children.join(
+        ""
+      )}</${name}>`;
+    },
+    /** Render raw (non-tokenized) message values as escaped HTML strings */
+    raw(value) {
+      if (value == null) return "";
+      if (typeof value === "string" || typeof value === "number") {
+        return escapeHtml(String(value));
+      }
+      if (Array.isArray(value)) {
+        return value.map((v) => escapeHtml(String(v))).join("");
+      }
+      throw new Error(
+        "[intor] HTML renderer cannot render raw non-primitive values."
+      );
+    }
+  };
 };
 
 export { createHtmlRenderer };

package/dist/core/src/core/render/utils/escape-html.js

@@ -1,10 +1,5 @@
 function escapeHtml(value) {
-    return value
-        .replaceAll("&", "&")
-        .replaceAll("<", "&lt;")
-        .replaceAll(">", "&gt;")
-        .replaceAll('"', "&quot;")
-        .replaceAll("'", "&#39;");
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
 }
 
 export { escapeHtml };

package/dist/core/src/core/render/utils/render-attributes.js

@@ -1,17 +1,12 @@
 import { escapeHtml } from './escape-html.js';
 
 function renderAttributes(attributes) {
-    if (!attributes)
-        return "";
-    return Object.entries(attributes)
-        .map(([key, value]) => {
-        if (value === true)
-            return ` ${key}`;
-        if (value == null)
-            return "";
-        return ` ${key}="${escapeHtml(String(value))}"`;
-    })
-        .join("");
+  if (!attributes) return "";
+  return Object.entries(attributes).map(([key, value]) => {
+    if (value === true) return ` ${key}`;
+    if (value == null) return "";
+    return ` ${key}="${escapeHtml(String(value))}"`;
+  }).join("");
 }
 
 export { renderAttributes };

package/dist/core/src/core/translator/create-t-rich.js

@@ -1,22 +1,13 @@
 import { renderRichMessage } from 'intor-translator';
 import { createHtmlRenderer } from '../render/create-html-renderer.js';
 
-/**
- * Create an HTML-string rich translation function.
- *
- * - Resolves translated messages via `translator.t`
- * - Renders semantic rich tags into escaped HTML strings
- * - Supports optional scoped keys via `preKey`
- *
- * Can be used in any HTML-based environment (Astro, Svelte, SSR, etc.).
- */
 const createTRich = (t) => {
-    return (key, tagRenderers, replacements) => {
-        const message = t(key, replacements);
-        const renderer = createHtmlRenderer(tagRenderers);
-        const nodes = renderRichMessage(message, renderer);
-        return nodes.join("");
-    };
+  return (key, tagRenderers, replacements) => {
+    const message = t(key, replacements);
+    const renderer = createHtmlRenderer(tagRenderers);
+    const nodes = renderRichMessage(message, renderer);
+    return nodes.join("");
+  };
 };
 
 export { createTRich };

package/dist/core/src/core/translator/create-translator.js

@@ -1,30 +1,23 @@
 import { Translator } from 'intor-translator';
 import { mergeMessages } from '../messages/merge-messages.js';
 
-/**
- * Create a server-side Translator instance for a fixed locale.
- *
- * - Merges static config messages with runtime-loaded messages
- * - Initializes a Translator bound to a specific locale
- * - Injects fallback rules, handlers, and plugins from config
- */
 function createTranslator(params) {
-    const { config, locale, messages, handlers, plugins } = params;
-    // Merge static config messages with runtime-loaded messages
-    const finalMessages = mergeMessages(config.messages, messages, {
-        config,
-        locale,
-    });
-    const translator = new Translator({
-        locale,
-        messages: finalMessages,
-        fallbackLocales: config.fallbackLocales,
-        loadingMessage: config.translator?.loadingMessage,
-        missingMessage: config.translator?.missingMessage,
-        handlers,
-        plugins,
-    });
-    return translator;
+  const { config, locale, messages, handlers, hooks } = params;
+  const finalMessages = mergeMessages(config.messages, messages, {
+    config,
+    locale
+  });
+  const { loadingMessage, missingMessage } = config.translator ?? {};
+  const translator = new Translator({
+    locale,
+    messages: finalMessages,
+    fallbackLocales: config.fallbackLocales,
+    ...loadingMessage !== void 0 ? { loadingMessage } : {},
+    ...missingMessage !== void 0 ? { missingMessage } : {},
+    ...handlers !== void 0 ? { handlers } : {},
+    ...hooks !== void 0 ? { hooks } : {}
+  });
+  return translator;
 }
 
 export { createTranslator };

package/dist/core/src/core/utils/deep-merge.js

@@ -1,47 +1,29 @@
-/**
- * Deeply merges two plain objects.
- *
- * - Nested plain objects → merged recursively
- * - Arrays / primitives → `b` overwrites `a`
- *
- * Debug behavior (optional):
- * - Emits override events via `onOverride`
- * - Zero overhead when no options are provided
- *
- * This function always returns a new plain object.
- */
 const deepMerge = (a = {}, b = {}, options) => {
-    const result = { ...a };
-    const basePath = options?._path ?? [];
-    // Iterate only over b's own enumerable properties
-    for (const key in b) {
-        if (!Object.prototype.hasOwnProperty.call(b, key))
-            continue;
-        const aValue = a[key];
-        const bValue = b[key];
-        const nextPath = [...basePath, key];
-        // Recursively merge when both sides are plain objects
-        if (aValue &&
-            bValue &&
-            typeof aValue === "object" &&
-            typeof bValue === "object" &&
-            !Array.isArray(aValue) &&
-            !Array.isArray(bValue)) {
-            result[key] = deepMerge(aValue, bValue, options ? { ...options, _path: nextPath } : undefined);
-        }
-        else {
-            // Emit override event only when debugging is enabled
-            const isAdd = aValue === undefined;
-            options?.onOverride?.({
-                path: nextPath.join("."),
-                prev: aValue,
-                next: bValue,
-                kind: isAdd ? "add" : "override",
-            });
-            result[key] = bValue;
-        }
+  const result = { ...a };
+  const basePath = options?._path ?? [];
+  for (const key in b) {
+    if (!Object.prototype.hasOwnProperty.call(b, key)) continue;
+    const aValue = a[key];
+    const bValue = b[key];
+    const nextPath = [...basePath, key];
+    if (aValue && bValue && typeof aValue === "object" && typeof bValue === "object" && !Array.isArray(aValue) && !Array.isArray(bValue)) {
+      result[key] = deepMerge(
+        aValue,
+        bValue,
+        options ? { ...options, _path: nextPath } : void 0
+      );
+    } else {
+      const isAdd = aValue === void 0;
+      options?.onOverride?.({
+        path: nextPath.join("."),
+        prev: aValue,
+        next: bValue,
+        kind: isAdd ? "add" : "override"
+      });
+      result[key] = bValue;
     }
-    return result;
+  }
+  return result;
 };
 
 export { deepMerge };

package/dist/core/src/core/utils/normalizers/normalize-cache-key.js

@@ -1,45 +1,19 @@
 const CACHE_KEY_DELIMITER = "|";
-const sanitize = (k) => k
-    .replaceAll(/[\u200B-\u200D\uFEFF]/g, "")
-    .replaceAll(/[\r\n]/g, "")
-    .trim();
-/**
- * Normalizes a value into a stable cache key string.
- *
- * - Supports primitive values and structured array keys.
- * - Produces deterministic output suitable for cache identifiers.
- *
- * Notes:
- * - `null`, `undefined`, or empty arrays return `null`.
- * - Special tokens are used for boolean, null, and undefined values
- *   to preserve semantic differences.
- */
+const sanitize = (k) => k.replaceAll(/[\u200B-\u200D\uFEFF]/g, "").replaceAll(/[\r\n]/g, "").trim();
 const normalizeCacheKey = (key, delimiter = CACHE_KEY_DELIMITER) => {
-    // Treat nullish values as "no cache key"
-    if (key === null || key === undefined)
-        return null;
-    if (Array.isArray(key)) {
-        // Empty array produces no meaningful cache key
-        if (key.length === 0)
-            return null;
-        const normalized = key.map((k) => {
-            // Preserve semantic differences for special values
-            if (k === null)
-                return "__null";
-            if (k === undefined)
-                return "__undefined";
-            if (typeof k === "boolean")
-                return k ? "__true" : "__false";
-            return sanitize(String(k));
-        });
-        // Join segments into a single deterministic cache key
-        return normalized.join(delimiter);
-    }
-    // Normalize boolean primitives explicitly
-    if (typeof key === "boolean")
-        return key ? "__true" : "__false";
-    // Fallback: stringify primitive values
-    return String(key);
+  if (key === null || key === void 0) return null;
+  if (Array.isArray(key)) {
+    if (key.length === 0) return null;
+    const normalized = key.map((k) => {
+      if (k === null) return "__null";
+      if (k === void 0) return "__undefined";
+      if (typeof k === "boolean") return k ? "__true" : "__false";
+      return sanitize(String(k));
+    });
+    return normalized.join(delimiter);
+  }
+  if (typeof key === "boolean") return key ? "__true" : "__false";
+  return String(key);
 };
 
 export { normalizeCacheKey };

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

package/dist/core/src/core/utils/parse-cookie-header.js

@@ -1,22 +1,15 @@
-/**
- * Parse a raw HTTP Cookie header into a key-value record.
- */
 function parseCookieHeader(cookieHeader) {
-    if (!cookieHeader)
-        return {};
-    const record = {};
-    // Split the Cookie header into individual key-value pairs
-    const pairs = cookieHeader.split(";");
-    for (const pair of pairs) {
-        // Locate the first "=" to separate key and value
-        const index = pair.indexOf("=");
-        if (index === -1)
-            continue;
-        const key = pair.slice(0, index).trim();
-        const value = pair.slice(index + 1).trim();
-        record[key] = decodeURIComponent(value);
-    }
-    return record;
+  if (!cookieHeader) return {};
+  const record = {};
+  const pairs = cookieHeader.split(";");
+  for (const pair of pairs) {
+    const index = pair.indexOf("=");
+    if (index === -1) continue;
+    const key = pair.slice(0, index).trim();
+    const value = pair.slice(index + 1).trim();
+    record[key] = decodeURIComponent(value);
+  }
+  return record;
 }
 
 export { parseCookieHeader };

package/dist/core/src/core/utils/resolve-loader-options.js

@@ -1,38 +1,12 @@
-/**
- * Resolve the effective message loader for a given runtime.
- *
- * Loader resolution follows an inheritance-based priority model:
- *
- * - client runtime:
- *   client.loader → server.loader → root loader
- *
- * - server runtime:
- *   server.loader → root loader
- *
- * This allows the client runtime to inherit server behavior
- * when no explicit client loader is provided.
- *
- * Notes:
- * - Static `messages` are intentionally NOT handled here.
- * - Returning `undefined` indicates that no loader is enabled
- *   for the given runtime.
- */
 const resolveLoaderOptions = (config, runtime) => {
-    // ------------------------------------------------
-    // runtime: client
-    // ------------------------------------------------
-    if (runtime === "client") {
-        const client = config.client?.loader;
-        if (client) {
-            // Client loader is always remote by design
-            return { mode: "remote", ...client };
-        }
-        return config.server?.loader ?? config.loader;
+  if (runtime === "client") {
+    const client = config.client?.loader;
+    if (client) {
+      return { mode: "remote", ...client };
     }
-    // ------------------------------------------------
-    // runtime: server
-    // ------------------------------------------------
     return config.server?.loader ?? config.loader;
+  }
+  return config.server?.loader ?? config.loader;
 };
 
 export { resolveLoaderOptions };

package/dist/core/src/edge/helpers/get-translator.js

@@ -1,29 +1,24 @@
-import '../../core/error/intor-error.js';
 import 'logry';
 import 'p-limit';
 import 'intor-translator';
 import { createTRich } from '../../core/translator/create-t-rich.js';
 import { initTranslator } from '../translator/init-translator.js';
 
-/**
- * Get a edge-runtime translator for the current execution context.
- */
 async function getTranslator(config, params) {
-    const { locale, fetch, preKey, handlers, plugins } = params;
-    // Initialize a locale-bound translator snapshot with messages loaded
-    const translator = await initTranslator(config, locale, {
-        fetch: fetch || globalThis.fetch,
-        plugins,
-        handlers,
-    });
-    const scoped = translator.scoped(preKey);
-    return {
-        messages: translator.messages,
-        locale: translator.locale,
-        hasKey: scoped.hasKey,
-        t: scoped.t,
-        tRich: createTRich(scoped.t),
-    };
+  const { locale, fetch = globalThis.fetch, preKey, handlers, hooks } = params;
+  const translator = await initTranslator(config, locale, {
+    fetch,
+    ...handlers !== void 0 ? { handlers } : {},
+    ...hooks !== void 0 ? { hooks } : {}
+  });
+  const scoped = translator.scoped(preKey);
+  return {
+    messages: translator.messages,
+    locale: translator.locale,
+    hasKey: scoped.hasKey,
+    t: scoped.t,
+    tRich: createTRich(scoped.t)
+  };
 }
 
 export { getTranslator };

package/dist/core/src/edge/translator/init-translator.js

@@ -1,35 +1,33 @@
-import '../../core/error/intor-error.js';
 import 'logry';
 import { loadRemoteMessages } from '../../core/messages/load-remote-messages/load-remote-messages.js';
 import { createTranslator } from '../../core/translator/create-translator.js';
 import 'intor-translator';
 
-/**
- * Initialize a locale-bound Translator snapshot.
- *
- * - Loads translation messages using the configured remote loader, if present.
- * - Creates an immutable Translator instance for edge runtimes
- */
 async function initTranslator(config, locale, options) {
-    const { loader } = config;
-    const { fetch, handlers, plugins } = options;
-    // Load messages
-    let messages = {};
-    if (loader && loader.mode === "remote") {
-        const loaded = await loadRemoteMessages({
-            locale,
-            fallbackLocales: config.fallbackLocales[locale] || [],
-            namespaces: loader.namespaces,
-            concurrency: loader.concurrency,
-            fetch,
-            url: loader.url,
-            headers: loader.headers,
-            loggerOptions: config.logger,
-        });
-        messages = loaded || {};
-    }
-    // Create immutable translator snapshot
-    return createTranslator({ config, locale, messages, handlers, plugins });
+  const { loader } = config;
+  const { fetch, handlers, hooks } = options;
+  let messages = {};
+  if (loader && loader.mode === "remote") {
+    const { namespaces, concurrency, url, headers } = loader;
+    const loaded = await loadRemoteMessages({
+      locale,
+      fallbackLocales: config.fallbackLocales[locale] || [],
+      ...namespaces !== void 0 ? { namespaces } : {},
+      ...concurrency !== void 0 ? { concurrency } : {},
+      fetch,
+      url,
+      ...headers !== void 0 ? { headers } : {},
+      loggerOptions: config.logger
+    });
+    messages = loaded || {};
+  }
+  return createTranslator({
+    config,
+    locale,
+    messages,
+    ...handlers !== void 0 ? { handlers } : {},
+    ...hooks !== void 0 ? { hooks } : {}
+  });
 }
 
 export { initTranslator };