@bleedingdev/modern-js-plugin-i18n 3.4.0-ultramodern.0 → 3.4.0-ultramodern.2

package/dist/esm/runtime/core.mjs

@@ -0,0 +1,139 @@
+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 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)=>{
+                    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/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/core.mjs

@@ -0,0 +1,140 @@
+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 { 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 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)=>{
+                    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/index.mjs

@@ -1,143 +1,8 @@
 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 { 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-node/runtime/no-react-i18next.mjs

@@ -0,0 +1,7 @@
+import "node:module";
+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/types/runtime/core.d.ts

@@ -0,0 +1,30 @@
+import { type RuntimePlugin } from '@modern-js/runtime';
+import type React from 'react';
+import type { BaseBackendOptions, BaseLocaleDetectionOptions } from '../shared/type';
+import type { I18nInitOptions, I18nInstance } from './i18n';
+import './types';
+export type { I18nSdkLoader, I18nSdkLoadOptions } from '../shared/type';
+export type { Resources } from './i18n/instance';
+export interface I18nPluginOptions {
+    entryName?: string;
+    localeDetection?: BaseLocaleDetectionOptions;
+    backend?: BaseBackendOptions;
+    i18nInstance?: I18nInstance;
+    changeLanguage?: (lang: string) => void;
+    initOptions?: I18nInitOptions;
+    htmlLangAttr?: boolean;
+    reactI18next?: boolean;
+    [key: string]: any;
+}
+export interface ReactI18nextIntegration {
+    I18nextProvider: React.ComponentType<any> | null;
+    initReactI18next: any | null;
+}
+export type LoadReactI18nextIntegration = () => Promise<ReactI18nextIntegration | null>;
+export declare const createI18nPlugin: (loadReactI18nextIntegration?: LoadReactI18nextIntegration) => ((options: I18nPluginOptions) => RuntimePlugin);
+export type { AllowedLinkTarget, CanonicalRoutePath, UltramodernCanonicalRoutes, } from './canonicalRoutes';
+export { useModernI18n } from './context';
+export { I18nLink, type I18nLinkProps } from './I18nLink';
+export { Link, type LinkActiveOptions, type LinkBaseProps, type LinkParams, type LinkProps, } from './Link';
+export { canonicalPath, type LocalizedPathsConfig, localizePath, type UseLocalizedLocationReturn, type UseLocalizedPathsReturn, useLocalizedLocation, useLocalizedPaths, } from './localizedPaths';
+export { buildLocalizedUrl, splitUrlTarget } from './utils';