@bleedingdev/modern-js-plugin-i18n 3.2.0-ultramodern.9 → 3.2.0-ultramodern.90

package/dist/cjs/cli/index.js

@@ -41,6 +41,7 @@ const external_fs_namespaceObject = require("fs");
 var external_fs_default = /*#__PURE__*/ __webpack_require__.n(external_fs_namespaceObject);
 const external_path_namespaceObject = require("path");
 var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+const localisedUrls_js_namespaceObject = require("../shared/localisedUrls.js");
 const utils_js_namespaceObject = require("../shared/utils.js");
 function hasJsonFiles(dirPath) {
     try {
@@ -120,6 +121,27 @@ const i18nPlugin = (options = {})=>({
                     plugins
                 };
             });
+            api.modifyFileSystemRoutes(({ entrypoint, routes })=>{
+                if (!localeDetection) return {
+                    entrypoint,
+                    routes
+                };
+                const localeDetectionOptions = (0, utils_js_namespaceObject.getLocaleDetectionOptions)(entrypoint.entryName, localeDetection);
+                const { localePathRedirect, languages = [], localisedUrls } = localeDetectionOptions;
+                if (!localePathRedirect || 0 === languages.length) return {
+                    entrypoint,
+                    routes
+                };
+                const localisedUrlsConfig = (0, localisedUrls_js_namespaceObject.resolveLocalisedUrlsConfig)(localisedUrls);
+                if (!localisedUrlsConfig.enabled) return {
+                    entrypoint,
+                    routes
+                };
+                return {
+                    entrypoint,
+                    routes: (0, localisedUrls_js_namespaceObject.applyLocalisedUrlsToRoutes)(routes, languages, localisedUrlsConfig.map)
+                };
+            });
             api._internalServerPlugins(({ plugins })=>{
                 const { serverRoutes, metaName } = api.getAppContext();
                 const normalizedConfig = api.getNormalizedConfig();

package/dist/cjs/runtime/I18nLink.js

@@ -28,22 +28,14 @@ __webpack_require__.d(__webpack_exports__, {
     default: ()=>runtime_I18nLink
 });
 const jsx_runtime_namespaceObject = require("react/jsx-runtime");
-const router_namespaceObject = require("@modern-js/runtime/router");
 const external_context_js_namespaceObject = require("./context.js");
+const external_routerAdapter_js_namespaceObject = require("./routerAdapter.js");
 const external_utils_js_namespaceObject = require("./utils.js");
-const useRouterHooks = ()=>{
-    const inRouter = (0, router_namespaceObject.useInRouterContext)();
-    return {
-        Link: inRouter ? router_namespaceObject.Link : null,
-        params: inRouter ? (0, router_namespaceObject.useParams)() : {},
-        hasRouter: inRouter
-    };
-};
 const I18nLink = ({ to, children, ...props })=>{
-    const { Link, params, hasRouter } = useRouterHooks();
-    const { language, supportedLanguages } = (0, external_context_js_namespaceObject.useModernI18n)();
+    const { Link, params, hasRouter } = (0, external_routerAdapter_js_namespaceObject.useI18nRouterAdapter)();
+    const { language, supportedLanguages, localisedUrls } = (0, external_context_js_namespaceObject.useModernI18n)();
     const currentLang = language;
-    const localizedTo = (0, external_utils_js_namespaceObject.buildLocalizedUrl)(to, currentLang, supportedLanguages);
+    const localizedTo = (0, external_utils_js_namespaceObject.buildLocalizedUrl)(to, currentLang, supportedLanguages, localisedUrls);
     if ('development' === process.env.NODE_ENV && hasRouter && !params.lang) console.warn("I18nLink is being used outside of a :lang dynamic route context. This may cause unexpected behavior. Please ensure I18nLink is used within a route that has a :lang parameter.");
     if (!hasRouter || !Link) return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("a", {
         href: localizedTo,

package/dist/cjs/runtime/context.js

@@ -31,6 +31,7 @@ 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_routerAdapter_js_namespaceObject = require("./routerAdapter.js");
 const external_utils_js_namespaceObject = require("./utils.js");
 const ModernI18nContext = /*#__PURE__*/ (0, external_react_namespaceObject.createContext)(null);
 const ModernI18nProvider = ({ children, value })=>/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(ModernI18nContext.Provider, {
@@ -40,9 +41,33 @@ 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');
-    const { language: contextLanguage, i18nInstance, languages, localePathRedirect, ignoreRedirectRoutes, updateLanguage } = context;
-    const { navigate, location, hasRouter } = (0, external_utils_js_namespaceObject.useRouterHooks)();
-    const currentLanguage = contextLanguage;
+    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;
+    }, [
+        languages,
+        localePathRedirect,
+        location?.pathname
+    ]);
+    const currentLanguage = pathLanguage || contextLanguage;
+    (0, external_react_namespaceObject.useEffect)(()=>{
+        if (!pathLanguage || pathLanguage === contextLanguage) return;
+        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);
+        }
+    }, [
+        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');
@@ -59,7 +84,7 @@ const useModernI18n = ()=>{
                 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 || []);
+                    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
@@ -72,7 +97,7 @@ const useModernI18n = ()=>{
                 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 || []);
+                    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);
                 }
@@ -87,6 +112,7 @@ const useModernI18n = ()=>{
         updateLanguage,
         localePathRedirect,
         ignoreRedirectRoutes,
+        localisedUrls,
         languages,
         hasRouter,
         navigate,
@@ -127,6 +153,7 @@ const useModernI18n = ()=>{
         changeLanguage,
         i18nInstance,
         supportedLanguages: languages || [],
+        localisedUrls,
         isLanguageSupported,
         isResourcesReady
     };

package/dist/cjs/runtime/hooks.js

@@ -33,6 +33,7 @@ const runtime_namespaceObject = require("@modern-js/runtime");
 const external_react_namespaceObject = require("react");
 const sdk_event_js_namespaceObject = require("./i18n/backend/sdk-event.js");
 const index_js_namespaceObject = require("./i18n/detection/index.js");
+const external_routerAdapter_js_namespaceObject = require("./routerAdapter.js");
 const external_utils_js_namespaceObject = require("./utils.js");
 function createMinimalI18nInstance(language) {
     const minimalInstance = {
@@ -45,7 +46,7 @@ function createMinimalI18nInstance(language) {
     };
     return minimalInstance;
 }
-function createContextValue(lang, i18nInstance, entryName, languages, localePathRedirect, ignoreRedirectRoutes, setLang) {
+function createContextValue(lang, i18nInstance, entryName, languages, localePathRedirect, ignoreRedirectRoutes, localisedUrls, setLang) {
     const instance = i18nInstance || createMinimalI18nInstance(lang);
     return {
         language: lang,
@@ -54,6 +55,7 @@ function createContextValue(lang, i18nInstance, entryName, languages, localePath
         languages,
         localePathRedirect,
         ignoreRedirectRoutes,
+        localisedUrls,
         updateLanguage: setLang
     };
 }
@@ -103,9 +105,9 @@ function useSdkResourcesLoader(i18nInstance, setForceUpdate) {
         setForceUpdate
     ]);
 }
-function useClientSideRedirect(i18nInstance, localePathRedirect, languages, fallbackLanguage, ignoreRedirectRoutes) {
+function useClientSideRedirect(i18nInstance, localePathRedirect, languages, fallbackLanguage, ignoreRedirectRoutes, localisedUrls) {
     const hasRedirectedRef = (0, external_react_namespaceObject.useRef)(false);
-    const { navigate, location, hasRouter } = (0, external_utils_js_namespaceObject.useRouterHooks)();
+    const { navigate, location, hasRouter } = (0, external_routerAdapter_js_namespaceObject.useI18nRouterAdapter)();
     (0, external_react_namespaceObject.useEffect)(()=>{
         if ('browser' !== process.env.MODERN_TARGET) return;
         if (!localePathRedirect || !i18nInstance) return;
@@ -124,7 +126,7 @@ function useClientSideRedirect(i18nInstance, localePathRedirect, languages, fall
         const pathDetection = (0, external_utils_js_namespaceObject.detectLanguageFromPath)(currentPathname, languages, localePathRedirect);
         if (pathDetection.detected) return;
         const targetLanguage = i18nInstance.language || fallbackLanguage || languages[0] || 'en';
-        const newPath = (0, external_utils_js_namespaceObject.buildLocalizedUrl)(relativePath, targetLanguage, languages);
+        const newPath = (0, external_utils_js_namespaceObject.buildLocalizedUrl)(relativePath, targetLanguage, languages, localisedUrls);
         const newUrl = entryPath + newPath + currentSearch + currentHash;
         if (newUrl !== currentPathname + currentSearch + currentHash) {
             hasRedirectedRef.current = true;
@@ -141,7 +143,8 @@ function useClientSideRedirect(i18nInstance, localePathRedirect, languages, fall
         i18nInstance,
         languages,
         fallbackLanguage,
-        ignoreRedirectRoutes
+        ignoreRedirectRoutes,
+        localisedUrls
     ]);
 }
 function useLanguageSync(i18nInstance, localePathRedirect, languages, runtimeContextRef, prevLangRef, setLang) {

package/dist/cjs/runtime/i18n/backend/defaults.js

@@ -33,7 +33,7 @@ const DEFAULT_I18NEXT_BACKEND_OPTIONS = {
 };
 function convertPath(path) {
     if (!path) return path;
-    if (path.startsWith('/')) return `${window.__assetPrefix__ || ''}${path}`;
+    if (path.startsWith('/')) return "u" < typeof window ? path : `${window.__assetPrefix__ || ''}${path}`;
     return path;
 }
 function convertBackendOptions(options) {

package/dist/cjs/runtime/i18n/backend/defaults.node.js

@@ -28,8 +28,8 @@ __webpack_require__.d(__webpack_exports__, {
     convertBackendOptions: ()=>convertBackendOptions
 });
 const DEFAULT_I18NEXT_BACKEND_OPTIONS = {
-    loadPath: './locales/{{lng}}/{{ns}}.json',
-    addPath: './locales/{{lng}}/{{ns}}.json'
+    loadPath: './config/public/locales/{{lng}}/{{ns}}.json',
+    addPath: './config/public/locales/{{lng}}/{{ns}}.json'
 };
 function convertPath(path) {
     if (!path) return path;

package/dist/cjs/runtime/i18n/backend/middleware.node.js

@@ -37,14 +37,14 @@ __webpack_require__.d(__webpack_exports__, {
     HttpBackendWithSave: ()=>HttpBackendWithSave,
     useI18nextBackend: ()=>useI18nextBackend
 });
-const external_i18next_fs_backend_namespaceObject = require("i18next-fs-backend");
-var external_i18next_fs_backend_default = /*#__PURE__*/ __webpack_require__.n(external_i18next_fs_backend_namespaceObject);
+const cjs_namespaceObject = require("i18next-fs-backend/cjs");
+var cjs_default = /*#__PURE__*/ __webpack_require__.n(cjs_namespaceObject);
 const external_middleware_common_js_namespaceObject = require("./middleware.common.js");
-class FsBackendWithSave extends external_i18next_fs_backend_default() {
+class FsBackendWithSave extends cjs_default() {
     save(_language, _namespace, _data) {}
 }
 const HttpBackendWithSave = FsBackendWithSave;
-const useI18nextBackend = (i18nInstance, backend)=>(0, external_middleware_common_js_namespaceObject.useI18nextBackendCommon)(i18nInstance, FsBackendWithSave, external_i18next_fs_backend_default(), backend);
+const useI18nextBackend = (i18nInstance, backend)=>(0, external_middleware_common_js_namespaceObject.useI18nextBackendCommon)(i18nInstance, FsBackendWithSave, cjs_default(), backend);
 exports.FsBackendWithSave = __webpack_exports__.FsBackendWithSave;
 exports.HttpBackendWithSave = __webpack_exports__.HttpBackendWithSave;
 exports.useI18nextBackend = __webpack_exports__.useI18nextBackend;

package/dist/cjs/runtime/i18n/instance.js

@@ -28,8 +28,6 @@ __webpack_require__.d(__webpack_exports__, {
     getI18nInstance: ()=>getI18nInstance,
     getI18nWrapperI18nextInstance: ()=>getI18nWrapperI18nextInstance,
     getI18nextInstanceForProvider: ()=>getI18nextInstanceForProvider,
-    getI18nextProvider: ()=>getI18nextProvider,
-    getInitReactI18next: ()=>getInitReactI18next,
     isI18nInstance: ()=>isI18nInstance,
     isI18nWrapperInstance: ()=>isI18nWrapperInstance
 });
@@ -75,14 +73,6 @@ async function createI18nextInstance() {
         return null;
     }
 }
-async function tryImportReactI18next() {
-    try {
-        const reactI18next = await import("react-i18next");
-        return reactI18next;
-    } catch (error) {
-        return null;
-    }
-}
 function getI18nextInstanceForProvider(instance) {
     if (isI18nWrapperInstance(instance)) {
         const i18nextInstance = getI18nWrapperI18nextInstance(instance);
@@ -99,22 +89,10 @@ async function getI18nInstance(userInstance) {
     if (i18nextInstance) return i18nextInstance;
     throw new Error('No i18n instance found');
 }
-async function getInitReactI18next() {
-    const reactI18nextModule = await tryImportReactI18next();
-    if (reactI18nextModule) return reactI18nextModule.initReactI18next;
-    return null;
-}
-async function getI18nextProvider() {
-    const reactI18nextModule = await tryImportReactI18next();
-    if (reactI18nextModule) return reactI18nextModule.I18nextProvider;
-    return null;
-}
 exports.getActualI18nextInstance = __webpack_exports__.getActualI18nextInstance;
 exports.getI18nInstance = __webpack_exports__.getI18nInstance;
 exports.getI18nWrapperI18nextInstance = __webpack_exports__.getI18nWrapperI18nextInstance;
 exports.getI18nextInstanceForProvider = __webpack_exports__.getI18nextInstanceForProvider;
-exports.getI18nextProvider = __webpack_exports__.getI18nextProvider;
-exports.getInitReactI18next = __webpack_exports__.getInitReactI18next;
 exports.isI18nInstance = __webpack_exports__.isI18nInstance;
 exports.isI18nWrapperInstance = __webpack_exports__.isI18nWrapperInstance;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
@@ -122,8 +100,6 @@ for(var __rspack_i in __webpack_exports__)if (-1 === [
     "getI18nInstance",
     "getI18nWrapperI18nextInstance",
     "getI18nextInstanceForProvider",
-    "getI18nextProvider",
-    "getInitReactI18next",
     "isI18nInstance",
     "isI18nWrapperInstance"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];

package/dist/cjs/runtime/i18n/react-i18next.js

@@ -0,0 +1,49 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __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__, {
+    getReactI18nextIntegration: ()=>getReactI18nextIntegration
+});
+async function tryImportReactI18next() {
+    try {
+        return await import("react-i18next");
+    } catch (error) {
+        return null;
+    }
+}
+async function getReactI18nextIntegration() {
+    const reactI18nextModule = await tryImportReactI18next();
+    return {
+        I18nextProvider: reactI18nextModule?.I18nextProvider ?? null,
+        initReactI18next: reactI18nextModule?.initReactI18next ?? null
+    };
+}
+exports.getReactI18nextIntegration = __webpack_exports__.getReactI18nextIntegration;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "getReactI18nextIntegration"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/i18n/utils.js

@@ -133,18 +133,6 @@ const initializeI18nInstance = async (i18nInstance, finalLanguage, fallbackLangu
                 };
             }
         }
-        if (mergedBackend && hasOptions(i18nInstance)) {
-            const defaultNS = initOptions.defaultNS || initOptions.ns || 'translation';
-            const ns = Array.isArray(defaultNS) ? defaultNS[0] : defaultNS;
-            let retries = 20;
-            while(retries > 0){
-                const actualInstance = (0, external_instance_js_namespaceObject.getActualI18nextInstance)(i18nInstance);
-                const store = actualInstance.store;
-                if (store?.data?.[finalLanguage]?.[ns]) break;
-                await new Promise((resolve)=>setTimeout(resolve, 100));
-                retries--;
-            }
-        }
     }
 };
 function hasOptions(instance) {

package/dist/cjs/runtime/index.js

@@ -49,19 +49,24 @@ const external_I18nLink_js_namespaceObject = require("./I18nLink.js");
 const i18nPlugin = (options)=>({
         name: '@modern-js/plugin-i18n',
         setup: (api)=>{
-            const { entryName, i18nInstance: userI18nInstance, initOptions, localeDetection, backend, htmlLangAttr = false } = options;
-            const { localePathRedirect = false, i18nextDetector = true, languages = [], fallbackLanguage = 'en', detection, ignoreRedirectRoutes } = localeDetection || {};
+            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.js");
+                return getReactI18nextIntegration();
+            };
             api.onBeforeRender(async (context)=>{
                 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 initReactI18next = await (0, instance_js_namespaceObject.getInitReactI18next)();
-                I18nextProvider = await (0, instance_js_namespaceObject.getI18nextProvider)();
-                if (initReactI18next) i18nInstance.use(initReactI18next);
+                const reactI18nextIntegration = await loadReactI18nextIntegration();
+                I18nextProvider = reactI18nextIntegration?.I18nextProvider ?? null;
+                if (reactI18nextIntegration?.initReactI18next) i18nInstance.use(reactI18nextIntegration.initReactI18next);
                 const pathname = (0, external_utils_js_namespaceObject.getPathname)(context);
                 if (i18nextDetector) (0, detection_middleware_js_namespaceObject.useI18nextLanguageDetector)(i18nInstance);
                 const mergedDetection = (0, detection_index_js_namespaceObject.mergeDetectionOptions)(i18nextDetector, detection, localePathRedirect, userInitOptions);
@@ -121,16 +126,18 @@ const i18nPlugin = (options)=>({
                     ]);
                     (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);
-                    const contextValue = (0, external_react_namespaceObject.useMemo)(()=>(0, external_hooks_js_namespaceObject.createContextValue)(lang, i18nInstance, entryName, languages, localePathRedirect, ignoreRedirectRoutes, 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, {
@@ -140,9 +147,10 @@ const i18nPlugin = (options)=>({
                             }),
                             /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_context_js_namespaceObject.ModernI18nProvider, {
                                 value: contextValue,
-                                children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(App, {
-                                    ...props
-                                })
+                                children: App ? /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(App, {
+                                    ...props,
+                                    children: children
+                                }) : children
                             })
                         ]
                     });

package/dist/cjs/runtime/routerAdapter.js

@@ -0,0 +1,163 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __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__, {
+    useI18nRouterAdapter: ()=>useI18nRouterAdapter
+});
+const runtime_namespaceObject = require("@modern-js/runtime");
+const context_namespaceObject = require("@modern-js/runtime/context");
+const router_namespaceObject = require("@modern-js/runtime/router");
+const external_react_namespaceObject = require("react");
+const normalizeUrlPart = (value, prefix)=>{
+    if ('string' != typeof value || !value) return '';
+    return value.startsWith(prefix) ? value : `${prefix}${value}`;
+};
+const normalizeLocation = (location)=>{
+    if (!location || 'object' != typeof location) return null;
+    const locationValue = location;
+    if ('string' != typeof locationValue.pathname) return null;
+    return {
+        pathname: locationValue.pathname,
+        search: normalizeUrlPart('string' == typeof locationValue.search ? locationValue.search : locationValue.searchStr, '?'),
+        hash: normalizeUrlPart(locationValue.hash, '#')
+    };
+};
+const getWindowLocation = ()=>{
+    if (!(0, runtime_namespaceObject.isBrowser)()) return null;
+    return {
+        pathname: window.location.pathname,
+        search: window.location.search,
+        hash: window.location.hash
+    };
+};
+const getRouterFramework = (runtimeContext, internalContext, inReactRouter)=>{
+    const framework = internalContext.routerFramework || internalContext.routerRuntime?.framework || runtimeContext.routerFramework;
+    if (framework) return framework;
+    if (internalContext.router?.useRouter || runtimeContext.router?.useRouter) return 'tanstack';
+    if (internalContext.router?.useLocation || internalContext.router?.useHref || runtimeContext.router?.useLocation || runtimeContext.router?.useHref) return 'react-router';
+    if (inReactRouter) return 'react-router';
+};
+const getRouterInstance = (internalContext, contextRouter)=>{
+    if (contextRouter) return contextRouter;
+    const router = internalContext.routerInstance || internalContext.routerRuntime?.instance;
+    if (!router || 'object' != typeof router) return null;
+    return router;
+};
+const getRouterStateLocation = (internalContext, contextRouter)=>{
+    const router = getRouterInstance(internalContext, contextRouter);
+    return normalizeLocation(router?.stores?.location?.get?.()) || normalizeLocation(router?.state?.location);
+};
+const getRouterParams = (internalContext, contextRouter)=>{
+    const router = getRouterInstance(internalContext, contextRouter);
+    const matches = router?.stores?.matches?.get?.() || router?.state?.matches;
+    if (!Array.isArray(matches)) return {};
+    return matches.reduce((params, match)=>{
+        if (match?.params) Object.assign(params, match.params);
+        return params;
+    }, {});
+};
+const useI18nRouterAdapter = ()=>{
+    const runtimeContext = (0, external_react_namespaceObject.useContext)(runtime_namespaceObject.RuntimeContext);
+    const internalContext = (0, external_react_namespaceObject.useContext)(context_namespaceObject.InternalRuntimeContext);
+    const inReactRouter = (0, router_namespaceObject.useInRouterContext)();
+    const reactRouterNavigate = inReactRouter ? (0, router_namespaceObject.useNavigate)() : null;
+    const reactRouterLocation = inReactRouter ? (0, router_namespaceObject.useLocation)() : null;
+    const reactRouterParams = inReactRouter ? (0, router_namespaceObject.useParams)() : {};
+    const framework = getRouterFramework(runtimeContext, internalContext, inReactRouter);
+    const contextUseRouter = inReactRouter || 'tanstack' !== framework ? void 0 : internalContext.router?.useRouter || runtimeContext.router?.useRouter;
+    const contextRouter = contextUseRouter ? contextUseRouter({
+        warn: false
+    }) : null;
+    const [, setRouterVersion] = (0, external_react_namespaceObject.useState)(0);
+    const hasRouter = 'tanstack' === framework || 'react-router' === framework || Boolean(reactRouterNavigate);
+    (0, external_react_namespaceObject.useEffect)(()=>{
+        if ('tanstack' !== framework) return;
+        const router = getRouterInstance(internalContext, contextRouter);
+        if (!router) return;
+        const update = ()=>setRouterVersion((version)=>version + 1);
+        const unsubscribers = [];
+        if ('function' == typeof router.stores?.location?.subscribe) {
+            const unsubscribe = router.stores.location.subscribe(update);
+            if ('function' == typeof unsubscribe) unsubscribers.push(unsubscribe);
+        }
+        if ('function' == typeof router.subscribe) for (const eventType of [
+            'onBeforeNavigate',
+            'onBeforeLoad'
+        ]){
+            const unsubscribe = router.subscribe(eventType, update);
+            if ('function' == typeof unsubscribe) unsubscribers.push(unsubscribe);
+        }
+        return ()=>{
+            for (const unsubscribe of unsubscribers)unsubscribe();
+        };
+    }, [
+        contextRouter,
+        framework,
+        internalContext
+    ]);
+    const navigate = (0, external_react_namespaceObject.useCallback)((href, options)=>{
+        const router = getRouterInstance(internalContext, contextRouter);
+        const activeFramework = getRouterFramework(runtimeContext, internalContext, inReactRouter);
+        if ('tanstack' === activeFramework) {
+            if ('function' == typeof router?.navigate) return router.navigate({
+                to: href,
+                replace: options?.replace,
+                ...options?.state === void 0 ? {} : {
+                    state: options.state
+                }
+            });
+            throw new Error('TanStack router instance is not available.');
+        }
+        if (reactRouterNavigate) return reactRouterNavigate(href, options);
+        if ('react-router' === activeFramework) {
+            if ('function' == typeof router?.navigate) return router.navigate(href, options);
+            throw new Error('React Router instance is not available.');
+        }
+    }, [
+        contextRouter,
+        internalContext,
+        inReactRouter,
+        reactRouterNavigate,
+        runtimeContext
+    ]);
+    const location = (reactRouterLocation ? normalizeLocation(reactRouterLocation) : getRouterStateLocation(internalContext, contextRouter)) || getWindowLocation();
+    const params = inReactRouter ? reactRouterParams : getRouterParams(internalContext, contextRouter);
+    const Link = 'tanstack' === framework ? internalContext.router?.Link || runtimeContext.router?.Link || null : 'react-router' === framework || inReactRouter ? router_namespaceObject.Link : null;
+    return {
+        framework,
+        hasRouter,
+        location,
+        navigate: hasRouter ? navigate : null,
+        Link,
+        params
+    };
+};
+exports.useI18nRouterAdapter = __webpack_exports__.useI18nRouterAdapter;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "useI18nRouterAdapter"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});