intor 2.3.35 → 2.4.0

package/dist/hono/src/core/logger/get-logger.js

@@ -0,0 +1,39 @@
+import { logry } from 'logry';
+import { getGlobalLoggerPool } from './global-logger-pool.js';
+
+const DEFAULT_FORMAT_CONFIG = {
+    timestamp: { withDate: false },
+};
+const DEFAULT_RENDER_CONFIG = {
+    timestamp: {},
+    id: { visible: true, prefix: "<", suffix: ">" },
+    meta: { lineBreaksAfter: 1 },
+};
+/**
+ * Get a shared logger instance by id.
+ * - Safe across hot reloads
+ * - Prevents unbounded memory usage via soft LRU
+ */
+function getLogger({ id = "default", formatConfig, renderConfig, preset, ...options }) {
+    const pool = getGlobalLoggerPool();
+    let logger = pool.get(id);
+    if (!logger) {
+        logger = logry({
+            id,
+            formatConfig: !formatConfig && !preset ? DEFAULT_FORMAT_CONFIG : formatConfig,
+            renderConfig: !renderConfig && !preset ? DEFAULT_RENDER_CONFIG : renderConfig,
+            preset,
+            ...options,
+        });
+        pool.set(id, logger);
+        // Soft LRU: keep pool size under control
+        if (pool.size > 1000) {
+            const keys = [...pool.keys()];
+            for (const key of keys.slice(0, 200))
+                pool.delete(key);
+        }
+    }
+    return logger;
+}
+
+export { getLogger };

package/dist/hono/src/core/logger/global-logger-pool.js

@@ -0,0 +1,8 @@
+function getGlobalLoggerPool() {
+    if (!globalThis.__INTOR_LOGGER_POOL__) {
+        globalThis.__INTOR_LOGGER_POOL__ = new Map();
+    }
+    return globalThis.__INTOR_LOGGER_POOL__;
+}
+
+export { getGlobalLoggerPool };

package/dist/hono/src/core/messages/load-remote-messages/collect-remote-resources.js

@@ -0,0 +1,25 @@
+/**
+ * Collect remote message resources for a given locale.
+ *
+ * - Always includes the root `index.json`
+ * - Optionally includes namespace-specific resources
+ * - Produces semantic paths for later message nesting
+ *
+ * This function performs no I/O and does not validate resource existence.
+ */
+function collectRemoteResources({ locale, baseUrl, namespaces, }) {
+    const basePath = `${baseUrl}/${locale}`;
+    // Root translation resource (always loaded)
+    const indexResource = { url: `${basePath}/index.json`, path: [] };
+    // When no namespaces are provided, the locale domain consists of index only
+    if (!namespaces || namespaces.length === 0)
+        return [indexResource];
+    // Namespace-specific resources are nested under their namespace key
+    const nsResources = namespaces.map((ns) => ({
+        url: `${basePath}/${ns}.json`,
+        path: [ns],
+    }));
+    return [indexResource, ...nsResources];
+}
+
+export { collectRemoteResources };

package/dist/hono/src/core/messages/load-remote-messages/fetch-remote-resource.js

@@ -0,0 +1,47 @@
+import { getLogger } from '../../logger/get-logger.js';
+import { isValidMessages } from '../utils/is-valid-messages.js';
+
+/**
+ * Fetch a single remote messages resource.
+ *
+ * This function performs a single HTTP request to retrieve
+ * a remote translation messages payload.
+ *
+ * It is responsible for:
+ * - Issuing the network request
+ * - Validating the returned message structure
+ * - Handling abort and network errors
+ */
+async function fetchRemoteResource({ fetch, url, headers, signal, loggerOptions, }) {
+    const baseLogger = getLogger(loggerOptions);
+    const logger = baseLogger.child({ scope: "fetch-locale-messages" });
+    try {
+        // Fetch
+        const response = await fetch(url, {
+            method: "GET",
+            headers: { "Content-Type": "application/json", ...headers },
+            cache: "no-store",
+            signal,
+        });
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status} ${response.statusText}`);
+        }
+        // Parse JSON body
+        const data = await response.json();
+        // Validate messages structure
+        if (!isValidMessages(data)) {
+            throw new Error("Invalid messages structure");
+        }
+        return data;
+    }
+    catch (error) {
+        if (error instanceof Error && error.name === "AbortError") {
+            logger.debug("Remote fetch aborted.", { url });
+            return;
+        }
+        logger.warn("Failed to fetch remote messages.", { url, error });
+        return;
+    }
+}
+
+export { fetchRemoteResource };

package/dist/hono/src/core/messages/load-remote-messages/load-remote-messages.js

@@ -0,0 +1,93 @@
+import pLimit from 'p-limit';
+import { getLogger } from '../../logger/get-logger.js';
+import { collectRemoteResources } from './collect-remote-resources.js';
+import { fetchRemoteResource } from './fetch-remote-resource.js';
+import { resolveRemoteResources } from './resolve-remote-resources.js';
+
+/**
+ * Load locale messages from a remote source.
+ *
+ * This function serves as the orchestration layer for remote message loading.
+ * It coordinates:
+ *
+ * - Locale resolution with fallbacks
+ * - Concurrency control for network requests
+ * - Remote resource fetching and message merging
+ *
+ * Remote messages are fetched on demand and are not memoized at the process level.
+ *
+ * Network requests and response validation are delegated to lower-level utilities.
+ */
+const loadRemoteMessages = async ({ locale, fallbackLocales, namespaces, concurrency, fetch, url: baseUrl, headers, signal, loggerOptions, }) => {
+    const baseLogger = getLogger(loggerOptions);
+    const logger = baseLogger.child({ scope: "load-remote-messages" });
+    // Abort early if the request has already been cancelled
+    if (signal?.aborted) {
+        logger.debug("Remote message loading aborted before fetch.");
+        return;
+    }
+    const start = performance.now();
+    logger.debug("Loading remote messages.", { baseUrl });
+    // ----------------------------------------------------------------
+    // Resolve locale messages with ordered fallback strategy
+    // ----------------------------------------------------------------
+    const limit = concurrency ? pLimit(concurrency) : undefined;
+    const candidateLocales = [locale, ...(fallbackLocales || [])];
+    let messages;
+    for (let i = 0; i < candidateLocales.length; i++) {
+        const candidateLocale = candidateLocales[i];
+        const isLast = i === candidateLocales.length - 1;
+        try {
+            // -----------------------------------------------------------------
+            // Collect remote message resources for the locale
+            // -----------------------------------------------------------------
+            const resources = collectRemoteResources({
+                locale: candidateLocale,
+                baseUrl,
+                namespaces,
+            });
+            // -----------------------------------------------------------------
+            // Fetch all message chunks in parallel
+            // -----------------------------------------------------------------
+            const fetchUrl = (url) => fetchRemoteResource({ url, headers, signal, loggerOptions, fetch });
+            const results = await Promise.all(resources.map(({ url }) => limit ? limit(() => fetchUrl(url)) : fetchUrl(url)));
+            // Guard: no valid remote resources
+            if (!results.some(Boolean))
+                continue;
+            // -----------------------------------------------------------------
+            // Resolve and merge remote message resources
+            // -----------------------------------------------------------------
+            const resolved = resolveRemoteResources(resources.map((res, i) => ({ path: res.path, data: results[i] })));
+            // -----------------------------------------------------------------
+            // Wrap resolved messages into locale-scoped LocaleMessages
+            // -----------------------------------------------------------------
+            messages = { [candidateLocale]: resolved };
+            break;
+        }
+        catch {
+            if (signal?.aborted) {
+                logger.debug("Remote message loading aborted.");
+                return;
+            }
+            if (isLast) {
+                logger.warn("Failed to load messages for all candidate locales.", {
+                    locale,
+                    fallbackLocales,
+                });
+            }
+            else {
+                logger.warn(`Failed to load locale messages for "${candidateLocale}", trying next fallback.`);
+            }
+        }
+    }
+    // Final success log with resolved locale and timing
+    if (messages) {
+        logger.trace("Finished loading remote messages.", {
+            loadedLocale: Object.keys(messages)[0],
+            duration: `${Math.round(performance.now() - start)} ms`,
+        });
+    }
+    return messages;
+};
+
+export { loadRemoteMessages };

package/dist/hono/src/core/messages/load-remote-messages/resolve-remote-resources.js

@@ -0,0 +1,24 @@
+import { deepMerge } from '../../utils/deep-merge.js';
+import { nestObjectFromPath } from '../utils/nest-object-from-path.js';
+
+/**
+ * Resolve remote message resources into a single MessageObject.
+ *
+ * - Applies semantic nesting based on resource path
+ * - Merges all resolved message chunks
+ *
+ * Always returns a MessageObject.
+ * An empty object represents an empty translation domain.
+ */
+function resolveRemoteResources(resources) {
+    let result = {};
+    for (const { path, data } of resources) {
+        if (!data)
+            continue;
+        const resolved = path.length > 0 ? nestObjectFromPath(path, data) : data;
+        result = deepMerge(result, resolved);
+    }
+    return result;
+}
+
+export { resolveRemoteResources };

package/dist/hono/src/core/messages/merge-messages.js

@@ -0,0 +1,33 @@
+import { getLogger } from '../logger/get-logger.js';
+import { deepMerge } from '../utils/deep-merge.js';
+
+/**
+ * Merge locale-specific messages with runtime overrides.
+ *
+ * - Only merges messages under the given locale
+ * - Emits debug logs for add / override events
+ */
+function mergeMessages(a, b, { config, locale, onEvent }) {
+    const baseLogger = getLogger({ ...config.logger, id: config.id });
+    const logger = baseLogger.child({ scope: "merge-messages" });
+    // Merge messages for the active locale only
+    const merged = deepMerge(a?.[locale] ?? {}, b?.[locale] ?? {}, {
+        onOverride: (event) => {
+            if (onEvent) {
+                onEvent(event);
+                return;
+            }
+            const { kind, path, next, prev } = event;
+            if (kind === "add")
+                return;
+            logger.debug(`Override | ${locale}: "${path}"`, { prev, next });
+        },
+    });
+    // Preserve other locales, update only the target one
+    return {
+        ...a,
+        [locale]: merged,
+    };
+}
+
+export { mergeMessages };

package/dist/hono/src/core/messages/utils/is-valid-messages.js

@@ -0,0 +1,44 @@
+/** Check if a value is a plain object (not null, not array) */
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+ * Check if a value is a valid MessageObject.
+ *
+ * - Supports all MessageValue variants (primitive, array, object).
+ * - Uses an iterative approach to avoid stack overflow.
+ */
+function isValidMessages(value) {
+    if (!isPlainObject(value))
+        return false;
+    const stack = [value];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        // primitives are always valid
+        if (current === null ||
+            typeof current === "string" ||
+            typeof current === "number" ||
+            typeof current === "boolean") {
+            continue;
+        }
+        // array → validate each item
+        if (Array.isArray(current)) {
+            for (const item of current) {
+                stack.push(item);
+            }
+            continue;
+        }
+        // object → validate each value
+        if (isPlainObject(current)) {
+            for (const v of Object.values(current)) {
+                stack.push(v);
+            }
+            continue;
+        }
+        // everything else is invalid
+        return false;
+    }
+    return true;
+}
+
+export { isPlainObject, isValidMessages };

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

@@ -0,0 +1,21 @@
+/**
+ * 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;
+}
+
+export { nestObjectFromPath };

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

@@ -0,0 +1,44 @@
+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.");
+        },
+    };
+};
+
+export { createHtmlRenderer };

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

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

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

@@ -0,0 +1,17 @@
+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("");
+}
+
+export { renderAttributes };

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

@@ -0,0 +1,22 @@
+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("");
+    };
+};
+
+export { createTRich };

package/dist/{next/src/server → hono/src/core}/translator/create-translator.js

@@ -1,5 +1,5 @@
 import { Translator } from 'intor-translator';
-import { mergeMessages } from '../../core/messages/merge-messages.js';
+import { mergeMessages } from '../messages/merge-messages.js';
 
 /**
  * Create a server-side Translator instance for a fixed locale.

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

@@ -0,0 +1,47 @@
+/**
+ * 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;
+        }
+    }
+    return result;
+};
+
+export { deepMerge };

package/dist/hono/src/core/utils/normalizers/normalize-locale.js

@@ -0,0 +1,59 @@
+const toCanonical = (input) => {
+    try {
+        return Intl.getCanonicalLocales(input)[0];
+    }
+    catch {
+        return;
+    }
+};
+/**
+ * Normalizes a locale string and resolves the best match
+ * from a list of supported locales.
+ *
+ * Resolution strategy:
+ *
+ * 1. Exact canonical match (BCP 47)
+ * 2. Base language fallback
+ *    - Falls back by base language when no exact match is found
+ *      (e.g. `"en"` → `"en-US"`).
+ *    - Script and region subtags are ignored during this step
+ *      (e.g. `"zh-Hans"` → `"zh-Hant-TW"`)
+ *    - Preference is determined by the order of `supportedLocales`.
+ *
+ * Returns `undefined` if no suitable match is found.
+ *
+ * Notes:
+ * - Invalid locale inputs are ignored gracefully.
+ * - Always returns an original entry from `supportedLocales`.
+ * - Requires `Intl` locale support in the runtime.
+ */
+const normalizeLocale = (locale, supportedLocales = []) => {
+    if (!locale || supportedLocales.length === 0)
+        return;
+    const canonicalLocale = toCanonical(locale);
+    if (!canonicalLocale)
+        return;
+    const supportedCanonicalMap = new Map();
+    for (const l of supportedLocales) {
+        const normalized = toCanonical(l);
+        if (normalized) {
+            supportedCanonicalMap.set(normalized, l);
+        }
+    }
+    // 1. Exact match
+    if (supportedCanonicalMap.has(canonicalLocale)) {
+        return supportedCanonicalMap.get(canonicalLocale);
+    }
+    const baseLang = canonicalLocale.split("-")[0];
+    // 2. Match by same base language (e.g., "en" matches "en-US" or "en-GB")
+    for (const [key, original] of supportedCanonicalMap) {
+        const supportedBase = key.split("-")[0];
+        if (supportedBase === baseLang) {
+            return original;
+        }
+    }
+    // 3. No match
+    return;
+};
+
+export { normalizeLocale };

package/dist/hono/src/core/utils/normalizers/normalize-pathname.js

@@ -0,0 +1,43 @@
+/**
+ * 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;
+        }
+    }
+    // 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 || "/";
+};
+
+export { normalizePathname };

package/dist/hono/src/core/utils/normalizers/normalize-query.js

@@ -0,0 +1,25 @@
+/**
+ * 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;
+        }
+    }
+    return normalized;
+}
+
+export { normalizeQuery };

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

@@ -0,0 +1,22 @@
+/**
+ * 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;
+}
+
+export { parseCookieHeader };