intor 2.5.0 → 2.6.0

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

package/dist/react/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/react/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/react/src/core/utils/resolve-loader-options.js

@@ -1,34 +1,11 @@
-/**
- * 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
-    // ------------------------------------------------
-    {
-        const client = config.client?.loader;
-        if (client) {
-            // Client loader is always remote by design
-            return { mode: "remote", ...client };
-        }
-        return config.server?.loader ?? config.loader;
+  {
+    const client = config.client?.loader;
+    if (client) {
+      return { mode: "remote", ...client };
     }
+    return config.server?.loader ?? config.loader;
+  }
 };
 
 export { resolveLoaderOptions };

package/dist/react/src/policies/should-persist-on-first-visit.js

@@ -1,8 +1,5 @@
-/**
- * Allow locale persistence based on first-visit policy.
- */
 function shouldPersistOnFirstVisit(isFirstVisit, persistOnFirstVisit) {
-    return !isFirstVisit || persistOnFirstVisit;
+  return !isFirstVisit || persistOnFirstVisit;
 }
 
 export { shouldPersistOnFirstVisit };

package/dist/svelte/export/svelte/index.js

@@ -3,12 +3,6 @@ import IntorProviderComponent from '../../src/client/svelte/provider/intor-provi
 import 'svelte';
 export { useTranslator } from '../../src/client/svelte/translator/use-translator.js';
 
-// intor / svelte
-/**
- * Svelte provider component for Intor.
- *
- * @public
- */
 const IntorProvider = IntorProviderComponent;
 
 export { IntorProvider };

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

@@ -4,57 +4,47 @@ import { loadRemoteMessages } from '../../../core/messages/load-remote-messages/
 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;
-        const { namespaces, concurrency, url, headers } = loader;
-        // Abort previous request
-        controller?.abort();
-        const currentController = new AbortController();
-        controller = currentController;
-        onLoadingStart?.();
-        try {
-            const loadedMessages = await loadRemoteMessages({
-                locale: newLocale,
-                fallbackLocales: config.fallbackLocales[newLocale] || [],
-                ...(namespaces !== undefined ? { namespaces } : {}),
-                ...(concurrency !== undefined ? { concurrency } : {}),
-                fetch: globalThis.fetch,
-                url,
-                ...(headers !== undefined ? { 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/svelte/src/client/shared/provider/effective-state.js

@@ -1,12 +1,8 @@
-// runtime > external > config
-// Always resolves to a non-null message object.
 function resolveEffectiveMessages(runtime, external, configMessages) {
-    return runtime ?? external ?? configMessages ?? {};
+  return runtime ?? external ?? configMessages ?? {};
 }
-// external > internal
-// Loading is active if either source is truthy
 function resolveEffectiveIsLoading(external, internal) {
-    return !!external || internal;
+  return !!external || internal;
 }
 
 export { resolveEffectiveIsLoading, resolveEffectiveMessages };

package/dist/svelte/src/client/shared/utils/build-cookie-string.js

@@ -1,31 +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 !== undefined) {
-        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) {
-        const normalized = sameSite.charAt(0).toUpperCase() + sameSite.slice(1).toLowerCase();
-        parts.push(`SameSite=${normalized}`);
-    }
-    // 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/svelte/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/svelte/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/svelte/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/svelte/src/client/svelte/provider/create-intor-store.js

@@ -5,71 +5,67 @@ import { resolveEffectiveIsLoading, resolveEffectiveMessages } from '../../share
 import { attachLocaleEffects } from './effects/attach-locale-effects.js';
 import { attachMessagesEffects } from './effects/attach-messages-effects.js';
 
-const INTOR_CONTEXT_KEY = Symbol("IntorContext");
-function buildIntorStores({ config, locale: initialLocale, messages, handlers, hooks, onLocaleChange, isLoading: externalIsLoading, }) {
-    // ---------------------------------------------------------------------------
-    // Internal state
-    // ---------------------------------------------------------------------------
-    const locale = writable(initialLocale);
-    const runtimeMessages = writable(null);
-    const internalIsLoading = writable(false);
-    // -----------------------------------------------------------------------------
-    // Locale transition
-    // -----------------------------------------------------------------------------
-    /** Request a locale change. */
-    function setLocale(next) {
-        const current = get(locale);
-        if (next === current)
-            return;
-        locale.set(next);
-        void onLocaleChange?.(next); // Notify external listener (fire-and-forget)
-    }
-    // ---------------------------------------------------------------------------
-    // Effective state
-    // ---------------------------------------------------------------------------
-    const externalIsLoadingStore = typeof externalIsLoading === "object" && "subscribe" in externalIsLoading
-        ? externalIsLoading
-        : readable(!!externalIsLoading);
-    const effectiveIsLoading = derived([externalIsLoadingStore, internalIsLoading], ([$external, $internal]) => resolveEffectiveIsLoading($external, $internal));
-    const effectiveMessages = derived(runtimeMessages, ($runtime) => resolveEffectiveMessages($runtime, messages, config.messages));
-    // ---------------------------------------------------------------------------
-    // Translator
-    // ---------------------------------------------------------------------------
-    const { loadingMessage, missingMessage } = config.translator ?? {};
-    const translator = derived([effectiveMessages, locale, effectiveIsLoading], ([$messages, $locale, $isLoading]) => new Translator({
-        messages: $messages,
-        locale: $locale,
-        isLoading: $isLoading,
-        fallbackLocales: config.fallbackLocales,
-        ...(loadingMessage !== undefined ? { loadingMessage } : {}),
-        ...(missingMessage !== undefined ? { missingMessage } : {}),
-        ...(handlers !== undefined ? { handlers } : {}),
-        ...(hooks !== undefined ? { hooks } : {}),
-    }));
-    return {
-        config,
-        locale,
-        setLocale,
-        translator,
-        runtimeMessages,
-        internalIsLoading,
-    };
+const INTOR_CONTEXT_KEY = /* @__PURE__ */ Symbol("IntorContext");
+function buildIntorStores({
+  config,
+  locale: initialLocale,
+  messages,
+  handlers,
+  hooks,
+  onLocaleChange,
+  isLoading: externalIsLoading
+}) {
+  const locale = writable(initialLocale);
+  const runtimeMessages = writable(null);
+  const internalIsLoading = writable(false);
+  function setLocale(next) {
+    const current = get(locale);
+    if (next === current) return;
+    locale.set(next);
+    void onLocaleChange?.(next);
+  }
+  const externalIsLoadingStore = typeof externalIsLoading === "object" && "subscribe" in externalIsLoading ? externalIsLoading : readable(!!externalIsLoading);
+  const effectiveIsLoading = derived(
+    [externalIsLoadingStore, internalIsLoading],
+    ([$external, $internal]) => resolveEffectiveIsLoading($external, $internal)
+  );
+  const effectiveMessages = derived(
+    runtimeMessages,
+    ($runtime) => resolveEffectiveMessages($runtime, messages, config.messages)
+  );
+  const { loadingMessage, missingMessage } = config.translator ?? {};
+  const translator = derived(
+    [effectiveMessages, locale, effectiveIsLoading],
+    ([$messages, $locale, $isLoading]) => new Translator({
+      messages: $messages,
+      locale: $locale,
+      isLoading: $isLoading,
+      fallbackLocales: config.fallbackLocales,
+      ...loadingMessage !== void 0 ? { loadingMessage } : {},
+      ...missingMessage !== void 0 ? { missingMessage } : {},
+      ...handlers !== void 0 ? { handlers } : {},
+      ...hooks !== void 0 ? { hooks } : {}
+    })
+  );
+  return {
+    config,
+    locale,
+    setLocale,
+    translator,
+    runtimeMessages,
+    internalIsLoading
+  };
 }
-/**
- * Svelte initializer for Intor.
- *
- * @public
- */
 function createIntorStore(value) {
-    const stores = buildIntorStores(value);
-    attachLocaleEffects(stores.locale, value.config);
-    attachMessagesEffects({
-        config: value.config,
-        locale: stores.locale,
-        runtimeMessages: stores.runtimeMessages,
-        internalIsLoading: stores.internalIsLoading,
-    });
-    setContext(INTOR_CONTEXT_KEY, stores);
+  const stores = buildIntorStores(value);
+  attachLocaleEffects(stores.locale, value.config);
+  attachMessagesEffects({
+    config: value.config,
+    locale: stores.locale,
+    runtimeMessages: stores.runtimeMessages,
+    internalIsLoading: stores.internalIsLoading
+  });
+  setContext(INTOR_CONTEXT_KEY, stores);
 }
 
 export { INTOR_CONTEXT_KEY, buildIntorStores, createIntorStore };