intor 2.4.14 → 2.4.16

package/dist/next/src/core/locale/parse-locale.js

@@ -0,0 +1,27 @@
+/**
+ * Parses a canonical locale tag into structural components.
+ *
+ * - Uses `Intl.Locale` when available.
+ * - Falls back to minimal parsing (language only) if unavailable.
+ *
+ * This function does not validate or match locales.
+ */
+function parseLocale(tag) {
+    try {
+        if (typeof Intl !== "undefined" && typeof Intl.Locale === "function") {
+            const locale = new Intl.Locale(tag);
+            return {
+                language: locale.language,
+                script: locale.script,
+                region: locale.region,
+            };
+        }
+    }
+    catch {
+        // fallback below
+    }
+    const parts = tag.split("-");
+    return { language: parts[0].toLowerCase() };
+}
+
+export { parseLocale };

package/dist/next/src/routing/inbound/resolve-locale/resolve-locale.js

@@ -1,5 +1,5 @@
 import '../../../core/error/intor-error.js';
-import { normalizeLocale } from '../../../core/utils/normalizers/normalize-locale.js';
+import { matchLocale } from '../../../core/locale/match-locale.js';
 import 'logry';
 import 'p-limit';
 import 'intor-translator';
@@ -15,7 +15,7 @@ function resolveLocale(config, context) {
     const { localeSources } = config.routing.inbound;
     for (const source of localeSources) {
         const locale = context[source]?.locale;
-        const normalized = normalizeLocale(locale, config.supportedLocales);
+        const normalized = matchLocale(locale, config.supportedLocales);
         if (!normalized)
             continue;
         return {
@@ -24,7 +24,7 @@ function resolveLocale(config, context) {
         };
     }
     // Fallback: detected is always available
-    const fallback = normalizeLocale(context.detected.locale, config.supportedLocales) ||
+    const fallback = matchLocale(context.detected.locale, config.supportedLocales) ||
         config.defaultLocale;
     return {
         locale: fallback,

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/react/src/client/shared/helpers/get-client-locale.js

@@ -1,5 +1,5 @@
 import '../../../core/error/intor-error.js';
-import { normalizeLocale } from '../../../core/utils/normalizers/normalize-locale.js';
+import { matchLocale } from '../../../core/locale/match-locale.js';
 import 'logry';
 import 'p-limit';
 import 'intor-translator';
@@ -16,7 +16,7 @@ function getClientLocale(config) {
     // Locale from browser preference
     const browserLocale = detectBrowserLocale();
     const localeCandidate = cookieLocale || browserLocale;
-    return normalizeLocale(localeCandidate, supportedLocales) || defaultLocale;
+    return matchLocale(localeCandidate, supportedLocales) || defaultLocale;
 }
 
 export { getClientLocale };

package/dist/react/src/core/locale/canonicalize-locale.js

@@ -0,0 +1,23 @@
+/**
+ * Canonicalizes a BCP 47 locale string.
+ *
+ * - Uses `Intl.getCanonicalLocales` when available.
+ * - Returns the original input if `Intl` is unavailable.
+ * - Returns `undefined` for invalid locale input.
+ *
+ * This function performs normalization only.
+ * It does not perform matching or fallback.
+ */
+function canonicalizeLocale(input) {
+    try {
+        if (typeof Intl === "undefined" || !Intl.getCanonicalLocales) {
+            return input;
+        }
+        return Intl.getCanonicalLocales(input)[0];
+    }
+    catch {
+        return;
+    }
+}
+
+export { canonicalizeLocale };

package/dist/react/src/core/locale/match-locale.js

@@ -0,0 +1,57 @@
+import { canonicalizeLocale } from './canonicalize-locale.js';
+import { parseLocale } from './parse-locale.js';
+
+/**
+ * Matches a locale candidate against a list of supported locales.
+ *
+ * Resolution order:
+ * 1. Exact canonical match
+ * 2. Same language + same script
+ * 3. Same language only (only if candidate has no script)
+ *
+ * Returns `undefined` if no match is found.
+ *
+ * Notes:
+ * - Matching is deterministic and order-sensitive.
+ * - Does not perform automatic fallback to default locale.
+ * - Does not cross script boundaries.
+ */
+function matchLocale(locale, supportedLocales = []) {
+    if (!locale || supportedLocales.length === 0)
+        return;
+    const canonicalCandidate = canonicalizeLocale(locale);
+    if (!canonicalCandidate)
+        return;
+    const candidateParts = parseLocale(canonicalCandidate);
+    const supportedCanonical = supportedLocales.flatMap((original) => {
+        const canonical = canonicalizeLocale(original);
+        if (!canonical)
+            return [];
+        return [{ original, canonical, parts: parseLocale(canonical) }];
+    });
+    // 1. Exact match
+    for (const s of supportedCanonical) {
+        if (s.canonical === canonicalCandidate) {
+            return s.original;
+        }
+    }
+    // 2. Same language + same script
+    if (candidateParts.script) {
+        for (const s of supportedCanonical) {
+            if (s.parts.language === candidateParts.language &&
+                s.parts.script === candidateParts.script) {
+                return s.original;
+            }
+        }
+        return;
+    }
+    // 3. Same language only
+    for (const s of supportedCanonical) {
+        if (s.parts.language === candidateParts.language) {
+            return s.original;
+        }
+    }
+    return;
+}
+
+export { matchLocale };

package/dist/react/src/core/locale/parse-locale.js

@@ -0,0 +1,27 @@
+/**
+ * Parses a canonical locale tag into structural components.
+ *
+ * - Uses `Intl.Locale` when available.
+ * - Falls back to minimal parsing (language only) if unavailable.
+ *
+ * This function does not validate or match locales.
+ */
+function parseLocale(tag) {
+    try {
+        if (typeof Intl !== "undefined" && typeof Intl.Locale === "function") {
+            const locale = new Intl.Locale(tag);
+            return {
+                language: locale.language,
+                script: locale.script,
+                region: locale.region,
+            };
+        }
+    }
+    catch {
+        // fallback below
+    }
+    const parts = tag.split("-");
+    return { language: parts[0].toLowerCase() };
+}
+
+export { parseLocale };

package/dist/svelte/src/client/shared/helpers/get-client-locale.js

@@ -1,5 +1,5 @@
 import '../../../core/error/intor-error.js';
-import { normalizeLocale } from '../../../core/utils/normalizers/normalize-locale.js';
+import { matchLocale } from '../../../core/locale/match-locale.js';
 import 'logry';
 import 'p-limit';
 import 'intor-translator';
@@ -16,7 +16,7 @@ function getClientLocale(config) {
     // Locale from browser preference
     const browserLocale = detectBrowserLocale();
     const localeCandidate = cookieLocale || browserLocale;
-    return normalizeLocale(localeCandidate, supportedLocales) || defaultLocale;
+    return matchLocale(localeCandidate, supportedLocales) || defaultLocale;
 }
 
 export { getClientLocale };

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/svelte/src/core/locale/canonicalize-locale.js

@@ -0,0 +1,23 @@
+/**
+ * Canonicalizes a BCP 47 locale string.
+ *
+ * - Uses `Intl.getCanonicalLocales` when available.
+ * - Returns the original input if `Intl` is unavailable.
+ * - Returns `undefined` for invalid locale input.
+ *
+ * This function performs normalization only.
+ * It does not perform matching or fallback.
+ */
+function canonicalizeLocale(input) {
+    try {
+        if (typeof Intl === "undefined" || !Intl.getCanonicalLocales) {
+            return input;
+        }
+        return Intl.getCanonicalLocales(input)[0];
+    }
+    catch {
+        return;
+    }
+}
+
+export { canonicalizeLocale };

package/dist/svelte/src/core/locale/match-locale.js

@@ -0,0 +1,57 @@
+import { canonicalizeLocale } from './canonicalize-locale.js';
+import { parseLocale } from './parse-locale.js';
+
+/**
+ * Matches a locale candidate against a list of supported locales.
+ *
+ * Resolution order:
+ * 1. Exact canonical match
+ * 2. Same language + same script
+ * 3. Same language only (only if candidate has no script)
+ *
+ * Returns `undefined` if no match is found.
+ *
+ * Notes:
+ * - Matching is deterministic and order-sensitive.
+ * - Does not perform automatic fallback to default locale.
+ * - Does not cross script boundaries.
+ */
+function matchLocale(locale, supportedLocales = []) {
+    if (!locale || supportedLocales.length === 0)
+        return;
+    const canonicalCandidate = canonicalizeLocale(locale);
+    if (!canonicalCandidate)
+        return;
+    const candidateParts = parseLocale(canonicalCandidate);
+    const supportedCanonical = supportedLocales.flatMap((original) => {
+        const canonical = canonicalizeLocale(original);
+        if (!canonical)
+            return [];
+        return [{ original, canonical, parts: parseLocale(canonical) }];
+    });
+    // 1. Exact match
+    for (const s of supportedCanonical) {
+        if (s.canonical === canonicalCandidate) {
+            return s.original;
+        }
+    }
+    // 2. Same language + same script
+    if (candidateParts.script) {
+        for (const s of supportedCanonical) {
+            if (s.parts.language === candidateParts.language &&
+                s.parts.script === candidateParts.script) {
+                return s.original;
+            }
+        }
+        return;
+    }
+    // 3. Same language only
+    for (const s of supportedCanonical) {
+        if (s.parts.language === candidateParts.language) {
+            return s.original;
+        }
+    }
+    return;
+}
+
+export { matchLocale };

package/dist/svelte/src/core/locale/parse-locale.js

@@ -0,0 +1,27 @@
+/**
+ * Parses a canonical locale tag into structural components.
+ *
+ * - Uses `Intl.Locale` when available.
+ * - Falls back to minimal parsing (language only) if unavailable.
+ *
+ * This function does not validate or match locales.
+ */
+function parseLocale(tag) {
+    try {
+        if (typeof Intl !== "undefined" && typeof Intl.Locale === "function") {
+            const locale = new Intl.Locale(tag);
+            return {
+                language: locale.language,
+                script: locale.script,
+                region: locale.region,
+            };
+        }
+    }
+    catch {
+        // fallback below
+    }
+    const parts = tag.split("-");
+    return { language: parts[0].toLowerCase() };
+}
+
+export { parseLocale };

package/dist/svelte-kit/src/core/locale/canonicalize-locale.js

@@ -0,0 +1,23 @@
+/**
+ * Canonicalizes a BCP 47 locale string.
+ *
+ * - Uses `Intl.getCanonicalLocales` when available.
+ * - Returns the original input if `Intl` is unavailable.
+ * - Returns `undefined` for invalid locale input.
+ *
+ * This function performs normalization only.
+ * It does not perform matching or fallback.
+ */
+function canonicalizeLocale(input) {
+    try {
+        if (typeof Intl === "undefined" || !Intl.getCanonicalLocales) {
+            return input;
+        }
+        return Intl.getCanonicalLocales(input)[0];
+    }
+    catch {
+        return;
+    }
+}
+
+export { canonicalizeLocale };

package/dist/svelte-kit/src/core/locale/match-locale.js

@@ -0,0 +1,57 @@
+import { canonicalizeLocale } from './canonicalize-locale.js';
+import { parseLocale } from './parse-locale.js';
+
+/**
+ * Matches a locale candidate against a list of supported locales.
+ *
+ * Resolution order:
+ * 1. Exact canonical match
+ * 2. Same language + same script
+ * 3. Same language only (only if candidate has no script)
+ *
+ * Returns `undefined` if no match is found.
+ *
+ * Notes:
+ * - Matching is deterministic and order-sensitive.
+ * - Does not perform automatic fallback to default locale.
+ * - Does not cross script boundaries.
+ */
+function matchLocale(locale, supportedLocales = []) {
+    if (!locale || supportedLocales.length === 0)
+        return;
+    const canonicalCandidate = canonicalizeLocale(locale);
+    if (!canonicalCandidate)
+        return;
+    const candidateParts = parseLocale(canonicalCandidate);
+    const supportedCanonical = supportedLocales.flatMap((original) => {
+        const canonical = canonicalizeLocale(original);
+        if (!canonical)
+            return [];
+        return [{ original, canonical, parts: parseLocale(canonical) }];
+    });
+    // 1. Exact match
+    for (const s of supportedCanonical) {
+        if (s.canonical === canonicalCandidate) {
+            return s.original;
+        }
+    }
+    // 2. Same language + same script
+    if (candidateParts.script) {
+        for (const s of supportedCanonical) {
+            if (s.parts.language === candidateParts.language &&
+                s.parts.script === candidateParts.script) {
+                return s.original;
+            }
+        }
+        return;
+    }
+    // 3. Same language only
+    for (const s of supportedCanonical) {
+        if (s.parts.language === candidateParts.language) {
+            return s.original;
+        }
+    }
+    return;
+}
+
+export { matchLocale };

package/dist/svelte-kit/src/core/locale/parse-locale.js

@@ -0,0 +1,27 @@
+/**
+ * Parses a canonical locale tag into structural components.
+ *
+ * - Uses `Intl.Locale` when available.
+ * - Falls back to minimal parsing (language only) if unavailable.
+ *
+ * This function does not validate or match locales.
+ */
+function parseLocale(tag) {
+    try {
+        if (typeof Intl !== "undefined" && typeof Intl.Locale === "function") {
+            const locale = new Intl.Locale(tag);
+            return {
+                language: locale.language,
+                script: locale.script,
+                region: locale.region,
+            };
+        }
+    }
+    catch {
+        // fallback below
+    }
+    const parts = tag.split("-");
+    return { language: parts[0].toLowerCase() };
+}
+
+export { parseLocale };

package/dist/svelte-kit/src/routing/inbound/resolve-locale/resolve-locale.js

@@ -1,5 +1,5 @@
 import '../../../core/error/intor-error.js';
-import { normalizeLocale } from '../../../core/utils/normalizers/normalize-locale.js';
+import { matchLocale } from '../../../core/locale/match-locale.js';
 import 'logry';
 import 'p-limit';
 import 'intor-translator';
@@ -15,7 +15,7 @@ function resolveLocale(config, context) {
     const { localeSources } = config.routing.inbound;
     for (const source of localeSources) {
         const locale = context[source]?.locale;
-        const normalized = normalizeLocale(locale, config.supportedLocales);
+        const normalized = matchLocale(locale, config.supportedLocales);
         if (!normalized)
             continue;
         return {
@@ -24,7 +24,7 @@ function resolveLocale(config, context) {
         };
     }
     // Fallback: detected is always available
-    const fallback = normalizeLocale(context.detected.locale, config.supportedLocales) ||
+    const fallback = matchLocale(context.detected.locale, config.supportedLocales) ||
         config.defaultLocale;
     return {
         locale: fallback,

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

@@ -1,3 +1,4 @@
-export { LOCALE_PLACEHOLDER, IntorError, IntorErrorCode, clearLoggerPool, mergeMessages, type MessagesReader, type MessagesReaders, type GenLocale as Locale, } from "../src/core";
+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/core/index.d.ts

@@ -1,6 +1,7 @@
 export { LOCALE_PLACEHOLDER, INTOR_HEADERS } from "./constants";
 export { IntorError, IntorErrorCode } from "./error";
-export { deepMerge, type PlainObject, type DeepMergeOverrideEvent, resolveLoaderOptions, parseCookieHeader, normalizePathname, normalizeCacheKey, normalizeLocale, normalizeQuery, type NormalizedQuery, } from "./utils";
+export { deepMerge, type PlainObject, type DeepMergeOverrideEvent, resolveLoaderOptions, parseCookieHeader, normalizePathname, normalizeCacheKey, normalizeQuery, type NormalizedQuery, } from "./utils";
+export { matchLocale } from "./locale";
 export { getLogger, clearLoggerPool } from "./logger";
 export { loadRemoteMessages, mergeMessages, isValidMessages, nestObjectFromPath, type MessagesReader, type MessagesReaders, INTOR_PREFIX, INTOR_MESSAGES_KIND_KEY, INTOR_MESSAGES_KIND, getMessagesKind, type IntorMessagesKind, } from "./messages";
 export { createHtmlRenderer, type TagRenderers, type HtmlTagRenderers, } from "./render";

package/dist/types/src/core/locale/canonicalize-locale.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Canonicalizes a BCP 47 locale string.
+ *
+ * - Uses `Intl.getCanonicalLocales` when available.
+ * - Returns the original input if `Intl` is unavailable.
+ * - Returns `undefined` for invalid locale input.
+ *
+ * This function performs normalization only.
+ * It does not perform matching or fallback.
+ */
+export declare function canonicalizeLocale(input: string): string | undefined;

package/dist/types/src/core/locale/index.d.ts

@@ -0,0 +1 @@
+export { matchLocale } from "./match-locale";

package/dist/types/src/core/locale/match-locale.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Matches a locale candidate against a list of supported locales.
+ *
+ * Resolution order:
+ * 1. Exact canonical match
+ * 2. Same language + same script
+ * 3. Same language only (only if candidate has no script)
+ *
+ * Returns `undefined` if no match is found.
+ *
+ * Notes:
+ * - Matching is deterministic and order-sensitive.
+ * - Does not perform automatic fallback to default locale.
+ * - Does not cross script boundaries.
+ */
+export declare function matchLocale(locale: string | undefined, supportedLocales?: readonly string[]): string | undefined;

package/dist/types/src/core/locale/parse-locale.d.ts

@@ -0,0 +1,14 @@
+export type LocaleParts = {
+    language: string;
+    script?: string;
+    region?: string;
+};
+/**
+ * Parses a canonical locale tag into structural components.
+ *
+ * - Uses `Intl.Locale` when available.
+ * - Falls back to minimal parsing (language only) if unavailable.
+ *
+ * This function does not validate or match locales.
+ */
+export declare function parseLocale(tag: string): LocaleParts;

package/dist/types/src/core/utils/index.d.ts

@@ -1,4 +1,4 @@
 export { deepMerge, type PlainObject, type DeepMergeOverrideEvent, } from "./deep-merge";
 export { resolveLoaderOptions } from "./resolve-loader-options";
 export { parseCookieHeader } from "./parse-cookie-header";
-export { normalizeCacheKey, normalizeLocale, normalizePathname, normalizeQuery, type NormalizedQuery, } from "./normalizers";
+export { normalizeCacheKey, normalizePathname, normalizeQuery, type NormalizedQuery, } from "./normalizers";

package/dist/types/src/core/utils/normalizers/index.d.ts

@@ -1,4 +1,3 @@
 export { normalizeCacheKey } from "./normalize-cache-key";
 export { normalizePathname } from "./normalize-pathname";
-export { normalizeLocale } from "./normalize-locale";
 export { normalizeQuery, type NormalizedQuery } from "./normalize-query";

package/dist/vue/src/client/shared/helpers/get-client-locale.js

@@ -1,5 +1,5 @@
 import '../../../core/error/intor-error.js';
-import { normalizeLocale } from '../../../core/utils/normalizers/normalize-locale.js';
+import { matchLocale } from '../../../core/locale/match-locale.js';
 import 'logry';
 import 'p-limit';
 import 'intor-translator';
@@ -16,7 +16,7 @@ function getClientLocale(config) {
     // Locale from browser preference
     const browserLocale = detectBrowserLocale();
     const localeCandidate = cookieLocale || browserLocale;
-    return normalizeLocale(localeCandidate, supportedLocales) || defaultLocale;
+    return matchLocale(localeCandidate, supportedLocales) || defaultLocale;
 }
 
 export { getClientLocale };

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,