intor 2.5.0 → 2.6.0

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

@@ -4,73 +4,68 @@ import { resolveEffectiveIsLoading, resolveEffectiveMessages } from '../../share
 import { useLocaleEffects } from './effects/use-locale-effects.js';
 import { useMessagesEffects } from './effects/use-messages-effects.js';
 
-const IntorContextKey = Symbol("IntorContext");
-/**
- * Vue provider for Intor.
- *
- * @public
- */
+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 = (newLocale) => {
-            if (newLocale === locale.value)
-                return;
-            locale.value = newLocale;
-            void props.value.onLocaleChange?.(newLocale); // Notify external listener (fire-and-forget)
-        };
-        // ---------------------------------------------------------------------------
-        // Effective state
-        // ---------------------------------------------------------------------------
-        const effectiveIsLoading = computed(() => resolveEffectiveIsLoading(!!props.value.isLoading?.value, internalIsLoading.value));
-        const effectiveMessages = computed(() => resolveEffectiveMessages(runtimeMessages.value, props.value.messages?.value, props.value.config.messages));
-        // ---------------------------------------------------------------------------
-        // Translator
-        // ---------------------------------------------------------------------------
-        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 !== undefined ? { loadingMessage } : {}),
-                ...(missingMessage !== undefined ? { missingMessage } : {}),
-                ...(handlers !== undefined ? { handlers } : {}),
-                ...(hooks !== undefined ? { hooks } : {}),
-            });
-        });
-        // -------------------------------------------------------------------------
-        // 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 };

package/dist/vue/src/client/vue/translator/trans.js

@@ -1,40 +1,33 @@
 import { defineComponent, h, Fragment } from 'vue';
 import { useTranslator } from './use-translator.js';
 
-/**
- * Vue component for rendering rich translations.
- *
- * A thin wrapper around `tRich`.
- *
- * @public
- */
 const Trans = defineComponent({
-    name: "Trans",
-    props: {
-        /** The message key to translate. */
-        i18nKey: {
-            type: String,
-            required: true,
-        },
-        /** Optional Vue renderers for semantic tags. */
-        components: {
-            type: Object,
-            required: false,
-        },
-        /** Optional replacement values for interpolation. */
-        values: {
-            type: Object,
-            required: false,
-        },
+  name: "Trans",
+  props: {
+    /** The message key to translate. */
+    i18nKey: {
+      type: String,
+      required: true
     },
-    setup(props) {
-        const { tRich } = useTranslator();
-        return () => {
-            const { i18nKey, components, values } = props;
-            const nodes = tRich(i18nKey, components, values);
-            return h(Fragment, null, nodes);
-        };
+    /** Optional Vue renderers for semantic tags. */
+    components: {
+      type: Object,
+      required: false
     },
+    /** Optional replacement values for interpolation. */
+    values: {
+      type: Object,
+      required: false
+    }
+  },
+  setup(props) {
+    const { tRich } = useTranslator();
+    return () => {
+      const { i18nKey, components, values } = props;
+      const nodes = tRich(i18nKey, components, values);
+      return h(Fragment, null, nodes);
+    };
+  }
 });
 
 export { Trans };

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

@@ -3,24 +3,19 @@ import '../provider/intor-provider.js';
 import { injectIntorContext } from '../provider/inject-intor-context.js';
 import { createTRich } from './create-t-rich.js';
 
-/**
- * Vue composable for accessing the active, scope-aware translator instance.
- *
- * @public
- */
 function useTranslator(preKey) {
-    const intor = injectIntorContext();
-    const translator = intor.value.translator;
-    const scoped = computed(() => translator.value.scoped(preKey));
-    return {
-        messages: computed(() => translator.value.messages),
-        locale: computed(() => translator.value.locale),
-        isLoading: computed(() => translator.value.isLoading),
-        setLocale: intor.value.setLocale,
-        hasKey: (...args) => scoped.value.hasKey(...args),
-        t: (...args) => scoped.value.t(...args),
-        tRich: (...args) => createTRich(scoped.value.t)(...args),
-    };
+  const intor = injectIntorContext();
+  const translator = intor.value.translator;
+  const scoped = computed(() => translator.value.scoped(preKey));
+  return {
+    messages: computed(() => translator.value.messages),
+    locale: computed(() => translator.value.locale),
+    isLoading: computed(() => translator.value.isLoading),
+    setLocale: intor.value.setLocale,
+    hasKey: (...args) => scoped.value.hasKey(...args),
+    t: (...args) => scoped.value.t(...args),
+    tRich: (...args) => createTRich(scoped.value.t)(...args)
+  };
 }
 
 export { useTranslator };

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