@bleedingdev/modern-js-plugin-i18n 3.5.0-ultramodern.3 → 3.5.0-ultramodern.31

package/dist/cjs/cli/index.js

@@ -64,7 +64,8 @@ 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`);
+                const { reactI18next } = extendedConfig;
+                const runtimePluginPath = customPlugin?.runtime?.path || (false === reactI18next ? `@${metaName}/plugin-i18n/runtime/no-react-i18next` : `@${metaName}/plugin-i18n/runtime`);
                 plugins.push({
                     name: customPlugin?.runtime?.name || 'i18n',
                     path: runtimePluginPath,

package/dist/cjs/runtime/Link.js

@@ -30,97 +30,16 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     Link: ()=>Link,
     default: ()=>runtime_Link,
-    interpolateRouteParams: ()=>interpolateRouteParams
+    interpolateRouteParams: ()=>external_linkHelpers_js_namespaceObject.interpolateRouteParams
 });
 const jsx_runtime_namespaceObject = require("react/jsx-runtime");
 const external_react_namespaceObject = require("react");
 const external_context_js_namespaceObject = require("./context.js");
+const external_linkHelpers_js_namespaceObject = require("./linkHelpers.js");
 const external_localizedPaths_js_namespaceObject = require("./localizedPaths.js");
 const external_routerAdapter_js_namespaceObject = require("./routerAdapter.js");
 const external_utils_js_namespaceObject = require("./utils.js");
 const EXTERNAL_TARGET_RE = /^(?:[a-z][a-z0-9+.-]*:|\/\/)/i;
-const warnedTargets = new Set();
-const warnOnce = (key, message)=>{
-    if ('development' !== process.env.NODE_ENV || warnedTargets.has(key)) return;
-    warnedTargets.add(key);
-    console.warn(message);
-};
-const interpolateRouteParams = (pathname, params)=>{
-    if (!/[$:*{]/.test(pathname)) return pathname;
-    const resolveParam = (name)=>{
-        const value = params?.[name];
-        return void 0 === value ? void 0 : String(value);
-    };
-    const segments = pathname.split('/').map((segment)=>{
-        if (!segment) return segment;
-        if (segment.startsWith('{-$') && segment.endsWith('}')) {
-            const value = resolveParam(segment.slice(3, -1));
-            return void 0 === value ? null : encodeURIComponent(value);
-        }
-        if ('$' === segment || '*' === segment) {
-            const value = resolveParam('_splat') ?? resolveParam('*');
-            return void 0 === value ? null : value.split('/').map(encodeURIComponent).join('/');
-        }
-        if (segment.startsWith('$')) {
-            const value = resolveParam(segment.slice(1));
-            if (void 0 === value) {
-                warnOnce(`missing-param:${pathname}:${segment}`, `[plugin-i18n] <Link to="${pathname}"> is missing required param "${segment.slice(1)}".`);
-                return segment;
-            }
-            return encodeURIComponent(value);
-        }
-        if (segment.startsWith(':')) {
-            const optional = segment.endsWith('?');
-            const name = segment.slice(1, optional ? -1 : void 0);
-            const value = resolveParam(name);
-            if (void 0 === value) {
-                if (optional) return null;
-                warnOnce(`missing-param:${pathname}:${segment}`, `[plugin-i18n] <Link to="${pathname}"> is missing required param "${name}".`);
-                return segment;
-            }
-            return encodeURIComponent(value);
-        }
-        return segment;
-    }).filter((segment)=>null !== segment);
-    return segments.join('/') || '/';
-};
-const normalizeSearch = (search, searchFromTo)=>{
-    if (search && 'object' == typeof search) {
-        const entries = Object.entries(search).filter(([, value])=>null != value);
-        const searchObject = Object.fromEntries(entries.map(([key, value])=>[
-                key,
-                String(value)
-            ]));
-        const params = new URLSearchParams(searchObject);
-        const serialized = params.toString();
-        return {
-            searchString: serialized ? `?${serialized}` : '',
-            searchObject
-        };
-    }
-    const raw = 'string' == typeof search && search ? search : searchFromTo;
-    if (!raw) return {
-        searchString: '',
-        searchObject: void 0
-    };
-    const searchString = raw.startsWith('?') ? raw : `?${raw}`;
-    const searchObject = {};
-    new URLSearchParams(searchString).forEach((value, key)=>{
-        searchObject[key] = value;
-    });
-    return {
-        searchString,
-        searchObject
-    };
-};
-const splitActiveProps = (active, activeProps)=>{
-    if (!active || !activeProps) return {};
-    return activeProps;
-};
-const mergeClassNames = (...values)=>{
-    const classNames = values.filter((value)=>'string' == typeof value && value.length > 0);
-    return classNames.length > 0 ? classNames.join(' ') : void 0;
-};
 const Link = (props)=>{
     const { to, params, children, hash: hashProp, search: searchProp, hashScrollIntoView, activeOptions, activeProps, prefetch, preload, ...rest } = props;
     const adapter = (0, external_routerAdapter_js_namespaceObject.useI18nRouterAdapter)();
@@ -134,12 +53,12 @@ const Link = (props)=>{
     const target = (0, external_react_namespaceObject.useMemo)(()=>{
         if (isExternal || isBareHash) return null;
         const { pathname, search: searchFromTo, hash: hashFromTo } = (0, external_utils_js_namespaceObject.splitUrlTarget)(to);
-        const interpolated = interpolateRouteParams(pathname || '/', params);
+        const interpolated = (0, external_linkHelpers_js_namespaceObject.interpolateRouteParams)(pathname || '/', params);
         const firstSegment = interpolated.split('/').filter(Boolean)[0];
-        if (firstSegment && supportedLanguages.includes(firstSegment)) warnOnce(`lang-prefix:${to}`, `[plugin-i18n] <Link to="${to}"> starts with a language prefix. Write language-agnostic canonical paths; the Link localizes them automatically.`);
+        if (firstSegment && supportedLanguages.includes(firstSegment)) (0, external_linkHelpers_js_namespaceObject.warnOnce)(`lang-prefix:${to}`, `[plugin-i18n] <Link to="${to}"> starts with a language prefix. Write language-agnostic canonical paths; the Link localizes them automatically.`);
         const localizedPathname = (0, external_utils_js_namespaceObject.buildLocalizedUrl)(interpolated, language, supportedLanguages, localisedUrls);
         const hash = hashProp ?? (hashFromTo ? hashFromTo.slice(1) : '');
-        const { searchString, searchObject } = normalizeSearch(searchProp, searchFromTo);
+        const { searchString, searchObject } = (0, external_linkHelpers_js_namespaceObject.normalizeSearch)(searchProp, searchFromTo);
         return {
             canonicalPathname: interpolated,
             localizedPathname,
@@ -174,7 +93,7 @@ const Link = (props)=>{
         supportedLanguages,
         localisedUrls
     ]);
-    const resolvedActiveProps = splitActiveProps(isActive, activeProps);
+    const resolvedActiveProps = (0, external_linkHelpers_js_namespaceObject.splitActiveProps)(isActive, activeProps);
     const activeAttributes = isActive ? {
         'data-status': 'active',
         'aria-current': rest['aria-current'] ?? resolvedActiveProps['aria-current'] ?? 'page'
@@ -196,7 +115,7 @@ const Link = (props)=>{
             ...anchorProps,
             ...activeRest,
             ...activeAttributes,
-            className: mergeClassNames(rest.className, activeClassName),
+            className: (0, external_linkHelpers_js_namespaceObject.mergeClassNames)(rest.className, activeClassName),
             style: {
                 ...rest.style,
                 ...activeStyle
@@ -205,7 +124,7 @@ const Link = (props)=>{
         });
     }
     const { className: activeClassName, style: activeStyle, ...activeRest } = resolvedActiveProps;
-    const mergedClassName = mergeClassNames(rest.className, activeClassName);
+    const mergedClassName = (0, external_linkHelpers_js_namespaceObject.mergeClassNames)(rest.className, activeClassName);
     const mergedStyle = {
         ...rest.style,
         ...activeStyle

package/dist/cjs/runtime/context.js

@@ -32,11 +32,9 @@ __webpack_require__.d(__webpack_exports__, {
     useModernI18n: ()=>useModernI18n
 });
 const jsx_runtime_namespaceObject = require("react/jsx-runtime");
-const runtime_namespaceObject = require("@modern-js/runtime");
 const external_react_namespaceObject = require("react");
-const index_js_namespaceObject = require("./i18n/detection/index.js");
+const external_contextHelpers_js_namespaceObject = require("./contextHelpers.js");
 const external_routerAdapter_js_namespaceObject = require("./routerAdapter.js");
-const external_utils_js_namespaceObject = require("./utils.js");
 const modernI18nContextKey = Symbol.for('@modern-js/plugin-i18n/runtime/ModernI18nContext');
 const getModernI18nContext = ()=>{
     const globalStore = globalThis;
@@ -50,14 +48,10 @@ const ModernI18nProvider = ({ children, value })=>/*#__PURE__*/ (0, jsx_runtime_
     });
 const useModernI18n = ()=>{
     const context = (0, external_react_namespaceObject.useContext)(ModernI18nContext);
-    if (!context) throw new Error('useModernI18n must be used within a ModernI18nProvider');
+    if (!context) throw new Error('useModernI18n must be used within ModernI18nProvider');
     const { language: contextLanguage, i18nInstance, languages, localePathRedirect, ignoreRedirectRoutes, localisedUrls, updateLanguage } = context;
     const { navigate, location, hasRouter } = (0, external_routerAdapter_js_namespaceObject.useI18nRouterAdapter)();
-    const pathLanguage = (0, external_react_namespaceObject.useMemo)(()=>{
-        if (!localePathRedirect || !location?.pathname) return;
-        const detected = (0, external_utils_js_namespaceObject.detectLanguageFromPath)(location.pathname, languages || [], localePathRedirect);
-        return detected.detected ? detected.language : void 0;
-    }, [
+    const pathLanguage = (0, external_react_namespaceObject.useMemo)(()=>(0, external_contextHelpers_js_namespaceObject.getPathLanguage)(location?.pathname, languages, localePathRedirect), [
         languages,
         localePathRedirect,
         location?.pathname
@@ -68,56 +62,24 @@ const useModernI18n = ()=>{
         updateLanguage?.(pathLanguage);
         i18nInstance?.setLang?.(pathLanguage);
         i18nInstance?.changeLanguage?.(pathLanguage);
-        if ((0, runtime_namespaceObject.isBrowser)()) {
-            const detectionOptions = i18nInstance.options?.detection;
-            (0, index_js_namespaceObject.cacheUserLanguage)(i18nInstance, pathLanguage, detectionOptions);
-        }
+        (0, external_contextHelpers_js_namespaceObject.cacheI18nLanguage)(i18nInstance, pathLanguage);
     }, [
         contextLanguage,
         i18nInstance,
         pathLanguage,
         updateLanguage
     ]);
-    const changeLanguage = (0, external_react_namespaceObject.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 ((0, runtime_namespaceObject.isBrowser)()) {
-                const detectionOptions = i18nInstance.options?.detection;
-                (0, index_js_namespaceObject.cacheUserLanguage)(i18nInstance, newLang, detectionOptions);
-            }
-            if (localePathRedirect && (0, runtime_namespaceObject.isBrowser)() && hasRouter && navigate && location) {
-                const currentPath = location.pathname;
-                const entryPath = (0, external_utils_js_namespaceObject.getEntryPath)();
-                const relativePath = currentPath.replace(entryPath, '');
-                const pathLanguage = (0, external_utils_js_namespaceObject.detectLanguageFromPath)(currentPath, languages || [], localePathRedirect);
-                if (pathLanguage.detected && pathLanguage.language === newLang) return;
-                if (!(0, external_utils_js_namespaceObject.shouldIgnoreRedirect)(relativePath, languages || [], ignoreRedirectRoutes)) {
-                    const newPath = (0, external_utils_js_namespaceObject.buildLocalizedUrl)(relativePath, newLang, languages || [], localisedUrls);
-                    const newUrl = entryPath + newPath + location.search + location.hash;
-                    await navigate(newUrl, {
-                        replace: true
-                    });
-                }
-            } else if (localePathRedirect && (0, runtime_namespaceObject.isBrowser)() && !hasRouter) {
-                const currentPath = window.location.pathname;
-                const entryPath = (0, external_utils_js_namespaceObject.getEntryPath)();
-                const relativePath = currentPath.replace(entryPath, '');
-                const pathLanguage = (0, external_utils_js_namespaceObject.detectLanguageFromPath)(currentPath, languages || [], localePathRedirect);
-                if (pathLanguage.detected && pathLanguage.language === newLang) return;
-                if (!(0, external_utils_js_namespaceObject.shouldIgnoreRedirect)(relativePath, languages || [], ignoreRedirectRoutes)) {
-                    const newPath = (0, external_utils_js_namespaceObject.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 changeLanguage = (0, external_react_namespaceObject.useCallback)((newLang)=>(0, external_contextHelpers_js_namespaceObject.changeModernI18nLanguage)(newLang, {
+            i18nInstance,
+            updateLanguage,
+            localePathRedirect,
+            ignoreRedirectRoutes,
+            localisedUrls,
+            languages,
+            hasRouter,
+            navigate,
+            location
+        }), [
         i18nInstance,
         updateLanguage,
         localePathRedirect,
@@ -128,40 +90,14 @@ const useModernI18n = ()=>{
         navigate,
         location
     ]);
-    const t = (0, external_react_namespaceObject.useCallback)((key, ...args)=>{
-        if ('function' != typeof i18nInstance.t) throw new Error('i18nInstance.t is required');
-        return i18nInstance.t(key, ...args);
-    }, [
+    const t = (0, external_react_namespaceObject.useCallback)((key, ...args)=>(0, external_contextHelpers_js_namespaceObject.translateI18n)(i18nInstance, key, ...args), [
         currentLanguage,
         i18nInstance
     ]);
-    const isLanguageSupported = (0, external_react_namespaceObject.useCallback)((lang)=>languages?.includes(lang) || false, [
+    const isLanguageSupported = (0, external_react_namespaceObject.useCallback)((lang)=>(0, external_contextHelpers_js_namespaceObject.isI18nLanguageSupported)(languages, lang), [
         languages
     ]);
-    const isResourcesReady = (0, external_react_namespaceObject.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 = (0, external_react_namespaceObject.useMemo)(()=>(0, external_contextHelpers_js_namespaceObject.isI18nResourcesReady)(i18nInstance, currentLanguage), [
         currentLanguage,
         i18nInstance
     ]);

package/dist/cjs/runtime/contextHelpers.js

@@ -0,0 +1,137 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    cacheI18nLanguage: ()=>cacheI18nLanguage,
+    changeModernI18nLanguage: ()=>changeModernI18nLanguage,
+    getPathLanguage: ()=>getPathLanguage,
+    isI18nLanguageSupported: ()=>isI18nLanguageSupported,
+    isI18nResourcesReady: ()=>isI18nResourcesReady,
+    translateI18n: ()=>translateI18n
+});
+const runtime_namespaceObject = require("@modern-js/runtime");
+const index_js_namespaceObject = require("./i18n/detection/index.js");
+const external_utils_js_namespaceObject = require("./utils.js");
+function getPathLanguage(pathname, languages, localePathRedirect) {
+    if (!localePathRedirect || !pathname) return;
+    const detected = (0, external_utils_js_namespaceObject.detectLanguageFromPath)(pathname, languages || [], localePathRedirect);
+    return detected.detected ? detected.language : void 0;
+}
+function cacheI18nLanguage(i18nInstance, language) {
+    if ((0, runtime_namespaceObject.isBrowser)()) {
+        const detectionOptions = i18nInstance.options?.detection;
+        (0, index_js_namespaceObject.cacheUserLanguage)(i18nInstance, language, detectionOptions);
+    }
+}
+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 i18nInstance?.setLang?.(newLang);
+        await i18nInstance?.changeLanguage?.(newLang);
+        cacheI18nLanguage(i18nInstance, newLang);
+        if (localePathRedirect && (0, runtime_namespaceObject.isBrowser)() && hasRouter && navigate && location) {
+            const currentPath = location.pathname;
+            const entryPath = (0, external_utils_js_namespaceObject.getEntryPath)();
+            const relativePath = currentPath.replace(entryPath, '');
+            const pathLanguage = (0, external_utils_js_namespaceObject.detectLanguageFromPath)(currentPath, languages || [], localePathRedirect);
+            if (pathLanguage.detected && pathLanguage.language === newLang) return void updateLanguage?.(newLang);
+            if (!(0, external_utils_js_namespaceObject.shouldIgnoreRedirect)(relativePath, languages || [], ignoreRedirectRoutes)) {
+                const newPath = (0, external_utils_js_namespaceObject.buildLocalizedUrl)(relativePath, newLang, languages || [], localisedUrls);
+                const newUrl = entryPath + newPath + location.search + location.hash;
+                await navigate(newUrl, {
+                    replace: true
+                });
+            }
+        } else if (localePathRedirect && (0, runtime_namespaceObject.isBrowser)() && !hasRouter) {
+            const currentPath = window.location.pathname;
+            const entryPath = (0, external_utils_js_namespaceObject.getEntryPath)();
+            const relativePath = currentPath.replace(entryPath, '');
+            const pathLanguage = (0, external_utils_js_namespaceObject.detectLanguageFromPath)(currentPath, languages || [], localePathRedirect);
+            if (pathLanguage.detected && pathLanguage.language === newLang) return void updateLanguage?.(newLang);
+            if (!(0, external_utils_js_namespaceObject.shouldIgnoreRedirect)(relativePath, languages || [], ignoreRedirectRoutes)) {
+                const newPath = (0, external_utils_js_namespaceObject.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;
+    });
+}
+exports.cacheI18nLanguage = __webpack_exports__.cacheI18nLanguage;
+exports.changeModernI18nLanguage = __webpack_exports__.changeModernI18nLanguage;
+exports.getPathLanguage = __webpack_exports__.getPathLanguage;
+exports.isI18nLanguageSupported = __webpack_exports__.isI18nLanguageSupported;
+exports.isI18nResourcesReady = __webpack_exports__.isI18nResourcesReady;
+exports.translateI18n = __webpack_exports__.translateI18n;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "cacheI18nLanguage",
+    "changeModernI18nLanguage",
+    "getPathLanguage",
+    "isI18nLanguageSupported",
+    "isI18nResourcesReady",
+    "translateI18n"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/core.js

@@ -39,37 +39,15 @@ __webpack_require__.d(__webpack_exports__, {
     useLocalizedPaths: ()=>external_localizedPaths_js_namespaceObject.useLocalizedPaths,
     useModernI18n: ()=>external_context_js_namespaceObject.useModernI18n
 });
-const jsx_runtime_namespaceObject = require("react/jsx-runtime");
-const runtime_namespaceObject = require("@modern-js/runtime");
-const head_namespaceObject = require("@modern-js/runtime/head");
-const merge_namespaceObject = require("@modern-js/runtime-utils/merge");
-const external_react_namespaceObject = require("react");
-const external_context_js_namespaceObject = require("./context.js");
-const external_hooks_js_namespaceObject = require("./hooks.js");
-const index_js_namespaceObject = require("./i18n/index.js");
-const backend_index_js_namespaceObject = require("./i18n/backend/index.js");
-const detection_index_js_namespaceObject = require("./i18n/detection/index.js");
-const middleware_js_namespaceObject = require("./i18n/detection/middleware.js");
-const instance_js_namespaceObject = require("./i18n/instance.js");
-const external_utils_js_namespaceObject = require("./utils.js");
+const external_pluginSetup_js_namespaceObject = require("./pluginSetup.js");
+const external_providerComposition_js_namespaceObject = require("./providerComposition.js");
+const external_reactI18next_js_namespaceObject = require("./reactI18next.js");
 require("./types.js");
+const external_context_js_namespaceObject = require("./context.js");
 const external_I18nLink_js_namespaceObject = require("./I18nLink.js");
 const external_Link_js_namespaceObject = require("./Link.js");
 const external_localizedPaths_js_namespaceObject = require("./localizedPaths.js");
-let i18nLifecycleHelpersPromise;
-function loadI18nLifecycleHelpers() {
-    i18nLifecycleHelpersPromise ??= Promise.all([
-        import("./i18n/backend/middleware.js"),
-        import("./i18n/utils.js")
-    ]).then(([backendMiddleware, utils])=>({
-            useI18nextBackend: backendMiddleware.useI18nextBackend,
-            changeI18nLanguage: utils.changeI18nLanguage,
-            ensureLanguageMatch: utils.ensureLanguageMatch,
-            initializeI18nInstance: utils.initializeI18nInstance,
-            setupClonedInstance: utils.setupClonedInstance
-        }));
-    return i18nLifecycleHelpersPromise;
-}
+const external_utils_js_namespaceObject = require("./utils.js");
 const createI18nPlugin = (loadReactI18nextIntegration)=>(options)=>({
             name: '@modern-js/plugin-i18n',
             setup: (api)=>{
@@ -78,116 +56,35 @@ 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 (0, index_js_namespaceObject.getI18nInstance)(userI18nInstance);
-                    const { i18n: otherConfig } = api.getRuntimeConfig();
-                    const { initOptions: otherInitOptions } = otherConfig || {};
-                    const userInitOptions = (0, merge_namespaceObject.merge)(otherInitOptions || {}, initOptions || {});
-                    const reactI18nextIntegration = await resolveReactI18nextIntegration();
-                    I18nextProvider = reactI18nextIntegration?.I18nextProvider ?? null;
-                    if (reactI18nextIntegration?.initReactI18next) i18nInstance.use(reactI18nextIntegration.initReactI18next);
-                    const pathname = (0, external_utils_js_namespaceObject.getPathname)(context);
-                    if (i18nextDetector) (0, middleware_js_namespaceObject.useI18nextLanguageDetector)(i18nInstance);
-                    const mergedDetection = (0, detection_index_js_namespaceObject.mergeDetectionOptions)(i18nextDetector, detection, localePathRedirect, userInitOptions);
-                    const mergedBackend = (0, backend_index_js_namespaceObject.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 (0, detection_index_js_namespaceObject.detectLanguageWithPriority)(i18nInstance, {
-                        languages,
-                        fallbackLanguage,
-                        localePathRedirect,
+                    latestI18nInstance = await (0, external_pluginSetup_js_namespaceObject.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 (!(0, runtime_namespaceObject.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 (!(0, runtime_namespaceObject.isBrowser)()) (0, detection_index_js_namespaceObject.exportServerLngToWindow)(context, finalLanguage);
-                    context.i18nInstance = i18nInstance;
-                    latestI18nInstance = i18nInstance;
-                    context.changeLanguage = async (newLang)=>{
-                        await changeI18nLanguage(i18nInstance, newLang, {
-                            detectionOptions: mergedDetection
-                        });
-                    };
-                });
-                api.wrapRoot((App)=>(props)=>{
-                        const runtimeContext = (0, external_react_namespaceObject.useContext)(runtime_namespaceObject.RuntimeContext);
-                        const i18nInstance = runtimeContext.i18nInstance || latestI18nInstance;
-                        const initialLang = (0, external_react_namespaceObject.useMemo)(()=>i18nInstance?.language || (localeDetection?.fallbackLanguage ?? 'en'), [
-                            i18nInstance?.language,
-                            localeDetection?.fallbackLanguage
-                        ]);
-                        const [lang, setLang] = (0, external_react_namespaceObject.useState)(initialLang);
-                        const [forceUpdate, setForceUpdate] = (0, external_react_namespaceObject.useState)(0);
-                        const prevLangRef = (0, external_react_namespaceObject.useRef)(lang);
-                        const runtimeContextRef = (0, external_react_namespaceObject.useRef)(runtimeContext);
-                        runtimeContextRef.current = runtimeContext;
-                        (0, external_react_namespaceObject.useEffect)(()=>{
-                            if (i18nInstance?.language) {
-                                const translator = i18nInstance.translator;
-                                if (translator) translator.language = i18nInstance.language;
-                            }
-                        }, [
-                            i18nInstance?.language
-                        ]);
-                        (0, external_react_namespaceObject.useEffect)(()=>{
-                            prevLangRef.current = lang;
-                        }, [
-                            lang
-                        ]);
-                        (0, external_hooks_js_namespaceObject.useSdkResourcesLoader)(i18nInstance, setForceUpdate);
-                        (0, external_hooks_js_namespaceObject.useLanguageSync)(i18nInstance, localePathRedirect, languages, runtimeContextRef, prevLangRef, setLang);
-                        (0, external_hooks_js_namespaceObject.useClientSideRedirect)(i18nInstance, localePathRedirect, languages, fallbackLanguage, ignoreRedirectRoutes, localisedUrls);
-                        const contextValue = (0, external_react_namespaceObject.useMemo)(()=>(0, external_hooks_js_namespaceObject.createContextValue)(lang, i18nInstance, entryName, languages, localePathRedirect, ignoreRedirectRoutes, localisedUrls, setLang), [
-                            lang,
-                            i18nInstance,
-                            entryName,
-                            languages,
-                            localePathRedirect,
-                            ignoreRedirectRoutes,
-                            localisedUrls,
-                            forceUpdate
-                        ]);
-                        const children = props.children;
-                        const appContent = /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)(jsx_runtime_namespaceObject.Fragment, {
-                            children: [
-                                Boolean(htmlLangAttr) && /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(head_namespaceObject.Helmet, {
-                                    htmlAttributes: {
-                                        lang
-                                    }
-                                }),
-                                /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_context_js_namespaceObject.ModernI18nProvider, {
-                                    value: contextValue,
-                                    children: App ? /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(App, {
-                                        ...props,
-                                        children: children
-                                    }) : children
-                                })
-                            ]
-                        });
-                        if (!i18nInstance) return appContent;
-                        if (I18nextProvider) {
-                            const i18nextInstanceForProvider = (0, instance_js_namespaceObject.getI18nextInstanceForProvider)(i18nInstance);
-                            return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(I18nextProvider, {
-                                i18n: i18nextInstanceForProvider,
-                                children: appContent
-                            });
+                        localePathRedirect,
+                        languages,
+                        fallbackLanguage,
+                        resolveReactI18nextIntegration: ()=>(0, external_reactI18next_js_namespaceObject.resolveReactI18nextIntegration)(reactI18next, loadReactI18nextIntegration),
+                        setI18nextProvider: (provider)=>{
+                            I18nextProvider = provider;
                         }
-                        return appContent;
                     });
+                });
+                api.wrapRoot((0, external_providerComposition_js_namespaceObject.createI18nRootWrapper)({
+                    entryName,
+                    htmlLangAttr,
+                    localePathRedirect,
+                    languages,
+                    fallbackLanguage,
+                    ignoreRedirectRoutes,
+                    localisedUrls,
+                    getLatestI18nInstance: ()=>latestI18nInstance,
+                    getI18nextProvider: ()=>I18nextProvider
+                }));
             }
         });
 exports.I18nLink = __webpack_exports__.I18nLink;