intor 2.3.16 → 2.3.18

package/dist/next/src/adapters/next/navigation/use-pathname.js

@@ -1,5 +1,5 @@
 import { usePathname as usePathname$1 } from 'next/navigation';
-import { useIntor } from 'intor/react';
+import { useIntorContext } from 'intor/react';
 import '../../../core/error/intor-error.js';
 import 'logry';
 import { localizePathname } from '../../../routing/pathname/localize-pathname.js';
@@ -17,7 +17,7 @@ import { localizePathname } from '../../../routing/pathname/localize-pathname.js
  * @platform Next.js
  */
 const usePathname = () => {
-    const { config, locale } = useIntor();
+    const { config, locale } = useIntorContext();
     const rawPathname = usePathname$1();
     return localizePathname(rawPathname, config, locale);
 };

package/dist/react/export/react/index.js

@@ -1,8 +1,8 @@
 export { IntorProvider } from '../../src/client/react/provider/intor-provider.js';
-export { useIntor } from '../../src/client/react/provider/use-intor.js';
+export { useIntorContext } from '../../src/client/react/provider/use-intor-context.js';
 export { useTranslator } from '../../src/client/react/translator/use-translator.js';
 export { Trans } from '../../src/client/react/translator/trans.js';
 export { useResolveNavigation } from '../../src/client/react/navigation/use-resolve-navigation.js';
 export { useExecuteNavigation } from '../../src/client/react/navigation/use-execute-navigation.js';
-export { useRuntimeState } from '../../src/client/react/helpers/use-runtime-state.js';
+export { useIntor } from '../../src/client/react/helpers/use-intor.js';
 export { getClientLocale } from '../../src/client/shared/helpers/get-client-locale.js';

package/dist/react/src/client/react/helpers/{use-runtime-state.js → use-intor.js}

@@ -4,7 +4,7 @@ import 'logry';
 import { mergeMessages } from '../../../core/messages/merge-messages.js';
 import { getClientLocale } from '../../shared/helpers/get-client-locale.js';
 
-function useRuntimeState(config, loader) {
+function useIntor(config, loader) {
     // ---------------------------------------------------------------------------
     // Initial locale
     // ---------------------------------------------------------------------------
@@ -43,4 +43,4 @@ function useRuntimeState(config, loader) {
     };
 }
 
-export { useRuntimeState };
+export { useIntor };

package/dist/react/src/client/react/navigation/use-execute-navigation.js

@@ -4,10 +4,10 @@ import '../../../core/error/intor-error.js';
 import 'logry';
 import { shouldSyncLocale } from '../../../policies/should-sync-locale.js';
 import '../provider/intor-provider.js';
-import { useIntor } from '../provider/use-intor.js';
+import { useIntorContext } from '../provider/use-intor-context.js';
 
 function useExecuteNavigation() {
-    const { config, setLocale, locale: currentLocale } = useIntor();
+    const { config, setLocale, locale: currentLocale } = useIntorContext();
     function executeNavigation(result, e) {
         const { destination, kind, locale } = result;
         // External navigation: let browser handle it

package/dist/react/src/client/react/navigation/use-resolve-navigation.js

@@ -2,10 +2,10 @@ import '../../../core/error/intor-error.js';
 import 'logry';
 import { resolveNavigation } from '../../../routing/navigation/resolve-navigation.js';
 import '../provider/intor-provider.js';
-import { useIntor } from '../provider/use-intor.js';
+import { useIntorContext } from '../provider/use-intor-context.js';
 
 function useResolveNavigation() {
-    const { config, locale: currentLocale } = useIntor();
+    const { config, locale: currentLocale } = useIntorContext();
     function resolveNavigation$1(currentPathname, intent) {
         return resolveNavigation(config, currentLocale, currentPathname, intent);
     }

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

@@ -57,14 +57,7 @@ const IntorProvider = ({ value: { config, locale: initialLocale, messages, handl
     // ---------------------------------------------------------------------------
     useLocaleEffects(config, locale);
     useMessagesEffects(config, locale, setRuntimeMessages, setInternalIsLoading);
-    return (jsx(IntorContext.Provider, { value: {
-            config,
-            locale,
-            setLocale,
-            messages: effectiveMessages,
-            isLoading: effectiveIsLoading,
-            translator,
-        }, children: children }));
+    return (jsx(IntorContext.Provider, { value: { config, locale, setLocale, translator }, children: children }));
 };
 
 export { IntorContext, IntorProvider };

package/dist/react/src/client/react/provider/{use-intor.js → use-intor-context.js}

@@ -1,11 +1,11 @@
 import React__default from 'react';
 import { IntorContext } from './intor-provider.js';
 
-function useIntor() {
+function useIntorContext() {
     const context = React__default.useContext(IntorContext);
     if (!context)
-        throw new Error("useIntor must be used within IntorProvider");
+        throw new Error("useIntorContext must be used within IntorProvider");
     return context;
 }
 
-export { useIntor };
+export { useIntorContext };

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

@@ -2,34 +2,24 @@ import * as React from 'react';
 
 /**
  * Create a React renderer for semantic rich messages.
- *
- * Transforms semantic AST nodes into React nodes.
- * Used together with `render` / `renderRichMessage`.
- *
- * - Text nodes → plain strings
- * - Tag nodes → custom renderer or native element
- * - Raw nodes → rendered as-is by the renderer
- *
- * This renderer is intentionally minimal and stateless.
  */
-const createReactRenderer = (options) => {
-    const { tagRenderers } = options ?? {};
+const createReactRenderer = (tagRenderers) => {
     return {
         /** Render plain text nodes */
         text(value) {
             return value;
         },
         /** Render semantic tag nodes */
-        tag(name, attributes, children) {
-            const renderer = tagRenderers?.[name];
-            // Custom tag renderer
-            if (renderer) {
-                return typeof renderer === "function"
-                    ? renderer(children, attributes)
-                    : renderer;
+        tag(name, _attributes, children) {
+            // Custom tag renderers override
+            const tagRenderer = tagRenderers?.[name];
+            if (tagRenderer) {
+                return typeof tagRenderer === "function"
+                    ? tagRenderer(children)
+                    : tagRenderer;
             }
             // Default behavior: render as a native React element
-            return React.createElement(name, attributes, ...children);
+            return React.createElement(name, null, ...children);
         },
         /** Render raw (non-tokenized) message values */
         raw(value) {

package/dist/react/src/client/react/render/render-rich-message-react.js

@@ -12,8 +12,8 @@ import { createReactRenderer } from './create-react-renderer.js';
  *
  * This function is intended for React environments only.
  */
-function renderRichMessageReact(message, tagRenderers) {
-    const reactRenderer = createReactRenderer({ tagRenderers });
+function renderRichMessageReact(message, tagComponents) {
+    const reactRenderer = createReactRenderer(tagComponents);
     const nodes = renderRichMessage(message, reactRenderer);
     // Wrap each top-level node with a Fragment to provide a stable key
     return nodes.map((node, index) => jsx(Fragment, { children: node }, index));

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

@@ -1,10 +1,10 @@
 import '../provider/intor-provider.js';
-import { useIntor } from '../provider/use-intor.js';
+import { useIntorContext } from '../provider/use-intor-context.js';
 import { createTRich } from './create-t-rich.js';
 
 // Implementation
 function useTranslator(preKey) {
-    const { translator, setLocale } = useIntor();
+    const { translator, setLocale } = useIntorContext();
     const scoped = translator.scoped(preKey);
     return {
         messages: translator.messages,
@@ -14,6 +14,10 @@ function useTranslator(preKey) {
         hasKey: preKey ? scoped.hasKey : translator.hasKey,
         t: preKey ? scoped.t : translator.t,
         tRich: createTRich(translator, preKey),
+        // NOTE:
+        // The runtime implementation is intentionally erased.
+        // Type safety is guaranteed by public type contracts.
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
     };
 }
 

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

@@ -1,3 +1,3 @@
-export { createIntor } from '../../src/client/svelte/runtime/create-intor.js';
-export { createRuntimeState } from '../../src/client/svelte/helpers/create-runtime-state.js';
+export { createIntorStore } from '../../src/client/svelte/store/create-intor-store.js';
+export { createIntor } from '../../src/client/svelte/helpers/create-intor.js';
 export { getClientLocale } from '../../src/client/shared/helpers/get-client-locale.js';

package/dist/svelte/src/client/svelte/helpers/{create-runtime-state.js → create-intor.js}

@@ -4,7 +4,7 @@ import 'logry';
 import { mergeMessages } from '../../../core/messages/merge-messages.js';
 import { getClientLocale } from '../../shared/helpers/get-client-locale.js';
 
-function createRuntimeState(config, loader) {
+function createIntor(config, loader) {
     // ---------------------------------------------------------------------------
     // Initial locale
     // ---------------------------------------------------------------------------
@@ -41,4 +41,4 @@ function createRuntimeState(config, loader) {
     };
 }
 
-export { createRuntimeState };
+export { createIntor };

package/dist/svelte/src/client/svelte/{runtime/create-intor.js → store/create-intor-store.js}

@@ -1,10 +1,10 @@
 import { Translator } from 'intor-translator';
 import { writable, readable, derived, get } from 'svelte/store';
-import { createIntorApi } from './create-intor-api.js';
+import { createTranslatorBindings } from './create-translator-bindings.js';
 import { attachLocaleEffects } from './effects/locale-effects.js';
 import { attachMessagesEffects } from './effects/messages-effects.js';
 
-function createIntor({ config, locale: initialLocale, messages, handlers, plugins, onLocaleChange, isLoading: externalIsLoading, }) {
+function createIntorStore({ config, locale: initialLocale, messages, handlers, plugins, onLocaleChange, isLoading: externalIsLoading, }) {
     // ---------------------------------------------------------------------------
     // Internal state
     // ---------------------------------------------------------------------------
@@ -48,7 +48,7 @@ function createIntor({ config, locale: initialLocale, messages, handlers, plugin
     // ---------------------------------------------------------------------------
     attachLocaleEffects(locale, config);
     attachMessagesEffects({ config, locale, runtimeMessages, internalIsLoading });
-    const { scoped, t, tRich } = createIntorApi(translator);
+    const { scoped, t, tRich } = createTranslatorBindings(translator);
     return {
         messages: effectiveMessages,
         locale,
@@ -60,4 +60,4 @@ function createIntor({ config, locale: initialLocale, messages, handlers, plugin
     };
 }
 
-export { createIntor };
+export { createIntorStore };

package/dist/svelte/src/client/svelte/{runtime/create-intor-api.js → store/create-translator-bindings.js}

@@ -1,10 +1,10 @@
 import { derived } from 'svelte/store';
 import { renderRichMessageSvelte } from '../render/render-rich-message-svelte.js';
 
-function createIntorApi(translator) {
+function createTranslatorBindings(translator) {
     const scoped = (preKey) => {
         const scopedTranslator = derived(translator, ($t) => $t.scoped(preKey));
-        return createIntorApi(scopedTranslator);
+        return createTranslatorBindings(scopedTranslator);
     };
     const t = derived(translator, ($t) => {
         return (key, replacements) => $t.t(key, replacements);
@@ -22,4 +22,4 @@ function createIntorApi(translator) {
     };
 }
 
-export { createIntorApi };
+export { createTranslatorBindings };

package/dist/types/export/react/index.d.ts

@@ -1,2 +1,2 @@
-export { IntorProvider, type IntorProviderProps, useIntor, // Internal hook.
-useTranslator, Trans, useResolveNavigation, useExecuteNavigation, useRuntimeState, getClientLocale, } from "../../src/client/react";
+export { IntorProvider, type IntorProviderProps, useIntorContext, // Internal hook.
+useTranslator, Trans, useResolveNavigation, useExecuteNavigation, useIntor, getClientLocale, } from "../../src/client/react";

package/dist/types/export/server/index.d.ts

@@ -1 +1 @@
-export { intor, type ServerSnapshot, loadMessages, getTranslator, loadMessagesFromUrl, } from "../../src/server";
+export { intor, type IntorValue, loadMessages, getTranslator, loadMessagesFromUrl, } from "../../src/server";

package/dist/types/export/svelte/index.d.ts

@@ -1 +1 @@
-export { createIntor, type IntorRuntime, createRuntimeState, getClientLocale, } from "../../src/client/svelte";
+export { createIntorStore, type IntorStore, createIntor, getClientLocale, } from "../../src/client/svelte";

package/dist/types/export/vue/index.d.ts

@@ -1 +1 @@
-export { IntorProvider, useTranslator, Trans, useRuntimeState, getClientLocale, } from "../../src/client/vue";
+export { IntorProvider, useTranslator, Trans, useIntor, getClientLocale, } from "../../src/client/vue";

package/dist/types/src/adapters/next/server/intor.d.ts

@@ -1,7 +1,7 @@
 import type { IntorResolvedConfig } from "../../../config";
 import type { MessagesReaders } from "../../../core";
 import { type GenConfigKeys } from "../../../core";
-import { type ServerSnapshot } from "../../../server";
+import { type IntorValue } from "../../../server";
 /**
  * Initializes Intor for the current execution context.
  *
@@ -9,4 +9,4 @@ import { type ServerSnapshot } from "../../../server";
  * - Permits cache writes during server execution.
  * @platform Next.js
  */
-export declare function intor<CK extends GenConfigKeys = "__default__">(config: IntorResolvedConfig, readers?: MessagesReaders): Promise<ServerSnapshot<CK>>;
+export declare function intor<CK extends GenConfigKeys = "__default__">(config: IntorResolvedConfig, readers?: MessagesReaders): Promise<IntorValue<CK>>;

package/dist/types/src/client/react/helpers/index.d.ts

@@ -1 +1 @@
-export { useRuntimeState } from "./use-runtime-state";
+export { useIntor } from "./use-intor";

package/dist/types/src/client/react/helpers/use-intor.d.ts

@@ -0,0 +1,5 @@
+import type { IntorValue } from "../provider";
+import type { IntorResolvedConfig } from "../../../config";
+import type { GenConfigKeys } from "../../../core";
+import type { LocaleMessages } from "intor-translator";
+export declare function useIntor<CK extends GenConfigKeys = "__default__">(config: IntorResolvedConfig, loader: (locale: string) => Promise<LocaleMessages>): Omit<IntorValue<CK>, "handlers" | "plugins">;

package/dist/types/src/client/react/index.d.ts

@@ -1,5 +1,5 @@
-export { IntorProvider, type IntorProviderProps, useIntor } from "./provider";
+export { IntorProvider, type IntorProviderProps, useIntorContext, } from "./provider";
 export { useTranslator, Trans } from "./translator";
 export { useResolveNavigation, useExecuteNavigation } from "./navigation";
-export { useRuntimeState } from "./helpers";
+export { useIntor } from "./helpers";
 export { getClientLocale } from "../shared/helpers";

package/dist/types/src/client/react/provider/index.d.ts

@@ -1,3 +1,3 @@
 export { IntorProvider } from "./intor-provider";
-export type { IntorProviderProps } from "./types";
-export { useIntor } from "./use-intor";
+export type { IntorValue, IntorProviderProps } from "./types";
+export { useIntorContext } from "./use-intor-context";

package/dist/types/src/client/react/provider/types.d.ts

@@ -3,23 +3,22 @@ import type { GenConfigKeys, GenLocale, GenMessages } from "../../../core";
 import type { TranslateHandlers, TranslateHook, TranslatorPlugin } from "intor-translator";
 import type { Translator } from "intor-translator";
 import type * as React from "react";
+export interface IntorValue<CK extends GenConfigKeys = "__default__"> {
+    config: IntorResolvedConfig;
+    locale: GenLocale<CK>;
+    messages?: Readonly<GenMessages<CK>>;
+    isLoading?: boolean;
+    onLocaleChange?: (newLocale: GenLocale<CK>) => Promise<void> | void;
+    handlers?: TranslateHandlers;
+    plugins?: (TranslatorPlugin | TranslateHook)[];
+}
 export interface IntorProviderProps<CK extends GenConfigKeys = "__default__"> {
-    value: {
-        config: IntorResolvedConfig;
-        locale: GenLocale<CK>;
-        messages?: Readonly<GenMessages<CK>>;
-        isLoading?: boolean;
-        handlers?: TranslateHandlers;
-        plugins?: (TranslatorPlugin | TranslateHook)[];
-        onLocaleChange?: (newLocale: GenLocale<CK>) => Promise<void> | void;
-    };
+    value: IntorValue<CK>;
     children: React.ReactNode;
 }
 export type IntorContextValue<CK extends GenConfigKeys = "__default__"> = {
     config: IntorResolvedConfig;
     locale: GenLocale<CK>;
     setLocale: (locale: GenLocale<CK>) => void;
-    messages: Readonly<GenMessages<CK>>;
-    isLoading: boolean;
     translator: Translator<unknown>;
 };

package/dist/types/src/client/react/provider/use-intor-context.d.ts

@@ -0,0 +1,3 @@
+import type { IntorContextValue } from "./types";
+import type { GenConfigKeys } from "../../../core";
+export declare function useIntorContext<CK extends GenConfigKeys = "__default__">(): IntorContextValue<CK>;

package/dist/types/src/client/react/render/create-react-renderer.d.ts

@@ -3,17 +3,5 @@ import type { Renderer } from "intor-translator";
 import * as React from "react";
 /**
  * Create a React renderer for semantic rich messages.
- *
- * Transforms semantic AST nodes into React nodes.
- * Used together with `render` / `renderRichMessage`.
- *
- * - Text nodes → plain strings
- * - Tag nodes → custom renderer or native element
- * - Raw nodes → rendered as-is by the renderer
- *
- * This renderer is intentionally minimal and stateless.
  */
-export declare const createReactRenderer: (options?: {
-    /** Optional custom renderers for semantic tags */
-    tagRenderers?: ReactTagRenderers;
-}) => Renderer<React.ReactNode>;
+export declare const createReactRenderer: (tagRenderers?: ReactTagRenderers) => Renderer<React.ReactNode>;

package/dist/types/src/client/react/render/render-rich-message-react.d.ts

@@ -11,4 +11,4 @@ import { type MessageValue } from "intor-translator";
  *
  * This function is intended for React environments only.
  */
-export declare function renderRichMessageReact(message: MessageValue, tagRenderers?: ReactTagRenderers): JSX.Element[];
+export declare function renderRichMessageReact(message: MessageValue, tagComponents?: ReactTagRenderers): JSX.Element[];

package/dist/types/src/client/react/render/types.d.ts

@@ -1,22 +1,8 @@
-import type { Attributes, Rich } from "intor-translator";
-/**
- * Renderer function for a semantic rich tag.
- *
- * - `children` are the rendered inner nodes of the tag
- * - `attributes` include both schema-defined and runtime attributes
- */
-type ReactTagRenderer<A = Attributes> = (children: React.ReactNode[], attributes: A & Attributes) => React.ReactNode;
-/**
- * Mapping of rich tags to React renderers.
- *
- * - Known tags are strongly typed based on the generated rich schema
- * - Unknown tags fall back to a generic renderer signature
- *
- * This design ensures:
- * - Accurate autocompletion for generated tags
- * - Fail-soft behavior for dynamic or newly added tags
- */
+import type { Rich } from "intor-translator";
+/** Renderer function for a semantic rich tag. */
+type ReactTagRenderer = ((children: React.ReactNode[]) => React.ReactNode) | React.ReactNode;
+/** Mapping of semantic rich tags to React renderers. */
 export type ReactTagRenderers<RichSchema = Rich> = {
-    [K in keyof RichSchema]: ReactTagRenderer<RichSchema[K]>;
+    [K in keyof RichSchema]: ReactTagRenderer;
 } & Record<string, ReactTagRenderer>;
 export {};

package/dist/types/src/client/react/translator/trans.d.ts

@@ -1,7 +1,7 @@
 import type { ReactTagRenderers } from "../render";
-import type { GenConfigKeys, GenMessages, GenReplacements } from "../../../core";
-import type { LocalizedKey, LocalizedReplacement, Replacement } from "intor-translator";
-type TransProps<CK extends GenConfigKeys = "__default__", K extends string = LocalizedKey<GenMessages<CK>>, R extends Replacement = LocalizedReplacement<GenReplacements<CK>, K>> = {
+import type { GenConfigKeys, GenMessages, GenReplacements, GenRich } from "../../../core";
+import type { LocalizedKey, LocalizedReplacement, LocalizedRich, Replacement } from "intor-translator";
+type TransProps<CK extends GenConfigKeys = "__default__", K extends string = LocalizedKey<GenMessages<CK>>, RI = LocalizedRich<GenRich<CK>, K>, RE extends Replacement = LocalizedReplacement<GenReplacements<CK>, K>> = {
     /** The message key to translate. */
     i18nKey: K | (string & {});
     /**
@@ -10,13 +10,13 @@ type TransProps<CK extends GenConfigKeys = "__default__", K extends string = Loc
      * Maps a tag name to either a React node or a render function,
      * allowing customization of rich tag rendering.
      */
-    components?: ReactTagRenderers;
+    components?: ReactTagRenderers<RI>;
     /**
      * Optional replacement values for message interpolation.
      *
      * These values are passed to the underlying translator.
      */
-    values?: R | Replacement;
+    values?: RE | Replacement;
 };
 /**
  * `<Trans />` is a lightweight React component for rendering rich translations.

package/dist/types/src/client/svelte/helpers/create-intor.d.ts

@@ -0,0 +1,4 @@
+import type { IntorValue } from "../store";
+import type { IntorResolvedConfig } from "../../../config";
+import type { Locale, LocaleMessages } from "intor-translator";
+export declare function createIntor(config: IntorResolvedConfig, loader: (locale: Locale) => Promise<LocaleMessages>): Omit<IntorValue, "handlers" | "plugins">;

package/dist/types/src/client/svelte/helpers/index.d.ts

@@ -1 +1 @@
-export { createRuntimeState } from "./create-runtime-state";
+export { createIntor } from "./create-intor";

package/dist/types/src/client/svelte/index.d.ts

@@ -1,3 +1,3 @@
-export { createIntor, type IntorRuntime } from "./runtime";
-export { createRuntimeState } from "./helpers";
+export { createIntorStore, type IntorStore } from "./store";
+export { createIntor } from "./helpers";
 export { getClientLocale } from "../shared/helpers";

package/dist/types/src/client/svelte/store/create-intor-store.d.ts

@@ -0,0 +1,2 @@
+import type { IntorValue, IntorStore } from "./types";
+export declare function createIntorStore({ config, locale: initialLocale, messages, handlers, plugins, onLocaleChange, isLoading: externalIsLoading, }: IntorValue): IntorStore;

package/dist/types/src/client/svelte/{runtime/create-intor-api.d.ts → store/create-translator-bindings.d.ts}

@@ -2,7 +2,7 @@ import type { Translator } from "intor-translator";
 import type { Replacement } from "intor-translator";
 import { type Readable } from "svelte/store";
 import { type SvelteTagRenderers } from "../render";
-export declare function createIntorApi(translator: Readable<Translator>): {
+export declare function createTranslatorBindings(translator: Readable<Translator>): {
     scoped: (preKey: string) => {
         scoped: /*elided*/ any;
         t: Readable<(key: string, replacements?: Replacement) => string>;

package/dist/types/src/client/svelte/store/index.d.ts

@@ -0,0 +1,2 @@
+export { createIntorStore } from "./create-intor-store";
+export type { IntorValue, IntorStore } from "./types";

package/dist/types/src/client/svelte/{runtime → store}/types.d.ts

@@ -2,16 +2,16 @@ import type { SvelteTagRenderers } from "../render";
 import type { IntorResolvedConfig } from "../../../config";
 import type { Locale, Replacement, LocaleMessages, TranslateHandlers, TranslateHook, TranslatorPlugin } from "intor-translator";
 import type { Readable, Writable } from "svelte/store";
-export type CreateIntorOptions = {
+export type IntorValue = {
     config: IntorResolvedConfig;
     locale: Locale;
     messages?: Readable<LocaleMessages>;
     isLoading?: Readable<boolean>;
+    onLocaleChange?: (newLocale: Locale) => Promise<void> | void;
     handlers?: TranslateHandlers;
     plugins?: (TranslatorPlugin | TranslateHook)[];
-    onLocaleChange?: (newLocale: Locale) => Promise<void> | void;
 };
-export type IntorRuntime = {
+export type IntorStore = {
     /** `messages`: The message object containing all translations. */
     messages: Readable<LocaleMessages>;
     /** Current locale in use. */

package/dist/types/src/client/vue/helpers/index.d.ts

@@ -1 +1 @@
-export { useRuntimeState } from "./use-runtime-state";
+export { useIntor } from "./use-intor";

package/dist/types/src/client/vue/helpers/use-intor.d.ts

@@ -0,0 +1,4 @@
+import type { IntorValue } from "../provider";
+import type { IntorResolvedConfig } from "../../../config";
+import type { Locale, LocaleMessages } from "intor-translator";
+export declare function useIntor(config: IntorResolvedConfig, loader: (locale: Locale) => Promise<LocaleMessages>): Omit<IntorValue, "handlers" | "plugins">;

package/dist/types/src/client/vue/index.d.ts

@@ -1,4 +1,4 @@
-export { IntorProvider } from "./provider";
+export { IntorProvider, injectIntor } from "./provider";
 export { useTranslator, Trans } from "./translator";
-export { useRuntimeState } from "./helpers";
+export { useIntor } from "./helpers";
 export { getClientLocale } from "../shared/helpers";

package/dist/types/src/client/vue/provider/index.d.ts

@@ -1,2 +1,3 @@
 export { IntorProvider } from "./intor-provider";
+export type { IntorValue } from "./types";
 export { injectIntor } from "./inject";

package/dist/types/src/client/vue/provider/types.d.ts

@@ -1,22 +1,22 @@
-import type { RuntimeState } from "../helpers/use-runtime-state";
 import type { IntorResolvedConfig } from "../../../config";
 import type { Locale, LocaleMessages, Translator } from "intor-translator";
 import type { TranslateHandlers, TranslateHook, TranslatorPlugin } from "intor-translator";
-export interface IntorProviderProps {
-    config?: IntorResolvedConfig;
-    locale?: Locale;
-    messages?: Readonly<LocaleMessages>;
-    isLoading?: boolean;
+import type { ComputedRef, Ref } from "vue";
+export interface IntorValue {
+    config: IntorResolvedConfig;
+    locale: Locale;
+    messages?: Ref<LocaleMessages>;
+    isLoading?: Ref<boolean>;
+    onLocaleChange?: (newLocale: Locale) => Promise<void> | void;
     handlers?: TranslateHandlers;
     plugins?: (TranslatorPlugin | TranslateHook)[];
-    onLocaleChange?: (newLocale: Locale) => Promise<void> | void;
-    runtimeState?: RuntimeState;
+}
+export interface IntorProviderProps {
+    value: IntorValue;
 }
 export type IntorContextValue = {
     config: IntorResolvedConfig;
-    locale: Locale;
+    locale: Ref<string>;
     setLocale: (locale: Locale) => void;
-    messages: Readonly<LocaleMessages>;
-    isLoading: boolean;
-    translator: Translator<unknown>;
+    translator: ComputedRef<Translator<unknown>>;
 };

package/dist/types/src/client/vue/render/create-vue-renderer.d.ts

@@ -3,17 +3,5 @@ import type { Renderer } from "intor-translator";
 import type { VNodeChild } from "vue";
 /**
  * Create a Vue renderer for semantic rich messages.
- *
- * Transforms semantic AST nodes into Vue VNodes.
- * Used together with `render` / `renderRichMessage`.
- *
- * - Text nodes → plain strings
- * - Tag nodes → custom renderer or native element
- * - Raw nodes → rendered as-is by the renderer
- *
- * This renderer is intentionally minimal and stateless.
  */
-export declare const createVueRenderer: (options?: {
-    /** Optional custom renderers for semantic tags */
-    tagRenderers?: VueTagRenderers;
-}) => Renderer<VNodeChild>;
+export declare const createVueRenderer: (tagRenderers?: VueTagRenderers) => Renderer<VNodeChild>;

package/dist/types/src/client/vue/render/types.d.ts

@@ -1,23 +1,9 @@
-import type { Attributes, Rich } from "intor-translator";
+import type { Rich } from "intor-translator";
 import type { VNodeChild } from "vue";
-/**
- * A renderer for a semantic tag in a rich message.
- *
- * - `children` are the rendered inner nodes of the tag
- * - `attributes` include both schema-defined and runtime attributes
- */
-type VueTagRenderer<A = Attributes> = (children: VNodeChild[], attributes: A & Attributes) => VNodeChild;
-/**
- * A mapping of semantic tag names to Vue renderers.
- *
- * - Known tags are strongly typed based on the generated rich schema
- * - Unknown tags fall back to a generic renderer signature
- *
- * This design ensures:
- * - Accurate autocompletion for generated tags
- * - Fail-soft behavior for dynamic or newly added tags
- */
+/** Renderer function for a semantic rich tag. */
+type VueTagRenderer = (children: VNodeChild[]) => VNodeChild | VNodeChild;
+/** Mapping of semantic rich tags to Vue renderers. */
 export type VueTagRenderers<RichSchema = Rich> = {
-    [K in keyof RichSchema]: VueTagRenderer<RichSchema[K]>;
+    [K in keyof RichSchema]: VueTagRenderer;
 } & Record<string, VueTagRenderer>;
 export {};

package/dist/types/src/server/index.d.ts

@@ -1,4 +1,4 @@
-export { intor, type ServerSnapshot } from "./intor";
+export { intor, type IntorValue } from "./intor";
 export { loadMessages } from "./messages";
 export { type TranslatorInstanceServer } from "./translator";
 export { getTranslator, type GetTranslatorParams, loadMessagesFromUrl, } from "./helpers";

package/dist/types/src/server/intor/index.d.ts

@@ -1,2 +1,2 @@
 export { intor } from "./intor";
-export type { ServerSnapshot } from "./types";
+export type { IntorValue } from "./types";

package/dist/types/src/server/intor/intor.d.ts

@@ -1,11 +1,12 @@
-import type { LocaleResolver, ServerSnapshot } from "./types";
+import type { LocaleResolver, IntorValue } from "./types";
 import type { IntorRuntimeOptions } from "../runtime";
 import type { IntorResolvedConfig } from "../../config";
-import { type GenConfigKeys, type GenLocale } from "../../core";
+import type { Locale } from "intor-translator";
+import { type GenConfigKeys } from "../../core";
 /**
  * Initializes Intor for the current execution context.
  *
  * Produces a server-side snapshot for SSR and
  * full-stack rendering environments.
  */
-export declare function intor<CK extends GenConfigKeys = "__default__">(config: IntorResolvedConfig, localeOrResolver: LocaleResolver<CK> | GenLocale<CK>, options?: IntorRuntimeOptions): Promise<ServerSnapshot<CK>>;
+export declare function intor<CK extends GenConfigKeys = "__default__">(config: IntorResolvedConfig, localeOrResolver: LocaleResolver | Locale, options?: IntorRuntimeOptions): Promise<IntorValue<CK>>;

package/dist/types/src/server/intor/types.d.ts

@@ -1,7 +1,8 @@
 import type { IntorResolvedConfig } from "../../config";
+import type { Locale } from "intor-translator";
 import { type GenConfigKeys, type GenLocale, type GenMessages } from "../../core";
-export type LocaleResolver<CK extends GenConfigKeys = "__default__"> = (config: IntorResolvedConfig) => GenLocale<CK> | Promise<GenLocale<CK>>;
-export interface ServerSnapshot<CK extends GenConfigKeys = "__default__"> {
+export type LocaleResolver = (config: IntorResolvedConfig) => Locale | Promise<Locale>;
+export interface IntorValue<CK extends GenConfigKeys = "__default__"> {
     config: IntorResolvedConfig;
     locale: GenLocale<CK>;
     messages: Readonly<GenMessages<CK>>;

package/dist/types/src/server/translator/create-translator.d.ts

@@ -23,6 +23,6 @@ export declare function createTranslator(params: CreateTranslatorParams & {
     messages: LocaleMessages;
     locale: string;
     hasKey: <K extends string>(key: K, targetLocale?: string | undefined) => boolean;
-    t: <K extends string = string>(key: K, replacements?: import("intor-translator").Replacement | undefined) => import("intor-translator").MessageValue;
+    t: <K extends string = string>(key: K, replacements?: import("intor-translator").Replacement | undefined) => string;
 };
 export {};

package/dist/vue/export/vue/index.js

@@ -2,5 +2,5 @@ export { IntorProvider } from '../../src/client/vue/provider/intor-provider.js';
 import 'vue';
 export { useTranslator } from '../../src/client/vue/translator/use-translator.js';
 export { Trans } from '../../src/client/vue/translator/trans.js';
-export { useRuntimeState } from '../../src/client/vue/helpers/use-runtime-state.js';
+export { useIntor } from '../../src/client/vue/helpers/use-intor.js';
 export { getClientLocale } from '../../src/client/shared/helpers/get-client-locale.js';

package/dist/vue/src/client/vue/helpers/{use-runtime-state.js → use-intor.js}

@@ -4,7 +4,7 @@ import 'logry';
 import { mergeMessages } from '../../../core/messages/merge-messages.js';
 import { getClientLocale } from '../../shared/helpers/get-client-locale.js';
 
-function useRuntimeState(config, loader) {
+function useIntor(config, loader) {
     // ---------------------------------------------------------------------------
     // Initial locale
     // ---------------------------------------------------------------------------
@@ -44,4 +44,4 @@ function useRuntimeState(config, loader) {
     };
 }
 
-export { useRuntimeState };
+export { useIntor };

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

@@ -2,27 +2,17 @@ import { Translator } from 'intor-translator';
 import { defineComponent, ref, computed, provide } from 'vue';
 import { useLocaleEffects } from './effects/use-locale-effects.js';
 import { useMessagesEffects } from './effects/use-messages-effects.js';
-import { resolveRuntime } from './resolver/resolve-runtime.js';
 
 const IntorContextKey = Symbol("IntorContext");
 const IntorProvider = defineComponent({
     name: "IntorProvider",
-    props: {
-        config: { type: Object, required: false },
-        locale: { type: String, required: false },
-        messages: { type: Object, required: false },
-        handlers: { type: Object, required: false },
-        plugins: { type: Array, required: false },
-        onLocaleChange: { type: Function, required: false },
-        isLoading: { type: Boolean, required: false },
-        runtimeState: { type: Object, required: false },
-    },
+    props: { value: { type: Object, required: true } },
     setup(props, { slots }) {
-        const { config, locale: initialLocale, messages, handlers, plugins, onLocaleChange, isLoading: externalIsLoading, } = resolveRuntime(props);
+        const { config, locale: initialLocale, messages, handlers, plugins, onLocaleChange, isLoading: externalIsLoading, } = props.value;
         // ---------------------------------------------------------------------------
         // Internal state
         // ---------------------------------------------------------------------------
-        const locale = ref(initialLocale.value);
+        const locale = ref(initialLocale);
         const runtimeMessages = ref(null);
         const internalIsLoading = ref(false);
         // ---------------------------------------------------------------------------
@@ -34,15 +24,15 @@ const IntorProvider = defineComponent({
                 return;
             locale.value = newLocale;
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            onLocaleChange?.value?.(newLocale); // Notify external listener (fire-and-forget)
+            onLocaleChange?.(newLocale); // Notify external listener (fire-and-forget)
         };
         // ---------------------------------------------------------------------------
         // Effective state
         // ---------------------------------------------------------------------------
         // external > internal
-        const effectiveIsLoading = computed(() => !!externalIsLoading.value || internalIsLoading.value);
+        const effectiveIsLoading = computed(() => !!externalIsLoading?.value || internalIsLoading.value);
         // runtime (client refetch) > initial > config (static)
-        const effectiveMessages = computed(() => runtimeMessages.value || messages.value || config.value.messages || {});
+        const effectiveMessages = computed(() => runtimeMessages.value || messages?.value || config.messages || {});
         // ---------------------------------------------------------------------------
         // Translator
         // ---------------------------------------------------------------------------
@@ -51,25 +41,23 @@ const IntorProvider = defineComponent({
                 messages: effectiveMessages.value,
                 locale: locale.value,
                 isLoading: effectiveIsLoading.value,
-                fallbackLocales: config.value.fallbackLocales,
-                loadingMessage: config.value.translator?.loadingMessage,
-                missingMessage: config.value.translator?.missingMessage,
-                handlers: handlers?.value,
-                plugins: plugins?.value,
+                fallbackLocales: config.fallbackLocales,
+                loadingMessage: config.translator?.loadingMessage,
+                missingMessage: config.translator?.missingMessage,
+                handlers: handlers,
+                plugins: plugins,
             });
         });
         // -------------------------------------------------------------------------
         // Side effects
         // -------------------------------------------------------------------------
-        useLocaleEffects(config.value, locale);
-        useMessagesEffects(config.value, locale, runtimeMessages, internalIsLoading);
+        useLocaleEffects(config, locale);
+        useMessagesEffects(config, locale, runtimeMessages, internalIsLoading);
         const contextValue = computed(() => ({
-            config: config.value,
-            locale: locale.value,
+            config,
+            locale,
             setLocale,
-            messages: effectiveMessages.value,
-            isLoading: effectiveIsLoading.value,
-            translator: translator.value,
+            translator,
         }));
         provide(IntorContextKey, contextValue);
         return () => slots.default?.();

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

@@ -2,34 +2,24 @@ import { h } from 'vue';
 
 /**
  * Create a Vue renderer for semantic rich messages.
- *
- * Transforms semantic AST nodes into Vue VNodes.
- * Used together with `render` / `renderRichMessage`.
- *
- * - Text nodes → plain strings
- * - Tag nodes → custom renderer or native element
- * - Raw nodes → rendered as-is by the renderer
- *
- * This renderer is intentionally minimal and stateless.
  */
-const createVueRenderer = (options) => {
-    const { tagRenderers } = options ?? {};
+const createVueRenderer = (tagRenderers) => {
     return {
         /** Render plain text nodes */
         text(value) {
             return value;
         },
         /** Render semantic tag nodes */
-        tag(name, attributes, children) {
-            const renderer = tagRenderers?.[name];
+        tag(name, _attributes, children) {
             // Custom tag renderer
-            if (renderer) {
-                return typeof renderer === "function"
-                    ? renderer(children, attributes)
-                    : renderer;
+            const tagRenderer = tagRenderers?.[name];
+            if (tagRenderer) {
+                return typeof tagRenderer === "function"
+                    ? tagRenderer(children)
+                    : tagRenderer;
             }
             // Default behavior: render as a native Vue element
-            return h(name, attributes, children);
+            return h(name, null, children);
         },
         /** Render raw (non-tokenized) message values */
         raw(value) {

package/dist/vue/src/client/vue/render/render-rich-message-vue.js

@@ -12,7 +12,7 @@ import { createVueRenderer } from './create-vue-renderer.js';
  * This function is intended for Vue environments only.
  */
 function renderRichMessageVue(message, tagRenderers) {
-    const vueRenderer = createVueRenderer({ tagRenderers });
+    const vueRenderer = createVueRenderer(tagRenderers);
     return renderRichMessage(message, vueRenderer);
 }
 

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

@@ -6,7 +6,7 @@ import { createTRich } from './create-t-rich.js';
 // Implementation
 function useTranslator(preKey) {
     const intor = injectIntor();
-    const translator = computed(() => intor.value.translator);
+    const translator = intor.value.translator;
     const scoped = computed(() => preKey ? translator.value.scoped(preKey) : translator.value);
     const hasKey = computed(() => scoped.value.hasKey);
     const t = computed(() => scoped.value.t);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "intor",
-  "version": "2.3.16",
+  "version": "2.3.18",
   "description": "The i18n library for modern JavaScript",
   "author": "Yiming Liao",
   "homepage": "https://github.com/yiming-liao/intor#readme",
@@ -100,7 +100,7 @@
     "examples:html": "vite --config examples/html/vite.config.ts"
   },
   "dependencies": {
-    "intor-translator": "^1.4.11",
+    "intor-translator": "1.4.13",
     "logry": "2.1.6",
     "p-limit": "7.2.0"
   },
@@ -112,7 +112,7 @@
     "@testing-library/jest-dom": "6.9.1",
     "@testing-library/react": "16.3.1",
     "@testing-library/user-event": "14.6.1",
-    "@types/express": "^5.0.6",
+    "@types/express": "5.0.6",
     "@types/node": "24.10.1",
     "@types/react": "19.0.0",
     "@types/react-dom": "19.0.0",

package/dist/types/src/client/react/helpers/use-runtime-state.d.ts

@@ -1,12 +0,0 @@
-import type { IntorResolvedConfig } from "../../../config";
-import type { GenConfigKeys, GenLocale, GenMessages } from "../../../core";
-import type { LocaleMessages } from "intor-translator";
-interface RuntimeState<CK extends GenConfigKeys = "__default__"> {
-    config: IntorResolvedConfig;
-    locale: GenLocale<CK>;
-    messages: GenMessages<CK>;
-    onLocaleChange: (locale: GenLocale<CK>) => Promise<void>;
-    isLoading: boolean;
-}
-export declare function useRuntimeState<CK extends GenConfigKeys = "__default__">(config: IntorResolvedConfig, loader: (locale: string) => Promise<LocaleMessages>): RuntimeState<CK>;
-export {};

package/dist/types/src/client/react/provider/use-intor.d.ts

@@ -1,3 +0,0 @@
-import type { IntorContextValue } from "./types";
-import type { GenConfigKeys } from "../../../core";
-export declare function useIntor<CK extends GenConfigKeys = "__default__">(): IntorContextValue<CK>;

package/dist/types/src/client/svelte/helpers/create-runtime-state.d.ts

@@ -1,12 +0,0 @@
-import type { IntorResolvedConfig } from "../../../config";
-import type { Locale, LocaleMessages } from "intor-translator";
-import { type Writable } from "svelte/store";
-interface RuntimeState {
-    config: IntorResolvedConfig;
-    locale: Locale;
-    messages: Writable<LocaleMessages>;
-    onLocaleChange: (locale: Locale) => Promise<void>;
-    isLoading: Writable<boolean>;
-}
-export declare function createRuntimeState(config: IntorResolvedConfig, loader: (locale: Locale) => Promise<LocaleMessages>): RuntimeState;
-export {};

package/dist/types/src/client/svelte/runtime/create-intor.d.ts

@@ -1,2 +0,0 @@
-import type { CreateIntorOptions, IntorRuntime } from "./types";
-export declare function createIntor({ config, locale: initialLocale, messages, handlers, plugins, onLocaleChange, isLoading: externalIsLoading, }: CreateIntorOptions): IntorRuntime;

package/dist/types/src/client/svelte/runtime/index.d.ts

@@ -1,2 +0,0 @@
-export { createIntor } from "./create-intor";
-export type { IntorRuntime } from "./types";

package/dist/types/src/client/vue/helpers/use-runtime-state.d.ts

@@ -1,11 +0,0 @@
-import type { IntorResolvedConfig } from "../../../config";
-import type { Locale, LocaleMessages } from "intor-translator";
-import { type Ref } from "vue";
-export interface RuntimeState {
-    config: IntorResolvedConfig;
-    locale: Locale;
-    messages: Ref<LocaleMessages>;
-    onLocaleChange: (locale: Locale) => Promise<void>;
-    isLoading: Ref<boolean>;
-}
-export declare function useRuntimeState(config: IntorResolvedConfig, loader: (locale: Locale) => Promise<LocaleMessages>): RuntimeState;

package/dist/types/src/client/vue/provider/resolver/resolve-runtime.d.ts

@@ -1,10 +0,0 @@
-import type { IntorProviderProps } from "../types";
-export declare function resolveRuntime(props: IntorProviderProps): {
-    config: import("vue").ComputedRef<import("../../../../config").IntorResolvedConfig>;
-    locale: import("vue").ComputedRef<string>;
-    messages: import("vue").ComputedRef<import("intor-translator").LocaleMessages | undefined>;
-    isLoading: import("vue").ComputedRef<boolean>;
-    onLocaleChange: import("vue").ComputedRef<((newLocale: import("intor-translator").Locale) => Promise<void> | void) | undefined>;
-    handlers: import("vue").Ref<import("intor-translator").TranslateHandlers | undefined, import("intor-translator").TranslateHandlers | undefined> | undefined;
-    plugins: import("vue").Ref<(import("intor-translator").TranslatorPlugin | import("intor-translator").TranslateHook)[] | undefined, (import("intor-translator").TranslatorPlugin | import("intor-translator").TranslateHook)[] | undefined> | undefined;
-};

package/dist/vue/src/client/vue/provider/resolver/resolve-runtime.js

@@ -1,32 +0,0 @@
-import { toRefs, computed } from 'vue';
-
-function resolveRuntime(props) {
-    const reactiveProps = toRefs(props);
-    const runtimeState = computed(() => props.runtimeState);
-    return {
-        config: computed(() => {
-            const value = runtimeState.value?.config ?? reactiveProps.config?.value;
-            if (!value) {
-                throw new Error("[Intor] Missing `config`. Provide either `runtimeState.config` or `config` prop.");
-            }
-            return value;
-        }),
-        locale: computed(() => {
-            const value = runtimeState.value?.locale ?? reactiveProps.locale?.value;
-            if (!value) {
-                throw new Error("[Intor] Missing `locale`. Provide either `runtimeState.locale` or `locale` prop.");
-            }
-            return value;
-        }),
-        messages: computed(() => runtimeState.value?.messages?.value ?? reactiveProps.messages?.value),
-        isLoading: computed(() => runtimeState.value?.isLoading?.value ??
-            reactiveProps.isLoading?.value ??
-            false),
-        onLocaleChange: computed(() => runtimeState.value?.onLocaleChange ??
-            reactiveProps.onLocaleChange?.value),
-        handlers: reactiveProps.handlers,
-        plugins: reactiveProps.plugins,
-    };
-}
-
-export { resolveRuntime };