@bleedingdev/modern-js-plugin-i18n 3.2.0-ultramodern.2 → 3.2.0-ultramodern.23

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/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

@@ -75,10 +75,12 @@ async function createI18nextInstance() {
         return null;
     }
 }
+function getOptionalReactI18nextPackageName() {
+    return "react-i18next";
+}
 async function tryImportReactI18next() {
     try {
-        const reactI18next = await import("react-i18next");
-        return reactI18next;
+        return await import(getOptionalReactI18nextPackageName());
     } catch (error) {
         return null;
     }

package/dist/cjs/runtime/index.js

@@ -49,8 +49,8 @@ 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;
@@ -59,8 +59,8 @@ const i18nPlugin = (options)=>({
                 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)();
+                const initReactI18next = reactI18next ? await (0, instance_js_namespaceObject.getInitReactI18next)() : null;
+                I18nextProvider = reactI18next ? await (0, instance_js_namespaceObject.getI18nextProvider)() : null;
                 if (initReactI18next) i18nInstance.use(initReactI18next);
                 const pathname = (0, external_utils_js_namespaceObject.getPathname)(context);
                 if (i18nextDetector) (0, detection_middleware_js_namespaceObject.useI18nextLanguageDetector)(i18nInstance);
@@ -121,14 +121,15 @@ 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 appContent = /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)(jsx_runtime_namespaceObject.Fragment, {

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
+});

package/dist/cjs/runtime/utils.js

@@ -1,19 +1,5 @@
 "use strict";
-var __webpack_modules__ = {
-    "@modern-js/runtime/router" (module) {
-        module.exports = require("@modern-js/runtime/router");
-    }
-};
-var __webpack_module_cache__ = {};
-function __webpack_require__(moduleId) {
-    var cachedModule = __webpack_module_cache__[moduleId];
-    if (void 0 !== cachedModule) return cachedModule.exports;
-    var module = __webpack_module_cache__[moduleId] = {
-        exports: {}
-    };
-    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
-    return module.exports;
-}
+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, {
@@ -36,100 +22,83 @@ function __webpack_require__(moduleId) {
     };
 })();
 var __webpack_exports__ = {};
-(()=>{
-    __webpack_require__.r(__webpack_exports__);
-    __webpack_require__.d(__webpack_exports__, {
-        buildLocalizedUrl: ()=>buildLocalizedUrl,
-        detectLanguageFromPath: ()=>detectLanguageFromPath,
-        getEntryPath: ()=>getEntryPath,
-        getLanguageFromPath: ()=>getLanguageFromPath,
-        getPathname: ()=>getPathname,
-        shouldIgnoreRedirect: ()=>shouldIgnoreRedirect,
-        useRouterHooks: ()=>useRouterHooks
-    });
-    const runtime_namespaceObject = require("@modern-js/runtime");
-    const context_namespaceObject = require("@modern-js/runtime/context");
-    const getPathname = (context)=>{
-        if ((0, runtime_namespaceObject.isBrowser)()) return window.location.pathname;
-        return context.ssrContext?.request?.pathname || '/';
-    };
-    const getEntryPath = ()=>{
-        const basename = (0, context_namespaceObject.getGlobalBasename)();
-        if (basename) return '/' === basename ? '' : basename;
-        return '';
-    };
-    const getLanguageFromPath = (pathname, languages, fallbackLanguage)=>{
-        const segments = pathname.split('/').filter(Boolean);
-        const firstSegment = segments[0];
-        if (languages.includes(firstSegment)) return firstSegment;
-        return fallbackLanguage;
-    };
-    const buildLocalizedUrl = (pathname, language, languages)=>{
-        const segments = pathname.split('/').filter(Boolean);
-        if (segments.length > 0 && languages.includes(segments[0])) segments[0] = language;
-        else segments.unshift(language);
-        return `/${segments.join('/')}`;
-    };
-    const detectLanguageFromPath = (pathname, languages, localePathRedirect)=>{
-        if (!localePathRedirect) return {
-            detected: false
-        };
-        const entryPath = getEntryPath();
-        const relativePath = pathname.replace(entryPath, '');
-        const segments = relativePath.split('/').filter(Boolean);
-        const segmentsToCheck = !entryPath && segments.length > 1 && segments[0] && !languages.includes(segments[0]) ? segments.slice(1) : segments;
-        const firstSegment = segmentsToCheck[0];
-        if (firstSegment && languages.includes(firstSegment)) return {
-            detected: true,
-            language: firstSegment
-        };
-        return {
-            detected: false
-        };
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    buildLocalizedUrl: ()=>buildLocalizedUrl,
+    detectLanguageFromPath: ()=>detectLanguageFromPath,
+    getEntryPath: ()=>getEntryPath,
+    getLanguageFromPath: ()=>getLanguageFromPath,
+    getPathname: ()=>getPathname,
+    shouldIgnoreRedirect: ()=>shouldIgnoreRedirect
+});
+const runtime_namespaceObject = require("@modern-js/runtime");
+const context_namespaceObject = require("@modern-js/runtime/context");
+const localisedUrls_js_namespaceObject = require("../shared/localisedUrls.js");
+const getPathname = (context)=>{
+    if ((0, runtime_namespaceObject.isBrowser)()) return window.location.pathname;
+    return context.ssrContext?.request?.pathname || '/';
+};
+const getEntryPath = ()=>{
+    const basename = (0, context_namespaceObject.getGlobalBasename)();
+    if (basename) return '/' === basename ? '' : basename;
+    return '';
+};
+const getLanguageFromPath = (pathname, languages, fallbackLanguage)=>{
+    const segments = pathname.split('/').filter(Boolean);
+    const firstSegment = segments[0];
+    if (languages.includes(firstSegment)) return firstSegment;
+    return fallbackLanguage;
+};
+const buildLocalizedUrl = (pathname, language, languages, localisedUrls)=>{
+    const segments = pathname.split('/').filter(Boolean);
+    const localisedUrlsConfig = (0, localisedUrls_js_namespaceObject.resolveLocalisedUrlsConfig)(localisedUrls);
+    const pathWithoutLanguage = segments.length > 0 && languages.includes(segments[0]) ? `/${segments.slice(1).join('/')}` : pathname;
+    const resolvedPath = localisedUrlsConfig.enabled ? (0, localisedUrls_js_namespaceObject.resolveLocalisedPath)(pathWithoutLanguage, language, languages, localisedUrlsConfig.map) : pathWithoutLanguage;
+    const resolvedSegments = resolvedPath.split('/').filter(Boolean);
+    return `/${[
+        language,
+        ...resolvedSegments
+    ].join('/')}`;
+};
+const detectLanguageFromPath = (pathname, languages, localePathRedirect)=>{
+    if (!localePathRedirect) return {
+        detected: false
     };
-    const shouldIgnoreRedirect = (pathname, languages, ignoreRedirectRoutes)=>{
-        if (!ignoreRedirectRoutes) return false;
-        const segments = pathname.split('/').filter(Boolean);
-        let pathWithoutLang = pathname;
-        if (segments.length > 0 && languages.includes(segments[0])) pathWithoutLang = `/${segments.slice(1).join('/')}`;
-        const normalizedPath = pathWithoutLang.startsWith('/') ? pathWithoutLang : `/${pathWithoutLang}`;
-        if ('function' == typeof ignoreRedirectRoutes) return ignoreRedirectRoutes(normalizedPath);
-        return ignoreRedirectRoutes.some((pattern)=>normalizedPath === pattern || normalizedPath.startsWith(`${pattern}/`));
+    const entryPath = getEntryPath();
+    const relativePath = pathname.replace(entryPath, '');
+    const segments = relativePath.split('/').filter(Boolean);
+    const segmentsToCheck = !entryPath && segments.length > 1 && segments[0] && !languages.includes(segments[0]) ? segments.slice(1) : segments;
+    const firstSegment = segmentsToCheck[0];
+    if (firstSegment && languages.includes(firstSegment)) return {
+        detected: true,
+        language: firstSegment
     };
-    const useRouterHooks = ()=>{
-        try {
-            const { useLocation, useNavigate, useParams } = __webpack_require__("@modern-js/runtime/router");
-            return {
-                navigate: useNavigate(),
-                location: useLocation(),
-                params: useParams(),
-                hasRouter: true
-            };
-        } catch (error) {
-            return {
-                navigate: null,
-                location: null,
-                params: {},
-                hasRouter: false
-            };
-        }
+    return {
+        detected: false
     };
-})();
+};
+const shouldIgnoreRedirect = (pathname, languages, ignoreRedirectRoutes)=>{
+    if (!ignoreRedirectRoutes) return false;
+    const segments = pathname.split('/').filter(Boolean);
+    let pathWithoutLang = pathname;
+    if (segments.length > 0 && languages.includes(segments[0])) pathWithoutLang = `/${segments.slice(1).join('/')}`;
+    const normalizedPath = pathWithoutLang.startsWith('/') ? pathWithoutLang : `/${pathWithoutLang}`;
+    if ('function' == typeof ignoreRedirectRoutes) return ignoreRedirectRoutes(normalizedPath);
+    return ignoreRedirectRoutes.some((pattern)=>normalizedPath === pattern || normalizedPath.startsWith(`${pattern}/`));
+};
 exports.buildLocalizedUrl = __webpack_exports__.buildLocalizedUrl;
 exports.detectLanguageFromPath = __webpack_exports__.detectLanguageFromPath;
 exports.getEntryPath = __webpack_exports__.getEntryPath;
 exports.getLanguageFromPath = __webpack_exports__.getLanguageFromPath;
 exports.getPathname = __webpack_exports__.getPathname;
 exports.shouldIgnoreRedirect = __webpack_exports__.shouldIgnoreRedirect;
-exports.useRouterHooks = __webpack_exports__.useRouterHooks;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "buildLocalizedUrl",
     "detectLanguageFromPath",
     "getEntryPath",
     "getLanguageFromPath",
     "getPathname",
-    "shouldIgnoreRedirect",
-    "useRouterHooks"
+    "shouldIgnoreRedirect"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true