@bleedingdev/modern-js-plugin-i18n 3.4.0-ultramodern.1 → 3.4.0-ultramodern.10

package/dist/esm/runtime/core.mjs

@@ -0,0 +1,152 @@
+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 "./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)=>{
+                const { entryName, i18nInstance: userI18nInstance, initOptions, localeDetection, backend, htmlLangAttr = false, reactI18next = true } = options;
+                const { localePathRedirect = false, i18nextDetector = true, languages = [], fallbackLanguage = 'en', detection, ignoreRedirectRoutes, localisedUrls } = localeDetection || {};
+                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,
+                        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
+                            });
+                        }
+                        return appContent;
+                    });
+            }
+        });
+export { I18nLink } from "./I18nLink.mjs";
+export { Link } from "./Link.mjs";
+export { canonicalPath, localizePath, useLocalizedLocation, useLocalizedPaths } from "./localizedPaths.mjs";
+export { buildLocalizedUrl, createI18nPlugin, splitUrlTarget, useModernI18n };

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

@@ -1,8 +1,23 @@
-import cjs from "i18next-fs-backend/cjs";
+import i18next_fs_backend from "i18next-fs-backend";
 import { useI18nextBackendCommon } from "./middleware.common.mjs";
-class FsBackendWithSave extends cjs {
+const resolveFsBackendConstructor = (backendModule)=>{
+    const nestedDefault = backendModule?.default?.default;
+    const nestedModuleExports = backendModule?.default?.['module.exports'];
+    const candidates = [
+        backendModule,
+        backendModule?.default,
+        backendModule?.['module.exports'],
+        nestedDefault,
+        nestedModuleExports
+    ];
+    const Backend = candidates.find((candidate)=>'function' == typeof candidate);
+    if (!Backend) throw new Error('Failed to resolve i18next-fs-backend constructor for the i18n Node backend.');
+    return Backend;
+};
+const middleware_node_Backend = resolveFsBackendConstructor(i18next_fs_backend);
+class FsBackendWithSave extends middleware_node_Backend {
     save(_language, _namespace, _data) {}
 }
 const HttpBackendWithSave = FsBackendWithSave;
-const useI18nextBackend = (i18nInstance, backend)=>useI18nextBackendCommon(i18nInstance, FsBackendWithSave, cjs, backend);
-export { FsBackendWithSave, HttpBackendWithSave, useI18nextBackend };
+const useI18nextBackend = (i18nInstance, backend)=>useI18nextBackendCommon(i18nInstance, FsBackendWithSave, middleware_node_Backend, backend);
+export { FsBackendWithSave, HttpBackendWithSave, resolveFsBackendConstructor, useI18nextBackend };

package/dist/esm/runtime/index.mjs

@@ -1,142 +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 { useI18nextBackend } from "./i18n/backend/middleware.mjs";
-import { detectLanguageWithPriority, exportServerLngToWindow, mergeDetectionOptions } from "./i18n/detection/index.mjs";
-import { useI18nextLanguageDetector } from "./i18n/detection/middleware.mjs";
-import { getI18nextInstanceForProvider } from "./i18n/instance.mjs";
-import { changeI18nLanguage, ensureLanguageMatch, initializeI18nInstance, setupClonedInstance } from "./i18n/utils.mjs";
-import { buildLocalizedUrl, getPathname, splitUrlTarget } from "./utils.mjs";
-import "./types.mjs";
-const i18nPlugin = (options)=>({
-        name: '@modern-js/plugin-i18n',
-        setup: (api)=>{
-            const { entryName, i18nInstance: userI18nInstance, initOptions, localeDetection, backend, htmlLangAttr = false, reactI18next = true } = options;
-            const { localePathRedirect = false, i18nextDetector = true, languages = [], fallbackLanguage = 'en', detection, ignoreRedirectRoutes, localisedUrls } = localeDetection || {};
-            const { enabled: backendEnabled = false } = backend || {};
-            let latestI18nInstance;
-            let I18nextProvider;
-            const loadReactI18nextIntegration = async ()=>{
-                if (!reactI18next) return null;
-                const { getReactI18nextIntegration } = await import("./i18n/react-i18next.mjs");
-                return getReactI18nextIntegration();
-            };
-            api.onBeforeRender(async (context)=>{
-                let i18nInstance = await getI18nInstance(userI18nInstance);
-                const { i18n: otherConfig } = api.getRuntimeConfig();
-                const { initOptions: otherInitOptions } = otherConfig || {};
-                const userInitOptions = merge(otherInitOptions || {}, initOptions || {});
-                const reactI18nextIntegration = await loadReactI18nextIntegration();
-                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,
-                    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
-                        });
-                    }
-                    return appContent;
-                });
-        }
-    });
+import { createI18nPlugin } from "./core.mjs";
+import { getReactI18nextIntegration } from "./i18n/react-i18next.mjs";
+export * from "./core.mjs";
+const i18nPlugin = createI18nPlugin(getReactI18nextIntegration);
 const runtime = i18nPlugin;
-export { I18nLink } from "./I18nLink.mjs";
-export { Link } from "./Link.mjs";
-export { canonicalPath, localizePath, useLocalizedLocation, useLocalizedPaths } from "./localizedPaths.mjs";
 export default runtime;
-export { buildLocalizedUrl, i18nPlugin, splitUrlTarget, useModernI18n };
+export { i18nPlugin };

package/dist/esm/runtime/no-react-i18next.mjs

@@ -0,0 +1,6 @@
+import { createI18nPlugin } from "./core.mjs";
+export * from "./core.mjs";
+const i18nPlugin = createI18nPlugin();
+const no_react_i18next = i18nPlugin;
+export default no_react_i18next;
+export { i18nPlugin };

package/dist/esm-node/cli/index.mjs

@@ -32,9 +32,10 @@ const i18nPlugin = (options = {})=>({
                     backend: backendOptions,
                     ...extendedConfig
                 };
+                const runtimePluginPath = customPlugin?.runtime?.path || (false === config.reactI18next ? `@${metaName}/plugin-i18n/runtime/no-react-i18next` : `@${metaName}/plugin-i18n/runtime`);
                 plugins.push({
                     name: customPlugin?.runtime?.name || 'i18n',
-                    path: customPlugin?.runtime?.path || `@${metaName}/plugin-i18n/runtime`,
+                    path: runtimePluginPath,
                     config
                 });
                 return {

package/dist/esm-node/runtime/context.mjs

@@ -90,6 +90,13 @@ 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);
+    }, [
+        currentLanguage,
+        i18nInstance
+    ]);
     const isLanguageSupported = useCallback((lang)=>languages?.includes(lang) || false, [
         languages
     ]);
@@ -123,6 +130,7 @@ const useModernI18n = ()=>{
     return {
         language: currentLanguage,
         changeLanguage,
+        t,
         i18nInstance,
         supportedLanguages: languages || [],
         localisedUrls,

package/dist/esm-node/runtime/core.mjs

@@ -0,0 +1,153 @@
+import "node:module";
+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 "./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)=>{
+                const { entryName, i18nInstance: userI18nInstance, initOptions, localeDetection, backend, htmlLangAttr = false, reactI18next = true } = options;
+                const { localePathRedirect = false, i18nextDetector = true, languages = [], fallbackLanguage = 'en', detection, ignoreRedirectRoutes, localisedUrls } = localeDetection || {};
+                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,
+                        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
+                            });
+                        }
+                        return appContent;
+                    });
+            }
+        });
+export { I18nLink } from "./I18nLink.mjs";
+export { Link } from "./Link.mjs";
+export { canonicalPath, localizePath, useLocalizedLocation, useLocalizedPaths } from "./localizedPaths.mjs";
+export { buildLocalizedUrl, createI18nPlugin, splitUrlTarget, useModernI18n };

package/dist/esm-node/runtime/i18n/backend/middleware.node.mjs

@@ -1,9 +1,24 @@
 import "node:module";
-import cjs from "i18next-fs-backend/cjs";
+import i18next_fs_backend from "i18next-fs-backend";
 import { useI18nextBackendCommon } from "./middleware.common.mjs";
-class FsBackendWithSave extends cjs {
+const resolveFsBackendConstructor = (backendModule)=>{
+    const nestedDefault = backendModule?.default?.default;
+    const nestedModuleExports = backendModule?.default?.['module.exports'];
+    const candidates = [
+        backendModule,
+        backendModule?.default,
+        backendModule?.['module.exports'],
+        nestedDefault,
+        nestedModuleExports
+    ];
+    const Backend = candidates.find((candidate)=>'function' == typeof candidate);
+    if (!Backend) throw new Error('Failed to resolve i18next-fs-backend constructor for the i18n Node backend.');
+    return Backend;
+};
+const middleware_node_Backend = resolveFsBackendConstructor(i18next_fs_backend);
+class FsBackendWithSave extends middleware_node_Backend {
     save(_language, _namespace, _data) {}
 }
 const HttpBackendWithSave = FsBackendWithSave;
-const useI18nextBackend = (i18nInstance, backend)=>useI18nextBackendCommon(i18nInstance, FsBackendWithSave, cjs, backend);
-export { FsBackendWithSave, HttpBackendWithSave, useI18nextBackend };
+const useI18nextBackend = (i18nInstance, backend)=>useI18nextBackendCommon(i18nInstance, FsBackendWithSave, middleware_node_Backend, backend);
+export { FsBackendWithSave, HttpBackendWithSave, resolveFsBackendConstructor, useI18nextBackend };