@bleedingdev/modern-js-plugin-i18n 3.5.0-ultramodern.6 → 3.5.0-ultramodern.75

package/dist/esm/runtime/context.mjs

@@ -1,9 +1,8 @@
 import { jsx } from "react/jsx-runtime";
-import { isBrowser } from "@modern-js/runtime";
 import { createContext, useCallback, useContext, useEffect, useMemo } from "react";
-import { cacheUserLanguage } from "./i18n/detection/index.mjs";
+import { changeModernI18nLanguage, getPathLanguage, isI18nLanguageSupported, isI18nResourcesReady, translateI18n } from "./contextHelpers.mjs";
+import { getActualI18nextInstance } from "./i18n/instance.mjs";
 import { useI18nRouterAdapter } from "./routerAdapter.mjs";
-import { buildLocalizedUrl, detectLanguageFromPath, getEntryPath, shouldIgnoreRedirect } from "./utils.mjs";
 const modernI18nContextKey = Symbol.for('@modern-js/plugin-i18n/runtime/ModernI18nContext');
 const getModernI18nContext = ()=>{
     const globalStore = globalThis;
@@ -15,76 +14,87 @@ const ModernI18nProvider = ({ children, value })=>/*#__PURE__*/ jsx(ModernI18nCo
         value: value,
         children: children
     });
+const FederatedI18nBoundary = ({ children, defaultNamespace, fallbackLanguage, resources, supportedLanguages })=>{
+    const parent = useContext(ModernI18nContext);
+    if (!parent) throw new Error('FederatedI18nBoundary must be used within ModernI18nProvider');
+    const languages = supportedLanguages ?? parent.languages ?? Object.keys(resources);
+    const scopedInstance = useMemo(()=>{
+        const parentInstance = getActualI18nextInstance(parent.i18nInstance);
+        const clone = parentInstance.cloneInstance?.({
+            defaultNS: defaultNamespace,
+            fallbackLng: fallbackLanguage ?? languages[0] ?? parent.language,
+            forkResourceStore: true,
+            initImmediate: false,
+            lng: parent.language,
+            ns: [
+                defaultNamespace
+            ],
+            resources,
+            supportedLngs: languages
+        });
+        if (!clone) throw new Error('FederatedI18nBoundary requires an i18n instance with cloneInstance support');
+        const resourceStore = clone.store;
+        const parentResourceStore = parentInstance.store;
+        const sharesNestedResourceState = Object.entries(resourceStore?.data ?? {}).some(([language, namespaces])=>{
+            const parentNamespaces = parentResourceStore?.data?.[language];
+            return namespaces === parentNamespaces || Object.entries(namespaces).some(([namespace, resource])=>null !== resource && 'object' == typeof resource && resource === parentNamespaces?.[namespace]);
+        });
+        if (clone === parentInstance || resourceStore === parentResourceStore || resourceStore?.data === parentResourceStore?.data || sharesNestedResourceState) throw new Error('FederatedI18nBoundary cloneInstance did not isolate the host resource store');
+        if (!resourceStore?.addResourceBundle || !clone.removeResourceBundle || !resourceStore.data) throw new Error('FederatedI18nBoundary requires an isolated mutable i18n resource store');
+        for (const [language, namespaces] of Object.entries(resourceStore.data))for (const namespace of Object.keys(namespaces))clone.removeResourceBundle(language, namespace);
+        for (const [language, namespaces] of Object.entries(resources))for (const [namespace, resource] of Object.entries(namespaces))resourceStore.addResourceBundle(language, namespace, resource, true, true);
+        return clone;
+    }, [
+        defaultNamespace,
+        fallbackLanguage,
+        languages,
+        parent.i18nInstance,
+        parent.language,
+        resources
+    ]);
+    const value = useMemo(()=>({
+            ...parent,
+            i18nInstance: scopedInstance,
+            language: parent.language,
+            languages
+        }), [
+        languages,
+        parent,
+        scopedInstance
+    ]);
+    return /*#__PURE__*/ jsx(ModernI18nProvider, {
+        value: value,
+        children: children
+    });
+};
 const useModernI18n = ()=>{
     const context = useContext(ModernI18nContext);
-    if (!context) throw new Error('useModernI18n must be used within a ModernI18nProvider');
-    const { language: contextLanguage, i18nInstance, languages, localePathRedirect, ignoreRedirectRoutes, localisedUrls, updateLanguage } = context;
+    if (!context) throw new Error('useModernI18n must be used within ModernI18nProvider');
+    const { language: contextLanguage, i18nInstance, languages, localePathRedirect, ignoreRedirectRoutes, localisedUrls, updateLanguage, synchronizeLanguage } = context;
     const { navigate, location, hasRouter } = useI18nRouterAdapter();
-    const pathLanguage = useMemo(()=>{
-        if (!localePathRedirect || !location?.pathname) return;
-        const detected = detectLanguageFromPath(location.pathname, languages || [], localePathRedirect);
-        return detected.detected ? detected.language : void 0;
-    }, [
+    const pathLanguage = useMemo(()=>getPathLanguage(location?.pathname, languages, localePathRedirect), [
         languages,
         localePathRedirect,
         location?.pathname
     ]);
-    const currentLanguage = pathLanguage || contextLanguage;
     useEffect(()=>{
-        if (!pathLanguage || pathLanguage === contextLanguage) return;
-        updateLanguage?.(pathLanguage);
-        i18nInstance?.setLang?.(pathLanguage);
-        i18nInstance?.changeLanguage?.(pathLanguage);
-        if (isBrowser()) {
-            const detectionOptions = i18nInstance.options?.detection;
-            cacheUserLanguage(i18nInstance, pathLanguage, detectionOptions);
-        }
+        if (pathLanguage) synchronizeLanguage?.(pathLanguage);
     }, [
-        contextLanguage,
-        i18nInstance,
         pathLanguage,
-        updateLanguage
+        synchronizeLanguage
     ]);
-    const changeLanguage = useCallback(async (newLang)=>{
-        try {
-            if (!newLang || 'string' != typeof newLang) throw new Error('Language must be a non-empty string');
-            await i18nInstance?.setLang?.(newLang);
-            await i18nInstance?.changeLanguage?.(newLang);
-            if (isBrowser()) {
-                const detectionOptions = i18nInstance.options?.detection;
-                cacheUserLanguage(i18nInstance, newLang, detectionOptions);
-            }
-            if (localePathRedirect && isBrowser() && hasRouter && navigate && location) {
-                const currentPath = location.pathname;
-                const entryPath = getEntryPath();
-                const relativePath = currentPath.replace(entryPath, '');
-                const pathLanguage = detectLanguageFromPath(currentPath, languages || [], localePathRedirect);
-                if (pathLanguage.detected && pathLanguage.language === newLang) return;
-                if (!shouldIgnoreRedirect(relativePath, languages || [], ignoreRedirectRoutes)) {
-                    const newPath = buildLocalizedUrl(relativePath, newLang, languages || [], localisedUrls);
-                    const newUrl = entryPath + newPath + location.search + location.hash;
-                    await navigate(newUrl, {
-                        replace: true
-                    });
-                }
-            } else if (localePathRedirect && isBrowser() && !hasRouter) {
-                const currentPath = window.location.pathname;
-                const entryPath = getEntryPath();
-                const relativePath = currentPath.replace(entryPath, '');
-                const pathLanguage = detectLanguageFromPath(currentPath, languages || [], localePathRedirect);
-                if (pathLanguage.detected && pathLanguage.language === newLang) return;
-                if (!shouldIgnoreRedirect(relativePath, languages || [], ignoreRedirectRoutes)) {
-                    const newPath = buildLocalizedUrl(relativePath, newLang, languages || [], localisedUrls);
-                    const newUrl = entryPath + newPath + window.location.search + window.location.hash;
-                    window.history.pushState(null, '', newUrl);
-                }
-            }
-            if (updateLanguage) updateLanguage(newLang);
-        } catch (error) {
-            console.error('Failed to change language:', error);
-            throw error;
-        }
-    }, [
+    const currentLanguage = contextLanguage;
+    const changeLanguage = useCallback((newLang)=>changeModernI18nLanguage(newLang, {
+            i18nInstance,
+            updateLanguage,
+            localePathRedirect,
+            ignoreRedirectRoutes,
+            localisedUrls,
+            languages,
+            hasRouter,
+            navigate,
+            location
+        }), [
         i18nInstance,
         updateLanguage,
         localePathRedirect,
@@ -95,40 +105,14 @@ const useModernI18n = ()=>{
         navigate,
         location
     ]);
-    const t = useCallback((key, ...args)=>{
-        if ('function' != typeof i18nInstance.t) throw new Error('i18nInstance.t is required');
-        return i18nInstance.t(key, ...args);
-    }, [
+    const t = useCallback((key, ...args)=>translateI18n(i18nInstance, key, ...args), [
         currentLanguage,
         i18nInstance
     ]);
-    const isLanguageSupported = useCallback((lang)=>languages?.includes(lang) || false, [
+    const isLanguageSupported = useCallback((lang)=>isI18nLanguageSupported(languages, lang), [
         languages
     ]);
-    const isResourcesReady = useMemo(()=>{
-        if (!i18nInstance?.isInitialized) return false;
-        const backend = i18nInstance?.services?.backend;
-        if (backend && 'function' == typeof backend.isLoading) {
-            const loadingResources = backend.getLoadingResources();
-            const isCurrentLanguageLoading = loadingResources.some(({ language })=>language === currentLanguage);
-            if (isCurrentLanguageLoading) return false;
-        }
-        const store = i18nInstance.store;
-        if (!store?.data) return false;
-        const langData = store.data[currentLanguage];
-        if (!langData || 'object' != typeof langData) return false;
-        const options = i18nInstance.options;
-        const namespaces = options?.ns || options?.defaultNS || [
-            'translation'
-        ];
-        const requiredNamespaces = Array.isArray(namespaces) ? namespaces : [
-            namespaces
-        ];
-        return requiredNamespaces.every((ns)=>{
-            const nsData = langData[ns];
-            return nsData && 'object' == typeof nsData && Object.keys(nsData).length > 0;
-        });
-    }, [
+    const isResourcesReady = useMemo(()=>isI18nResourcesReady(i18nInstance, currentLanguage), [
         currentLanguage,
         i18nInstance
     ]);
@@ -143,4 +127,4 @@ const useModernI18n = ()=>{
         isResourcesReady
     };
 };
-export { ModernI18nProvider, useModernI18n };
+export { FederatedI18nBoundary, ModernI18nProvider, useModernI18n };

package/dist/esm/runtime/contextHelpers.mjs

@@ -0,0 +1,87 @@
+import { isBrowser } from "@modern-js/runtime";
+import { cacheUserLanguage } from "./i18n/detection/index.mjs";
+import { buildLocalizedUrl, detectLanguageFromPath, getEntryPath, shouldIgnoreRedirect } from "./utils.mjs";
+function getPathLanguage(pathname, languages, localePathRedirect) {
+    if (!localePathRedirect || !pathname) return;
+    const detected = detectLanguageFromPath(pathname, languages || [], localePathRedirect);
+    return detected.detected ? detected.language : void 0;
+}
+function cacheI18nLanguage(i18nInstance, language) {
+    if (isBrowser()) {
+        const detectionOptions = i18nInstance.options?.detection;
+        cacheUserLanguage(i18nInstance, language, detectionOptions);
+    }
+}
+async function changeI18nInstanceLanguage(i18nInstance, language) {
+    if (i18nInstance.setLang) await i18nInstance.setLang(language);
+    else await i18nInstance.changeLanguage?.(language);
+}
+async function changeModernI18nLanguage(newLang, options) {
+    const { i18nInstance, updateLanguage, localePathRedirect, ignoreRedirectRoutes, localisedUrls, languages, hasRouter, navigate, location } = options;
+    try {
+        if (!newLang || 'string' != typeof newLang) throw new Error('Language must be non-empty string');
+        await changeI18nInstanceLanguage(i18nInstance, newLang);
+        cacheI18nLanguage(i18nInstance, newLang);
+        if (localePathRedirect && isBrowser() && hasRouter && navigate && location) {
+            const currentPath = location.pathname;
+            const entryPath = getEntryPath();
+            const relativePath = currentPath.replace(entryPath, '');
+            const pathLanguage = detectLanguageFromPath(currentPath, languages || [], localePathRedirect);
+            if (pathLanguage.detected && pathLanguage.language === newLang) return void updateLanguage?.(newLang);
+            if (!shouldIgnoreRedirect(relativePath, languages || [], ignoreRedirectRoutes)) {
+                const newPath = buildLocalizedUrl(relativePath, newLang, languages || [], localisedUrls);
+                const newUrl = entryPath + newPath + location.search + location.hash;
+                await navigate(newUrl, {
+                    replace: true
+                });
+            }
+        } else if (localePathRedirect && isBrowser() && !hasRouter) {
+            const currentPath = window.location.pathname;
+            const entryPath = getEntryPath();
+            const relativePath = currentPath.replace(entryPath, '');
+            const pathLanguage = detectLanguageFromPath(currentPath, languages || [], localePathRedirect);
+            if (pathLanguage.detected && pathLanguage.language === newLang) return void updateLanguage?.(newLang);
+            if (!shouldIgnoreRedirect(relativePath, languages || [], ignoreRedirectRoutes)) {
+                const newPath = buildLocalizedUrl(relativePath, newLang, languages || [], localisedUrls);
+                const newUrl = entryPath + newPath + window.location.search + window.location.hash;
+                window.history.pushState(null, '', newUrl);
+            }
+        }
+        if (updateLanguage) updateLanguage(newLang);
+    } catch (error) {
+        console.error('Failed change language:', error);
+        throw error;
+    }
+}
+function translateI18n(i18nInstance, key, ...args) {
+    if ('function' != typeof i18nInstance.t) throw new Error('i18nInstance.t required');
+    return i18nInstance.t(key, ...args);
+}
+function isI18nLanguageSupported(languages, lang) {
+    return languages?.includes(lang) || false;
+}
+function isI18nResourcesReady(i18nInstance, currentLanguage) {
+    if (!i18nInstance?.isInitialized) return false;
+    const backend = i18nInstance?.services?.backend;
+    if (backend && 'function' == typeof backend.isLoading) {
+        const loadingResources = backend.getLoadingResources();
+        const isCurrentLanguageLoading = loadingResources.some(({ language })=>language === currentLanguage);
+        if (isCurrentLanguageLoading) return false;
+    }
+    const store = i18nInstance.store;
+    if (!store?.data) return false;
+    const langData = store.data[currentLanguage];
+    if (!langData || 'object' != typeof langData) return false;
+    const options = i18nInstance.options;
+    const namespaces = options?.ns || options?.defaultNS || [
+        'translation'
+    ];
+    const requiredNamespaces = Array.isArray(namespaces) ? namespaces : [
+        namespaces
+    ];
+    return requiredNamespaces.every((ns)=>{
+        const nsData = langData[ns];
+        return nsData && 'object' == typeof nsData && Object.keys(nsData).length > 0;
+    });
+}
+export { cacheI18nLanguage, changeI18nInstanceLanguage, changeModernI18nLanguage, getPathLanguage, isI18nLanguageSupported, isI18nResourcesReady, translateI18n };

package/dist/esm/runtime/core.mjs

@@ -1,31 +1,7 @@
-import { Fragment, jsx, jsxs } from "react/jsx-runtime";
-import { RuntimeContext, isBrowser } from "@modern-js/runtime";
-import { Helmet } from "@modern-js/runtime/head";
-import { merge } from "@modern-js/runtime-utils/merge";
-import { useContext, useEffect, useMemo, useRef, useState } from "react";
-import { ModernI18nProvider, useModernI18n } from "./context.mjs";
-import { createContextValue, useClientSideRedirect, useLanguageSync, useSdkResourcesLoader } from "./hooks.mjs";
-import { getI18nInstance } from "./i18n/index.mjs";
-import { mergeBackendOptions } from "./i18n/backend/index.mjs";
-import { detectLanguageWithPriority, exportServerLngToWindow, mergeDetectionOptions } from "./i18n/detection/index.mjs";
-import { useI18nextLanguageDetector } from "./i18n/detection/middleware.mjs";
-import { getI18nextInstanceForProvider } from "./i18n/instance.mjs";
-import { buildLocalizedUrl, getPathname, splitUrlTarget } from "./utils.mjs";
+import { setupI18nBeforeRender } from "./pluginSetup.mjs";
+import { createI18nRootWrapper } from "./providerComposition.mjs";
+import { resolveReactI18nextIntegration } from "./reactI18next.mjs";
 import "./types.mjs";
-let i18nLifecycleHelpersPromise;
-function loadI18nLifecycleHelpers() {
-    i18nLifecycleHelpersPromise ??= Promise.all([
-        import("./i18n/backend/middleware.mjs"),
-        import("./i18n/utils.mjs")
-    ]).then(([backendMiddleware, utils])=>({
-            useI18nextBackend: backendMiddleware.useI18nextBackend,
-            changeI18nLanguage: utils.changeI18nLanguage,
-            ensureLanguageMatch: utils.ensureLanguageMatch,
-            initializeI18nInstance: utils.initializeI18nInstance,
-            setupClonedInstance: utils.setupClonedInstance
-        }));
-    return i18nLifecycleHelpersPromise;
-}
 const createI18nPlugin = (loadReactI18nextIntegration)=>(options)=>({
             name: '@modern-js/plugin-i18n',
             setup: (api)=>{
@@ -34,119 +10,40 @@ const createI18nPlugin = (loadReactI18nextIntegration)=>(options)=>({
                 const { enabled: backendEnabled = false } = backend || {};
                 let latestI18nInstance;
                 let I18nextProvider;
-                const resolveReactI18nextIntegration = async ()=>{
-                    if (!reactI18next) return null;
-                    return loadReactI18nextIntegration?.() ?? null;
-                };
                 api.onBeforeRender(async (context)=>{
-                    const { useI18nextBackend, changeI18nLanguage, ensureLanguageMatch, initializeI18nInstance, setupClonedInstance } = await loadI18nLifecycleHelpers();
-                    let i18nInstance = await getI18nInstance(userI18nInstance);
-                    const { i18n: otherConfig } = api.getRuntimeConfig();
-                    const { initOptions: otherInitOptions } = otherConfig || {};
-                    const userInitOptions = merge(otherInitOptions || {}, initOptions || {});
-                    const reactI18nextIntegration = await resolveReactI18nextIntegration();
-                    I18nextProvider = reactI18nextIntegration?.I18nextProvider ?? null;
-                    if (reactI18nextIntegration?.initReactI18next) i18nInstance.use(reactI18nextIntegration.initReactI18next);
-                    const pathname = getPathname(context);
-                    if (i18nextDetector) useI18nextLanguageDetector(i18nInstance);
-                    const mergedDetection = mergeDetectionOptions(i18nextDetector, detection, localePathRedirect, userInitOptions);
-                    const mergedBackend = mergeBackendOptions(backend, userInitOptions);
-                    const hasSdkConfig = 'function' == typeof userInitOptions?.backend?.sdk || mergedBackend?.sdk && 'function' == typeof mergedBackend.sdk;
-                    if (mergedBackend && (backendEnabled || hasSdkConfig)) useI18nextBackend(i18nInstance, mergedBackend);
-                    const { finalLanguage } = await detectLanguageWithPriority(i18nInstance, {
-                        languages,
-                        fallbackLanguage,
-                        localePathRedirect,
+                    latestI18nInstance = await setupI18nBeforeRender(context, {
+                        api,
+                        userI18nInstance,
+                        initOptions,
+                        backend,
+                        backendEnabled,
                         i18nextDetector,
                         detection,
-                        userInitOptions,
-                        mergedBackend,
-                        pathname,
-                        ssrContext: context.ssrContext
-                    });
-                    await initializeI18nInstance(i18nInstance, finalLanguage, fallbackLanguage, languages, mergedDetection, mergedBackend, userInitOptions);
-                    if (!isBrowser() && i18nInstance.cloneInstance) {
-                        i18nInstance = i18nInstance.cloneInstance();
-                        await setupClonedInstance(i18nInstance, finalLanguage, fallbackLanguage, languages, backendEnabled, backend, i18nextDetector, detection, localePathRedirect, userInitOptions);
-                    }
-                    if (localePathRedirect) await ensureLanguageMatch(i18nInstance, finalLanguage);
-                    if (!isBrowser()) exportServerLngToWindow(context, finalLanguage);
-                    context.i18nInstance = i18nInstance;
-                    latestI18nInstance = i18nInstance;
-                    context.changeLanguage = async (newLang)=>{
-                        await changeI18nLanguage(i18nInstance, newLang, {
-                            detectionOptions: mergedDetection
-                        });
-                    };
-                });
-                api.wrapRoot((App)=>(props)=>{
-                        const runtimeContext = useContext(RuntimeContext);
-                        const i18nInstance = runtimeContext.i18nInstance || latestI18nInstance;
-                        const initialLang = useMemo(()=>i18nInstance?.language || (localeDetection?.fallbackLanguage ?? 'en'), [
-                            i18nInstance?.language,
-                            localeDetection?.fallbackLanguage
-                        ]);
-                        const [lang, setLang] = useState(initialLang);
-                        const [forceUpdate, setForceUpdate] = useState(0);
-                        const prevLangRef = useRef(lang);
-                        const runtimeContextRef = useRef(runtimeContext);
-                        runtimeContextRef.current = runtimeContext;
-                        useEffect(()=>{
-                            if (i18nInstance?.language) {
-                                const translator = i18nInstance.translator;
-                                if (translator) translator.language = i18nInstance.language;
-                            }
-                        }, [
-                            i18nInstance?.language
-                        ]);
-                        useEffect(()=>{
-                            prevLangRef.current = lang;
-                        }, [
-                            lang
-                        ]);
-                        useSdkResourcesLoader(i18nInstance, setForceUpdate);
-                        useLanguageSync(i18nInstance, localePathRedirect, languages, runtimeContextRef, prevLangRef, setLang);
-                        useClientSideRedirect(i18nInstance, localePathRedirect, languages, fallbackLanguage, ignoreRedirectRoutes, localisedUrls);
-                        const contextValue = useMemo(()=>createContextValue(lang, i18nInstance, entryName, languages, localePathRedirect, ignoreRedirectRoutes, localisedUrls, setLang), [
-                            lang,
-                            i18nInstance,
-                            entryName,
-                            languages,
-                            localePathRedirect,
-                            ignoreRedirectRoutes,
-                            localisedUrls,
-                            forceUpdate
-                        ]);
-                        const children = props.children;
-                        const appContent = /*#__PURE__*/ jsxs(Fragment, {
-                            children: [
-                                Boolean(htmlLangAttr) && /*#__PURE__*/ jsx(Helmet, {
-                                    htmlAttributes: {
-                                        lang
-                                    }
-                                }),
-                                /*#__PURE__*/ jsx(ModernI18nProvider, {
-                                    value: contextValue,
-                                    children: App ? /*#__PURE__*/ jsx(App, {
-                                        ...props,
-                                        children: children
-                                    }) : children
-                                })
-                            ]
-                        });
-                        if (!i18nInstance) return appContent;
-                        if (I18nextProvider) {
-                            const i18nextInstanceForProvider = getI18nextInstanceForProvider(i18nInstance);
-                            return /*#__PURE__*/ jsx(I18nextProvider, {
-                                i18n: i18nextInstanceForProvider,
-                                children: appContent
-                            });
+                        localePathRedirect,
+                        languages,
+                        fallbackLanguage,
+                        resolveReactI18nextIntegration: ()=>resolveReactI18nextIntegration(reactI18next, loadReactI18nextIntegration),
+                        setI18nextProvider: (provider)=>{
+                            I18nextProvider = provider;
                         }
-                        return appContent;
                     });
+                });
+                api.wrapRoot(createI18nRootWrapper({
+                    entryName,
+                    htmlLangAttr,
+                    localePathRedirect,
+                    languages,
+                    fallbackLanguage,
+                    ignoreRedirectRoutes,
+                    localisedUrls,
+                    getLatestI18nInstance: ()=>latestI18nInstance,
+                    getI18nextProvider: ()=>I18nextProvider
+                }));
             }
         });
+export { FederatedI18nBoundary, useModernI18n } from "./context.mjs";
 export { I18nLink } from "./I18nLink.mjs";
 export { Link } from "./Link.mjs";
 export { canonicalPath, localizePath, useLocalizedLocation, useLocalizedPaths } from "./localizedPaths.mjs";
-export { buildLocalizedUrl, createI18nPlugin, splitUrlTarget, useModernI18n };
+export { buildLocalizedUrl, splitUrlTarget } from "./utils.mjs";
+export { createI18nPlugin };

package/dist/esm/runtime/hooks.mjs

@@ -1,9 +1,9 @@
 import { isBrowser } from "@modern-js/runtime";
-import { useEffect, useRef } from "react";
+import { useCallback, useEffect, useRef } from "react";
+import { cacheI18nLanguage, changeI18nInstanceLanguage } from "./contextHelpers.mjs";
 import { I18N_SDK_RESOURCES_LOADED_EVENT, getI18nSdkBackendId } from "./i18n/backend/sdk-event.mjs";
-import { cacheUserLanguage } from "./i18n/detection/index.mjs";
 import { useI18nRouterAdapter } from "./routerAdapter.mjs";
-import { buildLocalizedUrl, detectLanguageFromPath, getEntryPath, getPathname, shouldIgnoreRedirect } from "./utils.mjs";
+import { buildLocalizedUrl, detectLanguageFromPath, getEntryPath, shouldIgnoreRedirect } from "./utils.mjs";
 function createMinimalI18nInstance(language) {
     const minimalInstance = {
         language,
@@ -15,7 +15,7 @@ function createMinimalI18nInstance(language) {
     };
     return minimalInstance;
 }
-function createContextValue(lang, i18nInstance, entryName, languages, localePathRedirect, ignoreRedirectRoutes, localisedUrls, setLang) {
+function createContextValue(lang, i18nInstance, entryName, languages, localePathRedirect, ignoreRedirectRoutes, localisedUrls, setLang, synchronizeLanguage) {
     const instance = i18nInstance || createMinimalI18nInstance(lang);
     return {
         language: lang,
@@ -25,7 +25,8 @@ function createContextValue(lang, i18nInstance, entryName, languages, localePath
         localePathRedirect,
         ignoreRedirectRoutes,
         localisedUrls,
-        updateLanguage: setLang
+        updateLanguage: setLang,
+        synchronizeLanguage
     };
 }
 function useSdkResourcesLoader(i18nInstance, setForceUpdate) {
@@ -116,26 +117,56 @@ function useClientSideRedirect(i18nInstance, localePathRedirect, languages, fall
         localisedUrls
     ]);
 }
-function useLanguageSync(i18nInstance, localePathRedirect, languages, runtimeContextRef, prevLangRef, setLang) {
+function useLanguageSync(i18nInstance, localePathRedirect, languages, pathname, prevLangRef, setLang) {
+    const latestRequestRef = useRef(0);
+    const syncQueueRef = useRef(Promise.resolve());
+    const isMountedRef = useRef(false);
+    const desiredLanguageRef = useRef(void 0);
     useEffect(()=>{
-        if (!i18nInstance) return;
-        if (localePathRedirect) {
-            const currentPathname = getPathname(runtimeContextRef.current);
-            const pathDetection = detectLanguageFromPath(currentPathname, languages, localePathRedirect);
-            if (pathDetection.detected && pathDetection.language) {
-                const currentLang = pathDetection.language;
-                if (currentLang !== prevLangRef.current) {
-                    prevLangRef.current = currentLang;
-                    setLang(currentLang);
-                    i18nInstance.setLang?.(currentLang);
-                    i18nInstance.changeLanguage?.(currentLang);
-                    if (isBrowser()) {
-                        const detectionOptions = i18nInstance.options?.detection;
-                        cacheUserLanguage(i18nInstance, currentLang, detectionOptions);
-                    }
+        isMountedRef.current = true;
+        return ()=>{
+            isMountedRef.current = false;
+            latestRequestRef.current += 1;
+        };
+    }, []);
+    useEffect(()=>{
+        desiredLanguageRef.current = void 0;
+        latestRequestRef.current += 1;
+        syncQueueRef.current = Promise.resolve();
+    }, [
+        i18nInstance
+    ]);
+    const synchronizeLanguage = useCallback((currentLang)=>{
+        if (!i18nInstance || !currentLang || desiredLanguageRef.current === currentLang) return;
+        desiredLanguageRef.current = currentLang;
+        const requestId = ++latestRequestRef.current;
+        syncQueueRef.current = syncQueueRef.current.then(async ()=>{
+            if (requestId !== latestRequestRef.current || !isMountedRef.current) return;
+            try {
+                if (i18nInstance.language !== currentLang) await changeI18nInstanceLanguage(i18nInstance, currentLang);
+                if (requestId !== latestRequestRef.current || !isMountedRef.current) return;
+                prevLangRef.current = currentLang;
+                setLang(currentLang);
+                cacheI18nLanguage(i18nInstance, currentLang);
+            } catch (error) {
+                if (requestId === latestRequestRef.current && isMountedRef.current) {
+                    desiredLanguageRef.current = void 0;
+                    console.error(`Failed to synchronize i18n language "${currentLang}".`, error);
                 }
             }
+        });
+    }, [
+        i18nInstance,
+        prevLangRef,
+        setLang
+    ]);
+    useEffect(()=>{
+        if (!i18nInstance) return;
+        if (localePathRedirect) {
+            const pathDetection = detectLanguageFromPath(pathname || '', languages, localePathRedirect);
+            if (pathDetection.detected && pathDetection.language) synchronizeLanguage(pathDetection.language);
         } else {
+            latestRequestRef.current += 1;
             const instanceLang = i18nInstance.language;
             if (instanceLang && instanceLang !== prevLangRef.current) {
                 prevLangRef.current = instanceLang;
@@ -146,9 +177,11 @@ function useLanguageSync(i18nInstance, localePathRedirect, languages, runtimeCon
         i18nInstance,
         localePathRedirect,
         languages,
-        runtimeContextRef,
+        pathname,
         prevLangRef,
-        setLang
+        setLang,
+        synchronizeLanguage
     ]);
+    return synchronizeLanguage;
 }
 export { createContextValue, useClientSideRedirect, useLanguageSync, useSdkResourcesLoader };

package/dist/esm/runtime/i18n/backend/defaults.node.mjs

@@ -1,18 +1,18 @@
-import fs from "fs";
-import path_0 from "path";
+import node_fs from "node:fs";
+import node_path from "node:path";
 const CONVENTIONAL_LOCALES_DIRS = [
     './locales',
     './config/public/locales'
 ];
 const isDirectory = (dirPath)=>{
     try {
-        return fs.statSync(dirPath).isDirectory();
+        return node_fs.statSync(dirPath).isDirectory();
     } catch  {
         return false;
     }
 };
 const resolveDefaultLocalesDir = (cwd = process.cwd())=>{
-    for (const dir of CONVENTIONAL_LOCALES_DIRS)if (isDirectory(path_0.resolve(cwd, dir))) return dir;
+    for (const dir of CONVENTIONAL_LOCALES_DIRS)if (isDirectory(node_path.resolve(cwd, dir))) return dir;
     return CONVENTIONAL_LOCALES_DIRS[0];
 };
 const DEFAULT_I18NEXT_BACKEND_OPTIONS = {
@@ -38,7 +38,7 @@ function getResourceBasePath(resourcePath) {
 }
 function pathExists(resourcePath) {
     try {
-        return fs.existsSync(getResourceBasePath(resourcePath));
+        return node_fs.existsSync(getResourceBasePath(resourcePath));
     } catch  {
         return false;
     }