intor 2.4.15 → 2.4.17

package/dist/core/export/index.js

@@ -5,7 +5,7 @@ import 'logry';
 export { clearLoggerPool } from '../src/core/logger/global-logger-pool.js';
 import 'p-limit';
 export { mergeMessages } from '../src/core/messages/merge-messages.js';
-import 'intor-translator';
+export { Translator } from 'intor-translator';
 export { defineIntorConfig } from '../src/config/define-intor-config.js';
 import '../src/config/constants/cookie.js';
 export { localizePathname } from '../src/routing/pathname/localize-pathname.js';

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

@@ -57,6 +57,12 @@ function IntorProvider({ value: { config, locale: initialLocale, messages, handl
     // ---------------------------------------------------------------------------
     useLocaleEffects(config, locale);
     useMessagesEffects(config, locale, setRuntimeMessages, setInternalIsLoading);
+    // Sync internal locale with external prop
+    React.useEffect(() => {
+        if (initialLocale !== locale)
+            setLocaleState(initialLocale);
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [initialLocale]);
     return (jsx(IntorContext.Provider, { value: { config, locale, setLocale, translator }, children: children }));
 }
 

package/dist/svelte/src/client/svelte/provider/create-intor-store.js

@@ -26,7 +26,9 @@ function createIntorStore({ config, locale: initialLocale, messages, handlers, p
     // ---------------------------------------------------------------------------
     // Effective state
     // ---------------------------------------------------------------------------
-    const externalIsLoadingStore = readable(!!externalIsLoading);
+    const externalIsLoadingStore = typeof externalIsLoading === "object" && "subscribe" in externalIsLoading
+        ? externalIsLoading
+        : readable(!!externalIsLoading);
     // external > internal
     const effectiveIsLoading = derived([externalIsLoadingStore, internalIsLoading], ([$external, $internal]) => $external || $internal);
     // runtime (client refetch) > initial > config (static)

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

@@ -1,3 +1,4 @@
 export { LOCALE_PLACEHOLDER, IntorError, IntorErrorCode, matchLocale, clearLoggerPool, mergeMessages, type MessagesReader, type MessagesReaders, type GenLocale as Locale, } from "../src/core";
 export { defineIntorConfig, type IntorRawConfig, type IntorResolvedConfig, } from "../src/config";
 export { localizePathname, type InboundContext } from "../src/routing";
+export { Translator, type TranslatorPlugin, type TranslateContext, type TranslateHook, type TranslateHandlers, type HandlerContext, type FormatHandler, type LoadingHandler, type MissingHandler, type LocaleMessages, type MessageObject, type MessageValue, } from "intor-translator";

package/dist/types/src/client/react/translator/create-t-rich.d.ts

@@ -1,5 +1,5 @@
 import type { ReactTagRenderers } from "../render";
-import { type Replacement, type TranslatorMethods } from "intor-translator";
+import { type LocaleMessages, type Replacement, type TranslatorMethods } from "intor-translator";
 /**
  * Create a React-specific rich translation function.
  *
@@ -12,4 +12,4 @@ import { type Replacement, type TranslatorMethods } from "intor-translator";
  *
  * Intended for React client usage only.
  */
-export declare const createTRich: (t: TranslatorMethods["t"]) => (key: string, tagRenderers?: ReactTagRenderers, replacements?: Replacement) => import("react/jsx-runtime").JSX.Element[];
+export declare const createTRich: (t: TranslatorMethods<LocaleMessages>["t"]) => (key: string, tagRenderers?: ReactTagRenderers, replacements?: Replacement) => import("react/jsx-runtime").JSX.Element[];

package/dist/types/src/client/react/translator/translator-instance.d.ts

@@ -1,12 +1,12 @@
 import type { ReactTagRenderers } from "../render";
 import type { TranslatorInstance } from "../../../core";
 import type { JSX } from "react/jsx-runtime";
-import { type Locale, type LocaleMessages, type LocalizedKey, type LocalizedReplacement, type LocalizedRich, type Replacement, type Rich, type ScopedKey } from "intor-translator";
+import { type Locale, type LocaleMessages, type LocalizedKey, type LocalizedReplacement, type LocalizedRich, type Replacement, type Rich, type ScopedKey, type ScopedReplacement, type ScopedRich } from "intor-translator";
 export type TranslatorInstanceReact<M extends LocaleMessages, ReplacementSchema = Replacement, RichSchema = Rich, PK extends string | undefined = undefined> = Omit<TranslatorInstance<M, ReplacementSchema, RichSchema, PK>, "tRich"> & {
     /** Indicates whether translations are currently loading. */
     isLoading: boolean;
     /** Update the active locale. */
     setLocale: (locale: Locale<M>) => void;
     /** Translate a key into React nodes using semantic tags */
-    tRich: <K extends string = PK extends string ? ScopedKey<M, PK> : LocalizedKey<M>, RI = LocalizedRich<RichSchema, K>, RE = LocalizedReplacement<ReplacementSchema, K>>(key?: K | (string & {}), tagRenderers?: ReactTagRenderers<RI> | ReactTagRenderers, replacements?: RE | Replacement) => JSX.Element[];
+    tRich: <K extends string = PK extends string ? ScopedKey<M, PK> : LocalizedKey<M>, RI = PK extends string ? ScopedRich<RichSchema, PK, K> : LocalizedRich<RichSchema, K>, RE = PK extends string ? ScopedReplacement<ReplacementSchema, PK, K> : LocalizedReplacement<ReplacementSchema, K>>(key?: K | (string & {}), tagRenderers?: ReactTagRenderers<RI> | ReactTagRenderers, replacements?: RE | Replacement) => JSX.Element[];
 };

package/dist/types/src/client/vue/translator/create-t-rich.d.ts

@@ -1,5 +1,5 @@
 import type { VueTagRenderers } from "../../../client/vue/render";
-import { type Replacement, type TranslatorMethods } from "intor-translator";
+import { type LocaleMessages, type Replacement, type TranslatorMethods } from "intor-translator";
 /**
  * Create a Vue-specific rich translation function.
  *
@@ -12,4 +12,4 @@ import { type Replacement, type TranslatorMethods } from "intor-translator";
  *
  * Intended for Vue client usage only.
  */
-export declare const createTRich: (t: TranslatorMethods["t"]) => (key: string, tagRenderers?: VueTagRenderers, replacements?: Replacement) => import("vue").VNodeChild[];
+export declare const createTRich: (t: TranslatorMethods<LocaleMessages>["t"]) => (key: string, tagRenderers?: VueTagRenderers, replacements?: Replacement) => import("vue").VNodeChild[];

package/dist/types/src/client/vue/translator/translator-instance.d.ts

@@ -1,7 +1,7 @@
 import type { VueTagRenderers } from "../../../client/vue/render";
 import type { TranslatorInstance } from "../../../core";
 import type { ComputedRef, VNodeChild } from "vue";
-import { type Locale, type LocaleMessages, type LocalizedKey, type LocalizedReplacement, type LocalizedRich, type Replacement, type Rich, type ScopedKey } from "intor-translator";
+import { type Locale, type LocaleMessages, type LocalizedKey, type LocalizedReplacement, type LocalizedRich, type Replacement, type Rich, type ScopedKey, type ScopedReplacement, type ScopedRich } from "intor-translator";
 export type TranslatorInstanceVue<M extends LocaleMessages, ReplacementSchema = Replacement, RichSchema = Rich, PK extends string | undefined = undefined> = Omit<TranslatorInstance<M, ReplacementSchema, RichSchema, PK>, "tRich" | "messages" | "locale"> & {
     /** `messages`: The message object containing all translations. */
     messages: ComputedRef<M>;
@@ -12,5 +12,5 @@ export type TranslatorInstanceVue<M extends LocaleMessages, ReplacementSchema =
     /** Update the active locale. */
     setLocale: (locale: Locale<M>) => void;
     /** Translate a key into VNodes using semantic tags */
-    tRich: <K extends string = PK extends string ? ScopedKey<M, PK> : LocalizedKey<M>, RI = LocalizedRich<RichSchema, K>, RE = LocalizedReplacement<ReplacementSchema, K>>(key?: K | (string & {}), tagRenderers?: VueTagRenderers<RI> | VueTagRenderers, replacements?: RE | Replacement) => VNodeChild[];
+    tRich: <K extends string = PK extends string ? ScopedKey<M, PK> : LocalizedKey<M>, RI = PK extends string ? ScopedRich<RichSchema, PK, K> : LocalizedRich<RichSchema, K>, RE = PK extends string ? ScopedReplacement<ReplacementSchema, PK, K> : LocalizedReplacement<ReplacementSchema, K>>(key?: K | (string & {}), tagRenderers?: VueTagRenderers<RI> | VueTagRenderers, replacements?: RE | Replacement) => VNodeChild[];
 };

package/dist/types/src/core/translator/create-t-rich.d.ts

@@ -1,4 +1,4 @@
-import { type Replacement, type TranslatorMethods } from "intor-translator";
+import { type LocaleMessages, type Replacement, type TranslatorMethods } from "intor-translator";
 import { type TagRenderers } from "../render";
 /**
  * Create an HTML-string rich translation function.
@@ -9,4 +9,4 @@ import { type TagRenderers } from "../render";
  *
  * Can be used in any HTML-based environment (Astro, Svelte, SSR, etc.).
  */
-export declare const createTRich: (t: TranslatorMethods["t"]) => (key: string, tagRenderers?: TagRenderers, replacements?: Replacement) => string;
+export declare const createTRich: (t: TranslatorMethods<LocaleMessages>["t"]) => (key: string, tagRenderers?: TagRenderers, replacements?: Replacement) => string;

package/dist/types/src/core/types/translator-instance.d.ts

@@ -1,5 +1,5 @@
 import type { HtmlTagRenderers } from "../render";
-import { type Locale, type LocaleMessages, type LocalizedKey, type ScopedKey, type LocalizedValue, type ScopedValue, type Replacement, type LocalizedReplacement, type LocalizedRich, type Rich } from "intor-translator";
+import { type Locale, type LocaleMessages, type LocalizedKey, type ScopedKey, type LocalizedValue, type ScopedValue, type Replacement, type LocalizedReplacement, type LocalizedRich, type Rich, type ScopedRich, type ScopedReplacement } from "intor-translator";
 type FallbackIfNever<T, Fallback> = [T] extends [never] ? Fallback : T;
 /**
  * Core translator instance interface.
@@ -16,6 +16,6 @@ export type TranslatorInstance<M extends LocaleMessages, ReplacementSchema = Rep
     /** Translate a given key into its string representation. */
     t: <K extends string = PK extends string ? ScopedKey<M, PK> : LocalizedKey<M>, R extends Replacement = LocalizedReplacement<ReplacementSchema, K>>(key?: K | (string & {}), replacements?: R | Replacement) => FallbackIfNever<PK extends string ? ScopedValue<M, PK, K> : LocalizedValue<M, K>, string>;
     /** Translate a key into an HTML string using semantic rich tags. */
-    tRich: <K extends string = PK extends string ? ScopedKey<M, PK> : LocalizedKey<M>, RI = LocalizedRich<RichSchema, K>, RE = LocalizedReplacement<ReplacementSchema, K>>(key?: K | (string & {}), tagRenderers?: HtmlTagRenderers<RI> | HtmlTagRenderers, replacements?: RE | Replacement) => string;
+    tRich: <K extends string = PK extends string ? ScopedKey<M, PK> : LocalizedKey<M>, RI = PK extends string ? ScopedRich<RichSchema, PK, K> : LocalizedRich<RichSchema, K>, RE = PK extends string ? ScopedReplacement<ReplacementSchema, PK, K> : LocalizedReplacement<ReplacementSchema, K>>(key?: K | (string & {}), tagRenderers?: HtmlTagRenderers<RI> | HtmlTagRenderers, replacements?: RE | Replacement) => string;
 };
 export {};

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

@@ -1,5 +1,5 @@
 import { Translator } from 'intor-translator';
-import { defineComponent, ref, computed, provide } from 'vue';
+import { defineComponent, ref, computed, watch, provide } from 'vue';
 import { useLocaleEffects } from './effects/use-locale-effects.js';
 import { useMessagesEffects } from './effects/use-messages-effects.js';
 
@@ -8,11 +8,10 @@ const IntorProvider = defineComponent({
     name: "IntorProvider",
     props: { value: { type: Object, required: true } },
     setup(props, { slots }) {
-        const { config, locale: initialLocale, messages, handlers, plugins, onLocaleChange, isLoading: externalIsLoading, } = props.value;
         // ---------------------------------------------------------------------------
         // Internal state
         // ---------------------------------------------------------------------------
-        const locale = ref(initialLocale);
+        const locale = ref(props.value.locale);
         const runtimeMessages = ref(null);
         const internalIsLoading = ref(false);
         // ---------------------------------------------------------------------------
@@ -23,15 +22,18 @@ const IntorProvider = defineComponent({
             if (newLocale === locale.value)
                 return;
             locale.value = newLocale;
-            onLocaleChange?.(newLocale); // Notify external listener (fire-and-forget)
+            props.value.onLocaleChange?.(newLocale); // Notify external listener (fire-and-forget)
         };
         // ---------------------------------------------------------------------------
         // Effective state
         // ---------------------------------------------------------------------------
         // external > internal
-        const effectiveIsLoading = computed(() => !!externalIsLoading?.value || internalIsLoading.value);
+        const effectiveIsLoading = computed(() => !!props.value.isLoading?.value || internalIsLoading.value);
         // runtime (client refetch) > initial > config (static)
-        const effectiveMessages = computed(() => runtimeMessages.value || messages?.value || config.messages || {});
+        const effectiveMessages = computed(() => runtimeMessages.value ||
+            props.value.messages?.value ||
+            props.value.config.messages ||
+            {});
         // ---------------------------------------------------------------------------
         // Translator
         // ---------------------------------------------------------------------------
@@ -40,20 +42,25 @@ const IntorProvider = defineComponent({
                 messages: effectiveMessages.value,
                 locale: locale.value,
                 isLoading: effectiveIsLoading.value,
-                fallbackLocales: config.fallbackLocales,
-                loadingMessage: config.translator?.loadingMessage,
-                missingMessage: config.translator?.missingMessage,
-                handlers: handlers,
-                plugins: plugins,
+                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(config, locale);
-        useMessagesEffects(config, locale, runtimeMessages, internalIsLoading);
+        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,
+            config: props.value.config,
             locale,
             setLocale,
             translator,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "intor",
-  "version": "2.4.15",
+  "version": "2.4.17",
   "description": "The i18n library for modern JavaScript",
   "author": "Yiming Liao",
   "homepage": "https://intor.dev",
@@ -107,7 +107,7 @@
     "prepublishOnly": "yarn build"
   },
   "dependencies": {
-    "intor-translator": "^1.4.14",
+    "intor-translator": "^1.4.15",
     "logry": "2.1.6",
     "p-limit": "7.2.0"
   },