intor 2.5.0 → 2.6.0

package/dist/svelte/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/svelte/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/svelte/src/core/render/create-html-renderer.js

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

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

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

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

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

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

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

package/dist/svelte/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/svelte/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/svelte/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-kit/src/adapters/svelte-kit/create-intor-handler.js

@@ -7,65 +7,45 @@ import { resolveInbound } from '../../routing/inbound/resolve-inbound.js';
 import { getLocaleFromAcceptLanguage } from '../../routing/locale/get-locale-from-accept-language.js';
 import { isSvelteKitSSG } from './utils/is-svelte-kit-ssg.js';
 
-/**
- * Resolves locale-aware routing for the current execution context.
- *
- * - Acts as the canonical routing authority within the SvelteKit request lifecycle.
- *
- * @public
- */
 function createIntorHandler(config) {
-    return async function intorHandler({ event, resolve }) {
-        // Locale from Accept-Language header
-        const acceptLanguage = event.request.headers.get("accept-language");
-        const localeFromAcceptLanguage = getLocaleFromAcceptLanguage(acceptLanguage, config.supportedLocales);
-        // ----------------------------------------------------------
-        // Resolve inbound routing decision (pure computation)
-        // ----------------------------------------------------------
-        let inboundResult;
-        if (isSvelteKitSSG(event)) {
-            const locale = event.params?.["locale"];
-            if (!locale)
-                throw new Error("Locale param is missing in SSG mode.");
-            inboundResult = {
-                locale,
-                localeSource: "path",
-                pathname: event.url.pathname,
-                shouldRedirect: false,
-            };
-        }
-        else {
-            const cookie = event.cookies.get(config.cookie.name);
-            const { host, searchParams, pathname: rawPathname } = event.url;
-            inboundResult = resolveInbound(config, rawPathname, {
-                host,
-                query: normalizeQuery(Object.fromEntries(searchParams.entries())),
-                ...(cookie !== undefined ? { cookie } : {}),
-                ...(localeFromAcceptLanguage !== undefined
-                    ? { detected: localeFromAcceptLanguage }
-                    : {}),
-            });
-        }
-        const { locale, localeSource, pathname, shouldRedirect } = inboundResult;
-        // ----------------------------------------------------------
-        // Redirect if needed
-        // ----------------------------------------------------------
-        if (shouldRedirect)
-            redirect(307, pathname);
-        // ----------------------------------------------------------
-        // Bind inbound routing context
-        // ----------------------------------------------------------
-        // @ts-expect-error - App.Locals must be extended by user
-        event.locals.intor = {
-            locale,
-            localeSource,
-            pathname,
-        };
-        const response = await resolve(event, {
-            transformPageChunk: ({ html }) => html.replace("%lang%", locale),
-        });
-        return response;
+  return async function intorHandler({ event, resolve }) {
+    const acceptLanguage = event.request.headers.get("accept-language");
+    const localeFromAcceptLanguage = getLocaleFromAcceptLanguage(
+      acceptLanguage,
+      config.supportedLocales
+    );
+    let inboundResult;
+    if (isSvelteKitSSG(event)) {
+      const locale2 = event.params?.["locale"];
+      if (!locale2) throw new Error("Locale param is missing in SSG mode.");
+      inboundResult = {
+        locale: locale2,
+        localeSource: "path",
+        pathname: event.url.pathname,
+        shouldRedirect: false
+      };
+    } else {
+      const cookie = event.cookies.get(config.cookie.name);
+      const { host, searchParams, pathname: rawPathname } = event.url;
+      inboundResult = resolveInbound(config, rawPathname, {
+        host,
+        query: normalizeQuery(Object.fromEntries(searchParams.entries())),
+        ...cookie !== void 0 ? { cookie } : {},
+        ...localeFromAcceptLanguage !== void 0 ? { detected: localeFromAcceptLanguage } : {}
+      });
+    }
+    const { locale, localeSource, pathname, shouldRedirect } = inboundResult;
+    if (shouldRedirect) redirect(307, pathname);
+    event.locals.intor = {
+      locale,
+      localeSource,
+      pathname
     };
+    const response = await resolve(event, {
+      transformPageChunk: ({ html }) => html.replace("%lang%", locale)
+    });
+    return response;
+  };
 }
 
 export { createIntorHandler };

package/dist/svelte-kit/src/adapters/svelte-kit/use-navigation.js

@@ -8,34 +8,36 @@ import { resolveOutbound } from '../../routing/outbound/resolve-outbound.js';
 import { goto } from '$app/navigation';
 import { page } from '$app/state';
 
-/**
- * Locale-aware navigation utilities for SvelteKit.
- *
- * Provides imperative navigation helpers that integrate
- * Intor's locale-aware routing and side effects.
- *
- * @public
- */
 function useNavigation() {
-    const { config, locale: currentLocale, setLocale } = getIntorContext();
-    async function goto$1(url, opts) {
-        const { locale, ...rest } = opts || {};
-        const outboundResult = resolveOutbound(config, get(currentLocale), page.url.pathname, { destination: url, ...(locale !== undefined ? { locale } : {}) });
-        executeNavigation(outboundResult, {
-            config,
-            currentLocale: get(currentLocale),
-            setLocale,
-        });
-        return goto(outboundResult.destination, rest);
-    }
-    function href(url) {
-        const { destination } = resolveOutbound(config, get(currentLocale), page.url.pathname, { destination: url });
-        return destination;
-    }
-    return {
-        goto: goto$1,
-        href,
-    };
+  const { config, locale: currentLocale, setLocale } = getIntorContext();
+  async function goto$1(url, opts) {
+    const { locale, ...rest } = opts || {};
+    const outboundResult = resolveOutbound(
+      config,
+      get(currentLocale),
+      page.url.pathname,
+      { destination: url, ...locale !== void 0 ? { locale } : {} }
+    );
+    executeNavigation(outboundResult, {
+      config,
+      currentLocale: get(currentLocale),
+      setLocale
+    });
+    return goto(outboundResult.destination, rest);
+  }
+  function href(url) {
+    const { destination } = resolveOutbound(
+      config,
+      get(currentLocale),
+      page.url.pathname,
+      { destination: url }
+    );
+    return destination;
+  }
+  return {
+    goto: goto$1,
+    href
+  };
 }
 
 export { useNavigation };

package/dist/svelte-kit/src/adapters/svelte-kit/utils/is-svelte-kit-ssg.js

@@ -1,15 +1,8 @@
-/**
- * Heuristic to detect static (prerender) execution in SvelteKit.
- *
- * This is NOT a guaranteed signal.
- * It intentionally prefers false positives over false negatives.
- */
 function isSvelteKitSSG(event) {
-    // No user-agent is a strong signal of static rendering
-    if (event.request.headers.get("user-agent") === null) {
-        return true;
-    }
-    return false;
+  if (event.request.headers.get("user-agent") === null) {
+    return true;
+  }
+  return false;
 }
 
 export { isSvelteKitSSG };

package/dist/svelte-kit/src/client/shared/navigation/execute-navigation.js

@@ -4,46 +4,28 @@ import 'intor-translator';
 import { shouldSyncLocale } from '../../../policies/should-sync-locale.js';
 import { setLocaleCookie } from '../utils/locale/set-locale-cookie.js';
 
-/**
- * Executes a resolved outbound routing result.
- *
- * Applies all imperative side effects required to realize the outbound decision,
- * including locale synchronization, cookie persistence, and full page reloads.
- *
- * This function must be called after `resolveOutbound`.
- */
 function executeNavigation(outboundResult, context, e) {
-    const { config, currentLocale, setLocale } = context;
-    const { cookie } = config;
-    const { destination, kind, locale } = outboundResult;
-    // ------------------------------------------------------
-    // External navigation: let browser handle it
-    // ------------------------------------------------------
-    if (kind === "external") {
-        return;
-    }
-    // ------------------------------------------------------
-    // Full reload: commit locale side effects, then perform document reload
-    // ------------------------------------------------------
-    if (kind === "reload") {
-        if (shouldSyncLocale(locale, currentLocale)) {
-            if (cookie.persist) {
-                setLocaleCookie(cookie, locale);
-            }
-        }
-        globalThis.location.href = destination;
-        return;
-    }
-    // ------------------------------------------------------
-    // Client-side navigation only
-    // ------------------------------------------------------
+  const { config, currentLocale, setLocale } = context;
+  const { cookie } = config;
+  const { destination, kind, locale } = outboundResult;
+  if (kind === "external") {
+    return;
+  }
+  if (kind === "reload") {
     if (shouldSyncLocale(locale, currentLocale)) {
-        // Eagerly persist locale to avoid stale cookie during client-side navigation.
-        if (cookie.persist) {
-            setLocaleCookie(cookie, locale);
-        }
-        setLocale(locale);
+      if (cookie.persist) {
+        setLocaleCookie(cookie, locale);
+      }
+    }
+    globalThis.location.href = destination;
+    return;
+  }
+  if (shouldSyncLocale(locale, currentLocale)) {
+    if (cookie.persist) {
+      setLocaleCookie(cookie, locale);
     }
+    setLocale(locale);
+  }
 }
 
 export { executeNavigation };