intor 2.4.17 → 2.5.1

package/dist/vue/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/vue/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/vue/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/vue/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/vue/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/vue/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/vue/src/client/vue/helpers/use-intor.js

@@ -1,41 +1,27 @@
 import { ref, onMounted } from 'vue';
-import { getClientLocale } from '../../shared/helpers/get-client-locale.js';
+import { getClientLocale } from 'intor';
 
 function useIntor(config, loader) {
-    // ---------------------------------------------------------------------------
-    // Initial locale
-    // ---------------------------------------------------------------------------
-    const locale = getClientLocale(config);
-    // ---------------------------------------------------------------------------
-    // State
-    // ---------------------------------------------------------------------------
-    const messages = ref(config.messages || {});
-    const isLoading = ref(true);
-    let activeLocale = locale;
-    // ---------------------------------------------------------------------------
-    // Locale change handler
-    // ---------------------------------------------------------------------------
-    const onLocaleChange = async (newLocale) => {
-        activeLocale = newLocale;
-        isLoading.value = true;
-        const loaded = await loader(config, newLocale);
-        // Ignore outdated results when locale changes again.
-        if (activeLocale !== newLocale)
-            return;
-        messages.value = loaded;
-        isLoading.value = false;
-    };
-    // ---------------------------------------------------------------------------
-    // Initial load
-    // ---------------------------------------------------------------------------
-    onMounted(() => onLocaleChange(locale));
-    return {
-        config,
-        locale,
-        messages,
-        isLoading,
-        onLocaleChange,
-    };
+  const locale = getClientLocale(config);
+  const messages = ref(config.messages || {});
+  const isLoading = ref(true);
+  let activeLocale = locale;
+  const onLocaleChange = async (newLocale) => {
+    activeLocale = newLocale;
+    isLoading.value = true;
+    const loaded = await loader(config, newLocale);
+    if (activeLocale !== newLocale) return;
+    messages.value = loaded;
+    isLoading.value = false;
+  };
+  onMounted(() => onLocaleChange(locale));
+  return {
+    config,
+    locale,
+    messages,
+    isLoading,
+    onLocaleChange
+  };
 }
 
 export { useIntor };

package/dist/vue/src/client/vue/provider/effects/use-locale-effects.js

@@ -1,6 +1,5 @@
 import { watch } from 'vue';
 import { shouldPersistOnFirstVisit } from '../../../../policies/should-persist-on-first-visit.js';
-import '../../../../core/error/intor-error.js';
 import 'logry';
 import 'p-limit';
 import 'intor-translator';
@@ -9,31 +8,30 @@ import { setLocaleCookie } from '../../../shared/utils/locale/set-locale-cookie.
 import { setDocumentLocale } from '../../../shared/utils/locale/set-document-locale.js';
 
 function useLocaleEffects(config, locale) {
-    const { cookie, routing } = config;
-    let isFirstSync = true;
-    watch(locale, (currentLocale) => {
-        // Always sync document language
-        setDocumentLocale(currentLocale);
-        // -------------------------------------------------------------
-        // First sync (initial mount / hydration)
-        // -------------------------------------------------------------
-        if (isFirstSync) {
-            isFirstSync = false;
-            const localeCookie = getLocaleFromCookie(cookie.name);
-            const isFirstVisit = !localeCookie;
-            if (shouldPersistOnFirstVisit(isFirstVisit, routing.inbound.firstVisit.persist) &&
-                cookie.persist) {
-                setLocaleCookie(cookie, currentLocale);
-            }
-            return;
+  const { cookie, routing } = config;
+  let isFirstSync = true;
+  watch(
+    locale,
+    (currentLocale) => {
+      setDocumentLocale(currentLocale);
+      if (isFirstSync) {
+        isFirstSync = false;
+        const localeCookie = getLocaleFromCookie(cookie.name);
+        const isFirstVisit = !localeCookie;
+        if (shouldPersistOnFirstVisit(
+          isFirstVisit,
+          routing.inbound.firstVisit.persist
+        ) && cookie.persist) {
+          setLocaleCookie(cookie, currentLocale);
         }
-        // -------------------------------------------------------------
-        // Subsequent locale changes (user-driven)
-        // -------------------------------------------------------------
-        if (cookie.persist) {
-            setLocaleCookie(cookie, currentLocale);
-        }
-    }, { immediate: true });
+        return;
+      }
+      if (cookie.persist) {
+        setLocaleCookie(cookie, currentLocale);
+      }
+    },
+    { immediate: true }
+  );
 }
 
 export { useLocaleEffects };

package/dist/vue/src/client/vue/provider/effects/use-messages-effects.js

@@ -1,36 +1,22 @@
 import { watch } from 'vue';
 import { createRefetchMessages } from '../../../shared/messages/create-refetch-messages.js';
 
-/**
- * Attach message refetch side effects based on locale changes.
- *
- * - Skips initial run
- * - Aborts previous in-flight requests automatically
- * - Acts as a side-effect boundary (no state returned)
- */
 function useMessagesEffects(config, locale, runtimeMessages, internalIsLoading) {
-    // Prepares message refetch function.
-    const refetchMessages = createRefetchMessages({
-        config,
-        onLoadingStart: () => {
-            internalIsLoading.value = true;
-        },
-        onLoadingEnd: () => {
-            internalIsLoading.value = false;
-        },
-        onMessages: (messages) => {
-            runtimeMessages.value = messages;
-        },
-    });
-    // Refetch messages when locale changes (except initial render).
-    let isInitial = true;
-    watch(locale, (newLocale) => {
-        if (isInitial) {
-            isInitial = false;
-            return;
-        }
-        refetchMessages(newLocale);
-    });
+  const refetchMessages = createRefetchMessages({
+    config,
+    onLoadingStart: () => {
+      internalIsLoading.value = true;
+    },
+    onLoadingEnd: () => {
+      internalIsLoading.value = false;
+    },
+    onMessages: (messages) => {
+      runtimeMessages.value = messages;
+    }
+  });
+  watch(locale, (newLocale) => {
+    void refetchMessages(newLocale);
+  });
 }
 
 export { useMessagesEffects };

package/dist/vue/src/client/vue/provider/inject-intor-context.js

@@ -0,0 +1,11 @@
+import { inject } from 'vue';
+import { IntorContextKey } from './intor-provider.js';
+
+function injectIntorContext() {
+  const context = inject(IntorContextKey);
+  if (!context)
+    throw new Error("injectIntorContext must be used within IntorProvider");
+  return context;
+}
+
+export { injectIntorContext };

package/dist/vue/src/client/vue/provider/intor-provider.js

@@ -1,73 +1,71 @@
 import { Translator } from 'intor-translator';
 import { defineComponent, ref, computed, watch, provide } from 'vue';
+import { resolveEffectiveIsLoading, resolveEffectiveMessages } from '../../shared/provider/effective-state.js';
 import { useLocaleEffects } from './effects/use-locale-effects.js';
 import { useMessagesEffects } from './effects/use-messages-effects.js';
 
-const IntorContextKey = Symbol("IntorContext");
+const IntorContextKey = /* @__PURE__ */ Symbol("IntorContext");
 const IntorProvider = defineComponent({
-    name: "IntorProvider",
-    props: { value: { type: Object, required: true } },
-    setup(props, { slots }) {
-        // ---------------------------------------------------------------------------
-        // Internal state
-        // ---------------------------------------------------------------------------
-        const locale = ref(props.value.locale);
-        const runtimeMessages = ref(null);
-        const internalIsLoading = ref(false);
-        // ---------------------------------------------------------------------------
-        // Locale transition
-        // ---------------------------------------------------------------------------
-        /** Request a locale change. */
-        const setLocale = async (newLocale) => {
-            if (newLocale === locale.value)
-                return;
-            locale.value = newLocale;
-            props.value.onLocaleChange?.(newLocale); // Notify external listener (fire-and-forget)
-        };
-        // ---------------------------------------------------------------------------
-        // Effective state
-        // ---------------------------------------------------------------------------
-        // external > internal
-        const effectiveIsLoading = computed(() => !!props.value.isLoading?.value || internalIsLoading.value);
-        // runtime (client refetch) > initial > config (static)
-        const effectiveMessages = computed(() => runtimeMessages.value ||
-            props.value.messages?.value ||
-            props.value.config.messages ||
-            {});
-        // ---------------------------------------------------------------------------
-        // Translator
-        // ---------------------------------------------------------------------------
-        const translator = computed(() => {
-            return new Translator({
-                messages: effectiveMessages.value,
-                locale: locale.value,
-                isLoading: effectiveIsLoading.value,
-                fallbackLocales: props.value.config.fallbackLocales,
-                loadingMessage: props.value.config.translator?.loadingMessage,
-                missingMessage: props.value.config.translator?.missingMessage,
-                handlers: props.value.handlers,
-                plugins: props.value.plugins,
-            });
-        });
-        // -------------------------------------------------------------------------
-        // Side effects
-        // -------------------------------------------------------------------------
-        useLocaleEffects(props.value.config, locale);
-        useMessagesEffects(props.value.config, locale, runtimeMessages, internalIsLoading);
-        // Sync internal locale with external prop
-        watch(() => props.value.locale, (newLocale) => {
-            if (newLocale !== locale.value)
-                locale.value = newLocale;
-        });
-        const contextValue = computed(() => ({
-            config: props.value.config,
-            locale,
-            setLocale,
-            translator,
-        }));
-        provide(IntorContextKey, contextValue);
-        return () => slots.default?.();
-    },
+  name: "IntorProvider",
+  props: { value: { type: Object, required: true } },
+  setup(props, { slots }) {
+    const locale = ref(props.value.locale);
+    const runtimeMessages = ref(null);
+    const internalIsLoading = ref(false);
+    const setLocale = (newLocale) => {
+      if (newLocale === locale.value) return;
+      locale.value = newLocale;
+      void props.value.onLocaleChange?.(newLocale);
+    };
+    const effectiveIsLoading = computed(
+      () => resolveEffectiveIsLoading(
+        !!props.value.isLoading?.value,
+        internalIsLoading.value
+      )
+    );
+    const effectiveMessages = computed(
+      () => resolveEffectiveMessages(
+        runtimeMessages.value,
+        props.value.messages?.value,
+        props.value.config.messages
+      )
+    );
+    const { loadingMessage, missingMessage } = props.value.config.translator ?? {};
+    const { handlers, hooks } = props.value;
+    const translator = computed(() => {
+      return new Translator({
+        messages: effectiveMessages.value,
+        locale: locale.value,
+        isLoading: effectiveIsLoading.value,
+        fallbackLocales: props.value.config.fallbackLocales,
+        ...loadingMessage !== void 0 ? { loadingMessage } : {},
+        ...missingMessage !== void 0 ? { missingMessage } : {},
+        ...handlers !== void 0 ? { handlers } : {},
+        ...hooks !== void 0 ? { hooks } : {}
+      });
+    });
+    useLocaleEffects(props.value.config, locale);
+    useMessagesEffects(
+      props.value.config,
+      locale,
+      runtimeMessages,
+      internalIsLoading
+    );
+    watch(
+      () => props.value.locale,
+      (newLocale) => {
+        if (newLocale !== locale.value) locale.value = newLocale;
+      }
+    );
+    const contextValue = computed(() => ({
+      config: props.value.config,
+      locale,
+      setLocale,
+      translator
+    }));
+    provide(IntorContextKey, contextValue);
+    return () => slots["default"]?.();
+  }
 });
 
 export { IntorContextKey, IntorProvider };

package/dist/vue/src/client/vue/render/create-vue-renderer.js

@@ -1,30 +1,24 @@
 import { h } from 'vue';
 
-/**
- * Create a Vue renderer for semantic rich messages.
- */
 const createVueRenderer = (tagRenderers) => {
-    return {
-        /** Render plain text nodes */
-        text(value) {
-            return 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 a native Vue element
-            return h(name, null, children);
-        },
-        /** Render raw (non-tokenized) message values */
-        raw(value) {
-            return value;
-        },
-    };
+  return {
+    /** Render plain text nodes */
+    text(value) {
+      return value;
+    },
+    /** Render semantic tag nodes */
+    tag(name, _attributes, children) {
+      const tagRenderer = tagRenderers?.[name];
+      if (tagRenderer) {
+        return typeof tagRenderer === "function" ? tagRenderer(children) : tagRenderer;
+      }
+      return h(name, null, children);
+    },
+    /** Render raw (non-tokenized) message values */
+    raw(value) {
+      return value;
+    }
+  };
 };
 
 export { createVueRenderer };

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

@@ -1,24 +1,12 @@
 import { renderRichMessage } from 'intor-translator';
 import { createVueRenderer } from '../render/create-vue-renderer.js';
 
-/**
- * Create a Vue-specific rich translation function.
- *
- * This adapter bridges the core Translator with the Vue rich
- * message rendering flow.
- *
- * - Resolves translated messages via `translator.t`
- * - Renders semantic tags using Vue renderers
- * - Supports optional scoped keys via `preKey`
- *
- * Intended for Vue client usage only.
- */
 const createTRich = (t) => {
-    return (key, tagRenderers, replacements) => {
-        const message = t(key, replacements);
-        const vueRenderer = createVueRenderer(tagRenderers);
-        return renderRichMessage(message, vueRenderer);
-    };
+  return (key, tagRenderers, replacements) => {
+    const message = t(key, replacements);
+    const vueRenderer = createVueRenderer(tagRenderers);
+    return renderRichMessage(message, vueRenderer);
+  };
 };
 
 export { createTRich };