intor 2.4.17 → 2.5.1

package/dist/react/src/client/react/translator/create-t-rich.js

@@ -1,26 +1,17 @@
-import { jsx, Fragment } from 'react/jsx-runtime';
 import { renderRichMessage } from 'intor-translator';
+import * as React from 'react';
 import { createReactRenderer } from '../render/create-react-renderer.js';
 
-/**
- * Create a React-specific rich translation function.
- *
- * This adapter bridges the core Translator with the React rich
- * message rendering flow.
- *
- * - Resolves translated messages via `translator.t`
- * - Renders semantic tags using React renderers
- * - Supports optional scoped keys via `preKey`
- *
- * Intended for React client usage only.
- */
 const createTRich = (t) => {
-    return (key, tagRenderers, replacements) => {
-        const message = t(key, replacements);
-        const reactRenderer = createReactRenderer(tagRenderers);
-        const nodes = renderRichMessage(message, reactRenderer);
-        return nodes.map((node, index) => jsx(Fragment, { children: node }, index));
-    };
+  return (key, tagRenderers, replacements) => {
+    const message = t(key, replacements);
+    const reactRenderer = createReactRenderer(tagRenderers);
+    const nodes = renderRichMessage(message, reactRenderer);
+    if (!Array.isArray(nodes)) return nodes;
+    return nodes.map(
+      (node, i) => React.isValidElement(node) && node.key == null ? React.cloneElement(node, { key: i }) : node
+    );
+  };
 };
 
 export { createTRich };

package/dist/react/src/client/react/translator/use-translator.js

@@ -2,23 +2,18 @@ import '../provider/intor-provider.js';
 import { useIntorContext } from '../provider/use-intor-context.js';
 import { createTRich } from './create-t-rich.js';
 
-/**
- * React hook for accessing the active, scope-aware translator instance.
- *
- * @platform React
- */
 function useTranslator(preKey) {
-    const { translator, setLocale } = useIntorContext();
-    const scoped = translator.scoped(preKey);
-    return {
-        messages: translator.messages,
-        locale: translator.locale,
-        isLoading: translator.isLoading,
-        setLocale,
-        hasKey: scoped.hasKey,
-        t: scoped.t,
-        tRich: createTRich(scoped.t),
-    };
+  const { translator, setLocale } = useIntorContext();
+  const scoped = translator.scoped(preKey);
+  return {
+    messages: translator.messages,
+    locale: translator.locale,
+    isLoading: translator.isLoading,
+    setLocale,
+    hasKey: scoped.hasKey,
+    t: scoped.t,
+    tRich: createTRich(scoped.t)
+  };
 }
 
 export { useTranslator };

package/dist/react/src/client/shared/messages/create-refetch-messages.js

@@ -1,60 +1,50 @@
-import '../../../core/error/intor-error.js';
 import { resolveLoaderOptions } from '../../../core/utils/resolve-loader-options.js';
 import 'logry';
 import { loadRemoteMessages } from '../../../core/messages/load-remote-messages/load-remote-messages.js';
 import { mergeMessages } from '../../../core/messages/merge-messages.js';
 import 'intor-translator';
 
-/**
- * Creates a framework-agnostic message refetcher.
- *
- * - At most one remote request is active at any time
- * - Previous in-flight requests are aborted on subsequent calls
- * - State updates are applied only for the latest, non-aborted request
- */
-const createRefetchMessages = ({ config, onLoadingStart, onLoadingEnd, onMessages, }) => {
-    // Tracks the currently active remote request for this refetcher instance
-    let controller = null;
-    return async function refetchMessages(newLocale) {
-        // No-op when remote loading is not enabled
-        const loader = resolveLoaderOptions(config);
-        if (!loader || loader.mode !== "remote")
-            return;
-        // Abort previous request
-        controller?.abort();
-        const currentController = new AbortController();
-        controller = currentController;
-        onLoadingStart?.();
-        try {
-            const loadedMessages = await loadRemoteMessages({
-                locale: newLocale,
-                fallbackLocales: config.fallbackLocales[newLocale] || [],
-                namespaces: loader.namespaces,
-                concurrency: loader.concurrency,
-                fetch: globalThis.fetch,
-                url: loader.url,
-                headers: loader.headers,
-                signal: currentController.signal,
-                loggerOptions: config.logger,
-            });
-            // Apply state updates only when this request is still the active one
-            // and has not been aborted.
-            if (controller === currentController &&
-                !currentController.signal.aborted) {
-                onMessages?.(mergeMessages(config.messages, loadedMessages, {
-                    config,
-                    locale: newLocale,
-                }));
-            }
-        }
-        finally {
-            // Clear loading state only if this request is still the active one
-            if (controller === currentController &&
-                !currentController.signal.aborted) {
-                onLoadingEnd?.();
-            }
-        }
-    };
+const createRefetchMessages = ({
+  config,
+  onLoadingStart,
+  onLoadingEnd,
+  onMessages
+}) => {
+  let controller = null;
+  return async function refetchMessages(newLocale) {
+    const loader = resolveLoaderOptions(config);
+    if (!loader || loader.mode !== "remote") return;
+    const { namespaces, concurrency, url, headers } = loader;
+    controller?.abort();
+    const currentController = new AbortController();
+    controller = currentController;
+    onLoadingStart?.();
+    try {
+      const loadedMessages = await loadRemoteMessages({
+        locale: newLocale,
+        fallbackLocales: config.fallbackLocales[newLocale] || [],
+        ...namespaces !== void 0 ? { namespaces } : {},
+        ...concurrency !== void 0 ? { concurrency } : {},
+        fetch: globalThis.fetch,
+        url,
+        ...headers !== void 0 ? { headers } : {},
+        signal: currentController.signal,
+        loggerOptions: config.logger
+      });
+      if (controller === currentController && !currentController.signal.aborted) {
+        onMessages?.(
+          mergeMessages(config.messages, loadedMessages, {
+            config,
+            locale: newLocale
+          })
+        );
+      }
+    } finally {
+      if (controller === currentController && !currentController.signal.aborted) {
+        onLoadingEnd?.();
+      }
+    }
+  };
 };
 
 export { createRefetchMessages };

package/dist/react/src/client/shared/provider/effective-state.js

@@ -0,0 +1,8 @@
+function resolveEffectiveMessages(runtime, external, configMessages) {
+  return runtime ?? external ?? configMessages ?? {};
+}
+function resolveEffectiveIsLoading(external, internal) {
+  return !!external || internal;
+}
+
+export { resolveEffectiveIsLoading, resolveEffectiveMessages };

package/dist/react/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/react/src/client/shared/utils/locale/get-locale-from-cookie.js

@@ -1,16 +1,9 @@
-/**
- * Gets the locale value from the browser cookie.
- *
- * This function relies on `document.cookie`.
- */
 function getLocaleFromCookie(cookieName) {
-    if (typeof document === "undefined")
-        return undefined;
-    const cookies = document.cookie.split(";").map((c) => c.trim());
-    const entry = cookies.find((c) => c.startsWith(`${cookieName}=`));
-    if (!entry)
-        return undefined;
-    return decodeURIComponent(entry.slice(cookieName.length + 1));
+  if (typeof document === "undefined") return void 0;
+  const cookies = document.cookie.split(";").map((c) => c.trim());
+  const entry = cookies.find((c) => c.startsWith(`${cookieName}=`));
+  if (!entry) return void 0;
+  return decodeURIComponent(entry.slice(cookieName.length + 1));
 }
 
 export { getLocaleFromCookie };

package/dist/react/src/client/shared/utils/locale/set-document-locale.js

@@ -1,12 +1,6 @@
-/**
- * Set the document language attribute.
- *
- * This function relies on `document.documentElement.lang`.
- */
 function setDocumentLocale(locale) {
-    if (typeof document === "undefined")
-        return;
-    document.documentElement.lang = locale;
+  if (typeof document === "undefined") return;
+  document.documentElement.lang = locale;
 }
 
 export { setDocumentLocale };

package/dist/react/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/react/src/core/logger/get-logger.js

@@ -2,38 +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 = {
-    timestamp: {},
-    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", 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);
-        }
+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/react/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/react/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/react/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,
-        });
-        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/react/src/core/messages/load-remote-messages/load-remote-messages.js

@@ -4,90 +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 (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`,
+      }
+      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 };