intor 2.5.0 → 2.6.0

package/dist/core/src/core/locale/match-locale.js

@@ -1,61 +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 one of the original `supportedLocales` values if matched.
- * Returns `undefined` if no match is found.
- *
- * Notes:
- * - Matching is deterministic and order-sensitive.
- * - Does not perform automatic fallback to a default locale.
- *   Consumers are responsible for applying fallback logic.
- * - If the candidate includes a script subtag, language-only fallback is skipped.
- *
- * @public
- */
 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/core/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,
-                ...(locale.script !== undefined ? { script: locale.script } : {}),
-                ...(locale.region !== undefined ? { 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/core/src/core/logger/get-logger.js

@@ -2,41 +2,36 @@ import { logry } from 'logry';
 import { getGlobalLoggerPool } from './global-logger-pool.js';
 
 const DEFAULT_FORMAT_CONFIG = {
-    timestamp: { withDate: false },
+  timestamp: { withDate: false }
 };
 const DEFAULT_RENDER_CONFIG = {
-    id: { visible: true, prefix: "<", suffix: ">" },
-    meta: { lineBreaksAfter: 1 },
+  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", preset, ...options }) {
-    const pool = getGlobalLoggerPool();
-    const existing = pool.get(id);
-    if (existing)
-        return existing;
-    const baseConfig = preset === undefined
-        ? {
-            formatConfig: DEFAULT_FORMAT_CONFIG,
-            renderConfig: DEFAULT_RENDER_CONFIG,
-        }
-        : { preset };
-    const logger = logry({
-        id,
-        ...baseConfig,
-        ...options,
-    });
-    pool.set(id, logger);
-    // Soft LRU: keep pool size under control
-    if (pool.size > 1000) {
-        for (const key of [...pool.keys()].slice(0, 200)) {
-            pool.delete(key);
-        }
+function getLogger({
+  id = "default",
+  preset,
+  ...options
+}) {
+  const pool = getGlobalLoggerPool();
+  const existing = pool.get(id);
+  if (existing) return existing;
+  const baseConfig = preset === void 0 ? {
+    formatConfig: DEFAULT_FORMAT_CONFIG,
+    renderConfig: DEFAULT_RENDER_CONFIG
+  } : { preset };
+  const logger = logry({
+    id,
+    ...baseConfig,
+    ...options
+  });
+  pool.set(id, logger);
+  if (pool.size > 1e3) {
+    for (const key of [...pool.keys()].slice(0, 200)) {
+      pool.delete(key);
     }
-    return logger;
+  }
+  return logger;
 }
 
 export { getLogger };

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

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

package/dist/core/src/core/messages/internal-metadata.js

@@ -1,7 +1,7 @@
 const INTOR_PREFIX = "__intor_";
 const INTOR_MESSAGES_KIND_KEY = `${INTOR_PREFIX}kind`;
 const INTOR_MESSAGES_KIND = {
-    markdown: "markdown",
+  markdown: "markdown"
 };
 
 export { INTOR_MESSAGES_KIND, INTOR_MESSAGES_KIND_KEY, INTOR_PREFIX };

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

@@ -1,25 +1,16 @@
-/**
- * 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];
+function collectRemoteResources({
+  locale,
+  baseUrl,
+  namespaces
+}) {
+  const basePath = `${baseUrl}/${locale}`;
+  const indexResource = { url: `${basePath}/index.json`, path: [] };
+  if (!namespaces || namespaces.length === 0) return [indexResource];
+  const nsResources = namespaces.map((ns) => ({
+    url: `${basePath}/${ns}.json`,
+    path: [ns]
+  }));
+  return [indexResource, ...nsResources];
 }
 
 export { collectRemoteResources };

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

@@ -1,47 +1,38 @@
 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 !== undefined ? { 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;
+async function fetchRemoteResource({
+  fetch,
+  url,
+  headers,
+  signal,
+  loggerOptions
+}) {
+  const baseLogger = getLogger(loggerOptions);
+  const logger = baseLogger.child({ scope: "fetch-locale-messages" });
+  try {
+    const response = await fetch(url, {
+      method: "GET",
+      headers: { "Content-Type": "application/json", ...headers },
+      cache: "no-store",
+      ...signal !== void 0 ? { signal } : {}
+    });
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status} ${response.statusText}`);
     }
-    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;
+    const data = await response.json();
+    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/core/src/core/messages/load-remote-messages/load-remote-messages.js

@@ -4,98 +4,81 @@ 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.");
+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" });
+  if (signal?.aborted) {
+    logger.debug("Remote message loading aborted before fetch.");
+    return;
+  }
+  const start = performance.now();
+  logger.debug("Loading remote messages.", { baseUrl });
+  const limit = concurrency ? pLimit(concurrency) : void 0;
+  const candidateLocales = [locale, ...fallbackLocales || []];
+  let messages;
+  for (const candidateLocale of candidateLocales) {
+    const isLast = candidateLocale === candidateLocales[candidateLocales.length - 1];
+    try {
+      const resources = collectRemoteResources({
+        locale: candidateLocale,
+        baseUrl,
+        ...namespaces !== void 0 ? { namespaces } : {}
+      });
+      const fetchUrl = (url) => fetchRemoteResource({
+        url,
+        ...headers !== void 0 ? { headers } : {},
+        ...signal !== void 0 ? { signal } : {},
+        loggerOptions,
+        fetch
+      });
+      const results = await Promise.all(
+        resources.map(
+          ({ url }) => limit ? limit(() => fetchUrl(url)) : fetchUrl(url)
+        )
+      );
+      if (!results.some(Boolean)) continue;
+      const resolved = resolveRemoteResources(
+        resources.map((res, i) => {
+          const data = results[i];
+          return { path: res.path, ...data !== void 0 ? { data } : {} };
+        })
+      );
+      messages = { [candidateLocale]: resolved };
+      break;
+    } catch {
+      if (signal?.aborted) {
+        logger.debug("Remote message loading aborted.");
         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 (const candidateLocale of candidateLocales) {
-        const isLast = candidateLocale === candidateLocales[candidateLocales.length - 1];
-        try {
-            // -----------------------------------------------------------------
-            // Collect remote message resources for the locale
-            // -----------------------------------------------------------------
-            const resources = collectRemoteResources({
-                locale: candidateLocale,
-                baseUrl,
-                ...(namespaces !== undefined ? { namespaces } : {}),
-            });
-            // -----------------------------------------------------------------
-            // Fetch all message chunks in parallel
-            // -----------------------------------------------------------------
-            const fetchUrl = (url) => fetchRemoteResource({
-                url,
-                ...(headers !== undefined ? { headers } : {}),
-                ...(signal !== undefined ? { 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) => {
-                const data = results[i];
-                return { path: res.path, ...(data !== undefined ? { data } : {}) };
-            }));
-            // -----------------------------------------------------------------
-            // 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`,
+      }
+      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.`
+        );
+      }
     }
-    return messages;
+  }
+  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/core/src/core/messages/load-remote-messages/resolve-remote-resources.js

@@ -1,24 +1,14 @@
 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;
+  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/core/src/core/messages/merge-messages.js

@@ -1,35 +1,24 @@
 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
- *
- * @public
- */
 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,
-    };
+  const baseLogger = getLogger({ ...config.logger, id: config.id });
+  const logger = baseLogger.child({ scope: "merge-messages" });
+  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 });
+    }
+  });
+  return {
+    ...a,
+    [locale]: merged
+  };
 }
 
 export { mergeMessages };

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

@@ -1,44 +1,29 @@
-/** Check if a value is a plain object (not null, not array) */
 function isPlainObject(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(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;
+  if (!isPlainObject(value)) return false;
+  const stack = [value];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (current === null || typeof current === "string" || typeof current === "number" || typeof current === "boolean") {
+      continue;
     }
-    return true;
+    if (Array.isArray(current)) {
+      for (const item of current) {
+        stack.push(item);
+      }
+      continue;
+    }
+    if (isPlainObject(current)) {
+      for (const v of Object.values(current)) {
+        stack.push(v);
+      }
+      continue;
+    }
+    return false;
+  }
+  return true;
 }
 
 export { isPlainObject, isValidMessages };