@bleedingdev/modern-js-plugin-i18n 3.9.0-ultramodern.1 → 3.9.0-ultramodern.11

package/dist/cjs/runtime/providerComposition.js

@@ -31,7 +31,6 @@ __webpack_require__.d(__webpack_exports__, {
     createI18nRootWrapper: ()=>createI18nRootWrapper
 });
 const jsx_runtime_namespaceObject = require("react/jsx-runtime");
-const i18n_runtime_extensions_namespaceObject = require("@modern-js/i18n-runtime-extensions");
 const runtime_namespaceObject = require("@modern-js/runtime");
 const head_namespaceObject = require("@modern-js/runtime/head");
 const external_react_namespaceObject = require("react");
@@ -39,8 +38,14 @@ const external_context_js_namespaceObject = require("./context.js");
 const external_hooks_js_namespaceObject = require("./hooks.js");
 const instance_js_namespaceObject = require("./i18n/instance.js");
 const external_routerAdapter_js_namespaceObject = require("./routerAdapter.js");
-const createI18nRootWrapper = (options)=>(App)=>(props)=>{
-            const { entryName, htmlLangAttr, localePathRedirect, languages, fallbackLanguage, ignoreRedirectRoutes, localisedUrls, getLatestI18nInstance, getI18nextProvider } = options;
+const NativeLanguageSynchronization = ({ i18nInstance, localePathRedirect, languages, pathname, prevLangRef, setLang, children })=>{
+    const synchronizeLanguage = (0, external_hooks_js_namespaceObject.useLanguageSync)(i18nInstance, localePathRedirect, languages, pathname, prevLangRef, setLang);
+    return children(synchronizeLanguage);
+};
+const createI18nRootWrapper = (options)=>(App)=>{
+        const LanguageSynchronization = options.LanguageSynchronization ?? NativeLanguageSynchronization;
+        const I18nRoot = (props)=>{
+            const { entryName, htmlLangAttr, localePathRedirect, languages, fallbackLanguage, ignoreRedirectRoutes, urlStrategy, getLatestI18nInstance, getI18nextProvider } = options;
             const runtimeContext = (0, external_react_namespaceObject.useContext)(runtime_namespaceObject.RuntimeContext);
             const i18nInstance = runtimeContext.i18nInstance || getLatestI18nInstance();
             const initialLang = (0, external_react_namespaceObject.useMemo)(()=>i18nInstance?.language || fallbackLanguage, [
@@ -65,18 +70,16 @@ const createI18nRootWrapper = (options)=>(App)=>(props)=>{
                 lang
             ]);
             (0, external_hooks_js_namespaceObject.useSdkResourcesLoader)(i18nInstance, setForceUpdate);
-            const synchronizeLanguage = (0, i18n_runtime_extensions_namespaceObject.useLanguageSync)(i18nInstance, localePathRedirect, languages, location?.pathname, 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, synchronizeLanguage), [
+            (0, external_hooks_js_namespaceObject.useClientSideRedirect)(i18nInstance, localePathRedirect, languages, fallbackLanguage, ignoreRedirectRoutes, urlStrategy);
+            const contextValue = (0, external_react_namespaceObject.useMemo)(()=>(0, external_hooks_js_namespaceObject.createContextValue)(lang, i18nInstance, entryName, languages, localePathRedirect, ignoreRedirectRoutes, setLang, urlStrategy), [
                 lang,
                 i18nInstance,
                 entryName,
                 languages,
                 localePathRedirect,
                 ignoreRedirectRoutes,
-                localisedUrls,
-                forceUpdate,
-                synchronizeLanguage
+                urlStrategy,
+                forceUpdate
             ]);
             const I18nextProvider = getI18nextProvider();
             const i18nextInstanceForProvider = (0, external_react_namespaceObject.useMemo)(()=>i18nInstance ? (0, instance_js_namespaceObject.getI18nextInstanceForProvider)(i18nInstance, lang) : void 0, [
@@ -99,14 +102,35 @@ const createI18nRootWrapper = (options)=>(App)=>(props)=>{
                             lang
                         }
                     }),
-                    /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_context_js_namespaceObject.ModernI18nProvider, {
-                        i18nextProvider: I18nextProvider,
-                        value: contextValue,
-                        children: appContent
+                    /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(LanguageSynchronization, {
+                        i18nInstance: i18nInstance,
+                        localePathRedirect: localePathRedirect,
+                        languages: languages,
+                        pathname: location?.pathname,
+                        prevLangRef: prevLangRef,
+                        setLang: setLang,
+                        children: (synchronizeLanguage)=>/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_context_js_namespaceObject.ModernI18nProvider, {
+                                i18nextProvider: I18nextProvider,
+                                value: {
+                                    ...contextValue,
+                                    synchronizeLanguage
+                                },
+                                children: appContent
+                            })
                     })
                 ]
             });
         };
+        const { NavigationProvider } = options;
+        if (!NavigationProvider) return I18nRoot;
+        return function(props) {
+            return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(NavigationProvider, {
+                children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(I18nRoot, {
+                    ...props
+                })
+            });
+        };
+    };
 exports.createI18nRootWrapper = __webpack_exports__.createI18nRootWrapper;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "createI18nRootWrapper"

package/dist/cjs/runtime/routerAdapter.js

@@ -28,160 +28,55 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    useI18nRouterAdapter: ()=>useI18nRouterAdapter
+    I18nNavigationProvider: ()=>I18nNavigationProvider,
+    useI18nRouterAdapter: ()=>useI18nRouterAdapter,
+    useNativeI18nRouterAdapter: ()=>useNativeI18nRouterAdapter
 });
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
 const runtime_namespaceObject = require("@modern-js/runtime");
 const context_namespaceObject = require("@modern-js/runtime/context");
 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 = (0, context_namespaceObject.getRouterRuntimeState)(internalContext)?.framework || (0, context_namespaceObject.getRouterRuntimeState)(runtimeContext)?.framework;
-    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 = (0, context_namespaceObject.getRouterRuntimeState)(internalContext)?.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 getRouterSnapshot = (internalContext, contextRouter)=>{
-    const location = getRouterStateLocation(internalContext, contextRouter);
-    const params = getRouterParams(internalContext, contextRouter);
-    return JSON.stringify([
-        location?.pathname ?? '',
-        location?.search ?? '',
-        location?.hash ?? '',
-        Object.entries(params).sort(([left], [right])=>left.localeCompare(right))
-    ]);
-};
-const useI18nRouterAdapter = ()=>{
+const navigationContextKey = Symbol.for('@modern-js/plugin-i18n/runtime/I18nNavigationContext');
+const contextStore = globalThis;
+const I18nNavigationContext = contextStore[navigationContextKey] ??= /*#__PURE__*/ (0, external_react_namespaceObject.createContext)(null);
+const I18nNavigationProvider = ({ children, value })=>/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(I18nNavigationContext.Provider, {
+        value: value,
+        children: children
+    });
+const useNativeI18nRouterAdapter = ()=>{
     const runtimeContext = (0, external_react_namespaceObject.useContext)(runtime_namespaceObject.RuntimeContext);
     const internalContext = (0, external_react_namespaceObject.useContext)(context_namespaceObject.InternalRuntimeContext);
     const routerApi = internalContext.router || runtimeContext.router;
-    const inReactRouter = routerApi?.useInRouterContext?.() ?? false;
-    const reactRouterNavigate = inReactRouter ? routerApi?.useNavigate?.() ?? null : null;
-    const reactRouterLocation = inReactRouter ? routerApi?.useLocation?.() ?? null : null;
-    const reactRouterParams = inReactRouter ? routerApi?.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 hasRouter = 'tanstack' === framework || 'react-router' === framework || Boolean(reactRouterNavigate);
-    const subscribeToRouter = (0, external_react_namespaceObject.useCallback)((update)=>{
-        const router = getRouterInstance(internalContext, contextRouter);
-        if (!router) return ()=>void 0;
-        const unsubscribers = [];
-        if ('react-router' === framework && !inReactRouter && 'function' == typeof router.subscribe) {
-            const subscribe = router.subscribe;
-            const unsubscribe = subscribe.call(router, update);
-            if ('function' == typeof unsubscribe) unsubscribers.push(unsubscribe);
-        }
-        if ('tanstack' === framework && 'function' == typeof router.stores?.location?.subscribe) {
-            const unsubscribe = router.stores.location.subscribe(update);
-            if ('function' == typeof unsubscribe) unsubscribers.push(unsubscribe);
-        }
-        if ('tanstack' === framework && 'function' == typeof router.subscribe) {
-            const subscribe = router.subscribe;
-            for (const eventType of [
-                'onBeforeNavigate',
-                'onBeforeLoad'
-            ]){
-                const unsubscribe = subscribe.call(router, eventType, update);
-                if ('function' == typeof unsubscribe) unsubscribers.push(unsubscribe);
-            }
-        }
-        return ()=>{
-            for (const unsubscribe of unsubscribers)unsubscribe();
-        };
-    }, [
-        contextRouter,
-        framework,
-        inReactRouter,
-        internalContext
-    ]);
-    const getSnapshot = (0, external_react_namespaceObject.useCallback)(()=>getRouterSnapshot(internalContext, contextRouter), [
-        contextRouter,
-        internalContext
-    ]);
-    (0, external_react_namespaceObject.useSyncExternalStore)(subscribeToRouter, getSnapshot, getSnapshot);
-    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 ? routerApi?.Link ?? null : null;
+    const hasRouter = routerApi?.useInRouterContext?.() ?? false;
+    const navigate = hasRouter ? routerApi?.useNavigate?.() ?? null : null;
+    const routerLocation = hasRouter ? routerApi?.useLocation?.() ?? null : null;
+    const params = hasRouter ? routerApi?.useParams?.() ?? {} : {};
+    const location = routerLocation ?? ((0, runtime_namespaceObject.isBrowser)() ? {
+        pathname: window.location.pathname,
+        search: window.location.search,
+        hash: window.location.hash
+    } : null);
     return {
-        framework,
+        framework: hasRouter ? 'react-router' : void 0,
         hasRouter,
+        navigate,
         location,
-        navigate: hasRouter ? navigate : null,
-        Link,
-        params
+        params,
+        Link: hasRouter ? routerApi?.Link ?? null : null
     };
 };
+const useI18nRouterAdapter = ()=>{
+    const provided = (0, external_react_namespaceObject.useContext)(I18nNavigationContext);
+    const native = useNativeI18nRouterAdapter();
+    return provided ?? native;
+};
+exports.I18nNavigationProvider = __webpack_exports__.I18nNavigationProvider;
 exports.useI18nRouterAdapter = __webpack_exports__.useI18nRouterAdapter;
+exports.useNativeI18nRouterAdapter = __webpack_exports__.useNativeI18nRouterAdapter;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "useI18nRouterAdapter"
+    "I18nNavigationProvider",
+    "useI18nRouterAdapter",
+    "useNativeI18nRouterAdapter"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true

package/dist/cjs/runtime/utils.js

@@ -34,11 +34,13 @@ __webpack_require__.d(__webpack_exports__, {
     getLanguageFromPath: ()=>getLanguageFromPath,
     getPathname: ()=>getPathname,
     shouldIgnoreRedirect: ()=>shouldIgnoreRedirect,
-    splitUrlTarget: ()=>splitUrlTarget
+    splitUrlTarget: ()=>url_namespaceObject.splitUrlTarget
 });
-const i18n_runtime_extensions_namespaceObject = require("@modern-js/i18n-runtime-extensions");
 const runtime_namespaceObject = require("@modern-js/runtime");
 const context_namespaceObject = require("@modern-js/runtime/context");
+const url_namespaceObject = require("@modern-js/runtime-utils/url");
+const mappedUrlStrategy_js_namespaceObject = require("../shared/mappedUrlStrategy.js");
+const urlStrategy_js_namespaceObject = require("../shared/urlStrategy.js");
 const getPathname = (context)=>{
     if ((0, runtime_namespaceObject.isBrowser)()) return window.location.pathname;
     return context.ssrContext?.request?.pathname || '/';
@@ -54,22 +56,14 @@ const getLanguageFromPath = (pathname, languages, fallbackLanguage)=>{
     if (languages.includes(firstSegment)) return firstSegment;
     return fallbackLanguage;
 };
-const splitUrlTarget = (target)=>{
-    const hashIndex = target.indexOf('#');
-    const hash = hashIndex >= 0 ? target.slice(hashIndex) : '';
-    const beforeHash = hashIndex >= 0 ? target.slice(0, hashIndex) : target;
-    const searchIndex = beforeHash.indexOf('?');
-    const search = searchIndex >= 0 ? beforeHash.slice(searchIndex) : '';
-    const pathname = searchIndex >= 0 ? beforeHash.slice(0, searchIndex) : beforeHash;
-    return {
-        pathname,
-        search,
-        hash
-    };
-};
-const buildLocalizedUrl = (target, language, languages, localisedUrls)=>{
-    const { pathname, search, hash } = splitUrlTarget(target);
-    const localizedPathname = (0, i18n_runtime_extensions_namespaceObject.localiseTargetPathname)(pathname, language, languages, localisedUrls);
+const buildLocalizedUrl = (target, language, languages, urlStrategy)=>{
+    const { pathname, search, hash } = (0, url_namespaceObject.splitUrlTarget)(target);
+    const strategy = (0, urlStrategy_js_namespaceObject.asI18nUrlStrategy)(urlStrategy);
+    if (strategy) return `${strategy.localizePathname(pathname, language, languages)}${search}${hash}`;
+    const segments = pathname.split('/').filter(Boolean);
+    if (segments[0] && languages.some((item)=>item.toLowerCase() === segments[0].toLowerCase())) segments[0] = language;
+    else segments.unshift(language);
+    const localizedPathname = `/${segments.join('/')}`;
     return `${localizedPathname}${search}${hash}`;
 };
 const detectLanguageFromPath = (pathname, languages, localePathRedirect)=>{
@@ -89,7 +83,15 @@ const detectLanguageFromPath = (pathname, languages, localePathRedirect)=>{
         detected: false
     };
 };
-const shouldIgnoreRedirect = (pathname, languages, ignoreRedirectRoutes)=>(0, i18n_runtime_extensions_namespaceObject.shouldSkipLocaleRedirect)(pathname, languages, ignoreRedirectRoutes);
+const shouldIgnoreRedirect = (pathname, languages, ignoreRedirectRoutes, urlStrategy)=>{
+    if ((0, mappedUrlStrategy_js_namespaceObject.isDefaultLocaleRedirectSkipPath)(pathname, languages)) return true;
+    if ((0, urlStrategy_js_namespaceObject.asI18nUrlStrategy)(urlStrategy)?.shouldSkipRedirect?.(pathname, languages)) return true;
+    if (!ignoreRedirectRoutes) return false;
+    const segments = pathname.split('/').filter(Boolean);
+    if (segments[0] && languages.some((item)=>item.toLowerCase() === segments[0].toLowerCase())) segments.shift();
+    const normalizedPath = `/${segments.join('/')}`;
+    return 'function' == typeof ignoreRedirectRoutes ? ignoreRedirectRoutes(normalizedPath) : ignoreRedirectRoutes.some((pattern)=>normalizedPath === pattern || normalizedPath.startsWith(`${pattern}/`));
+};
 exports.buildLocalizedUrl = __webpack_exports__.buildLocalizedUrl;
 exports.detectLanguageFromPath = __webpack_exports__.detectLanguageFromPath;
 exports.getEntryPath = __webpack_exports__.getEntryPath;

package/dist/cjs/server/defaultUrlStrategy.js

@@ -0,0 +1,48 @@
+"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__, {
+    createDefaultUrlStrategy: ()=>createDefaultUrlStrategy,
+    resolveDefaultUrlStrategy: ()=>resolveDefaultUrlStrategy
+});
+const external_mappedUrlStrategy_js_namespaceObject = require("./mappedUrlStrategy.js");
+const createDefaultUrlStrategy = (localisedUrls)=>(0, external_mappedUrlStrategy_js_namespaceObject.createMappedUrlStrategy)(localisedUrls);
+const resolveDefaultUrlStrategy = (localisedUrls)=>{
+    if (!localisedUrls || 'object' != typeof localisedUrls || 0 === Object.keys(localisedUrls).length) return;
+    return createDefaultUrlStrategy(localisedUrls);
+};
+exports.createDefaultUrlStrategy = __webpack_exports__.createDefaultUrlStrategy;
+exports.resolveDefaultUrlStrategy = __webpack_exports__.resolveDefaultUrlStrategy;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createDefaultUrlStrategy",
+    "resolveDefaultUrlStrategy"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/server/index.js

@@ -33,10 +33,11 @@ __webpack_require__.d(__webpack_exports__, {
     i18nServerPlugin: ()=>i18nServerPlugin,
     matchesApiPrefix: ()=>external_apiPrefix_js_namespaceObject.matchesApiPrefix
 });
-const i18n_runtime_extensions_namespaceObject = require("@modern-js/i18n-runtime-extensions");
 const hono_namespaceObject = require("@modern-js/server-core/hono");
+const urlStrategy_js_namespaceObject = require("../shared/urlStrategy.js");
 const utils_js_namespaceObject = require("../shared/utils.js");
 const external_apiPrefix_js_namespaceObject = require("./apiPrefix.js");
+const external_defaultUrlStrategy_js_namespaceObject = require("./defaultUrlStrategy.js");
 const external_detectorOptions_js_namespaceObject = require("./detectorOptions.js");
 const external_redirectPolicy_js_namespaceObject = require("./redirectPolicy.js");
 const { languageDetector } = hono_namespaceObject;
@@ -59,7 +60,10 @@ const i18nServerPlugin = (options)=>({
                     const { entryName } = route;
                     if (!entryName) return;
                     if (!options.localeDetection) return;
-                    const { localePathRedirect, i18nextDetector = true, languages = [], fallbackLanguage = 'en', detection, ignoreRedirectRoutes, localisedUrls } = (0, utils_js_namespaceObject.getLocaleDetectionOptions)(entryName, options.localeDetection);
+                    const entryLocaleDetection = (0, utils_js_namespaceObject.getLocaleDetectionOptions)(entryName, options.localeDetection);
+                    const { localePathRedirect, i18nextDetector = true, languages = [], fallbackLanguage = 'en', detection, ignoreRedirectRoutes } = entryLocaleDetection;
+                    const legacyLocalisedUrls = Reflect.get(entryLocaleDetection, 'localisedUrls');
+                    const urlStrategy = (0, urlStrategy_js_namespaceObject.asI18nUrlStrategy)(options.resolveUrlStrategy?.(entryName)) ?? (0, external_defaultUrlStrategy_js_namespaceObject.resolveDefaultUrlStrategy)(legacyLocalisedUrls);
                     const staticRoutePrefixes = options.staticRoutePrefixes;
                     const originUrlPath = route.urlPath;
                     const urlPath = originUrlPath.endsWith('/') ? `${originUrlPath}*` : `${originUrlPath}/*`;
@@ -74,6 +78,7 @@ const i18nServerPlugin = (options)=>({
                                     const url = new URL(c.req.url);
                                     const pathname = url.pathname;
                                     if ((0, external_apiPrefix_js_namespaceObject.matchesApiPrefix)(pathname, apiPrefixes)) return await next();
+                                    if ((0, external_redirectPolicy_js_namespaceObject.shouldIgnoreRedirect)(pathname, urlPath, ignoreRedirectRoutes, urlStrategy, languages)) return await next();
                                     if ((0, external_redirectPolicy_js_namespaceObject.isStaticResourceRequest)(pathname, staticRoutePrefixes, languages)) return await next();
                                     if ('/' === originUrlPath) {
                                         const pathSegments = pathname.split('/').filter(Boolean);
@@ -94,7 +99,7 @@ const i18nServerPlugin = (options)=>({
                                 const pathname = url.pathname;
                                 if ((0, external_apiPrefix_js_namespaceObject.matchesApiPrefix)(pathname, apiPrefixes)) return await next();
                                 if ((0, external_redirectPolicy_js_namespaceObject.isStaticResourceRequest)(pathname, staticRoutePrefixes, languages)) return await next();
-                                if ((0, external_redirectPolicy_js_namespaceObject.shouldIgnoreRedirect)(pathname, urlPath, ignoreRedirectRoutes)) return await next();
+                                if ((0, external_redirectPolicy_js_namespaceObject.shouldIgnoreRedirect)(pathname, urlPath, ignoreRedirectRoutes, urlStrategy, languages)) return await next();
                                 if ('/' === originUrlPath) {
                                     const pathSegments = pathname.split('/').filter(Boolean);
                                     if (pathSegments.length > 0) {
@@ -107,12 +112,11 @@ const i18nServerPlugin = (options)=>({
                                     let detectedLanguage = null;
                                     if (i18nextDetector) detectedLanguage = c.get('language') || null;
                                     const targetLanguage = detectedLanguage || fallbackLanguage;
-                                    const localizedUrl = (0, external_redirectPolicy_js_namespaceObject.buildLocalizedUrl)(c.req, originUrlPath, targetLanguage, languages, localisedUrls);
+                                    const localizedUrl = (0, external_redirectPolicy_js_namespaceObject.buildLocalizedUrl)(c.req, originUrlPath, targetLanguage, languages, urlStrategy);
                                     return (0, external_redirectPolicy_js_namespaceObject.createLocaleRedirectResponse)(localizedUrl);
                                 }
-                                const localisedUrlsConfig = (0, i18n_runtime_extensions_namespaceObject.resolveLocalisedUrlsConfig)(localisedUrls);
-                                if (localisedUrlsConfig.enabled) {
-                                    const expectedUrl = (0, external_redirectPolicy_js_namespaceObject.buildLocalizedUrl)(c.req, originUrlPath, language, languages, localisedUrls);
+                                if (urlStrategy) {
+                                    const expectedUrl = (0, external_redirectPolicy_js_namespaceObject.buildLocalizedUrl)(c.req, originUrlPath, language, languages, urlStrategy);
                                     if (expectedUrl !== `${pathname}${url.search}${url.hash}`) return (0, external_redirectPolicy_js_namespaceObject.createLocaleRedirectResponse)(expectedUrl);
                                 }
                                 await next();

package/dist/cjs/server/mappedUrlStrategy.js

@@ -0,0 +1,43 @@
+"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__, {
+    createMappedUrlStrategy: ()=>mappedUrlStrategy_js_namespaceObject.createMappedUrlStrategy,
+    resolveMappedUrlStrategy: ()=>mappedUrlStrategy_js_namespaceObject.resolveMappedUrlStrategy
+});
+const mappedUrlStrategy_js_namespaceObject = require("../shared/mappedUrlStrategy.js");
+exports.createMappedUrlStrategy = __webpack_exports__.createMappedUrlStrategy;
+exports.resolveMappedUrlStrategy = __webpack_exports__.resolveMappedUrlStrategy;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createMappedUrlStrategy",
+    "resolveMappedUrlStrategy"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/server/redirectPolicy.js

@@ -34,42 +34,51 @@ __webpack_require__.d(__webpack_exports__, {
     isStaticResourceRequest: ()=>isStaticResourceRequest,
     shouldIgnoreRedirect: ()=>shouldIgnoreRedirect
 });
-const i18n_runtime_extensions_namespaceObject = require("@modern-js/i18n-runtime-extensions");
+const mappedUrlStrategy_js_namespaceObject = require("../shared/mappedUrlStrategy.js");
+const urlStrategy_js_namespaceObject = require("../shared/urlStrategy.js");
 const stripUrlPathPrefix = (pathname, urlPath)=>{
     const basePath = urlPath.replace('/*', '');
     if (!basePath || '/' === basePath) return pathname;
-    const remainingPath = pathname.startsWith(basePath) ? pathname.slice(basePath.length) : pathname;
-    return remainingPath || '/';
+    return pathname === basePath || pathname.startsWith(`${basePath}/`) ? pathname.slice(basePath.length) || '/' : pathname;
 };
-const shouldIgnoreRedirect = (pathname, urlPath, ignoreRedirectRoutes)=>{
+const shouldIgnoreRedirect = (pathname, urlPath, ignoreRedirectRoutes, urlStrategy, languages = [])=>{
     const remainingPath = stripUrlPathPrefix(pathname, urlPath);
-    return (0, i18n_runtime_extensions_namespaceObject.shouldSkipLocaleRedirect)(remainingPath, [], ignoreRedirectRoutes);
+    if ((0, mappedUrlStrategy_js_namespaceObject.isDefaultLocaleRedirectSkipPath)(remainingPath, languages)) return true;
+    if ((0, urlStrategy_js_namespaceObject.asI18nUrlStrategy)(urlStrategy)?.shouldSkipRedirect?.(remainingPath, languages)) return true;
+    if (!ignoreRedirectRoutes) return false;
+    const segments = remainingPath.split('/').filter(Boolean);
+    if (segments[0] && languages.some((language)=>language.toLowerCase() === segments[0].toLowerCase())) segments.shift();
+    const normalizedPath = `/${segments.join('/')}`;
+    return 'function' == typeof ignoreRedirectRoutes ? ignoreRedirectRoutes(normalizedPath) : ignoreRedirectRoutes.some((pattern)=>normalizedPath === pattern || normalizedPath.startsWith(`${pattern}/`));
 };
 const isStaticResourceRequest = (pathname, staticRoutePrefixes, languages = [])=>{
-    if ((0, i18n_runtime_extensions_namespaceObject.isDefaultLocaleRedirectSkipPath)(pathname, languages)) return true;
-    const matchesStaticRoutePrefix = (targetPathname)=>staticRoutePrefixes.some((prefix)=>(0, i18n_runtime_extensions_namespaceObject.matchesPathPrefix)(targetPathname, prefix));
-    if (matchesStaticRoutePrefix(pathname)) return true;
-    const pathWithoutLanguage = (0, i18n_runtime_extensions_namespaceObject.stripLanguagePrefix)(pathname, languages);
-    return pathWithoutLanguage !== pathname && matchesStaticRoutePrefix(pathWithoutLanguage);
+    const prefixes = [
+        ...staticRoutePrefixes,
+        '/static',
+        '/upload'
+    ];
+    const matches = (target)=>prefixes.some((prefix)=>target === prefix || target.startsWith(`${prefix}/`));
+    if (matches(pathname)) return true;
+    const segments = pathname.split('/').filter(Boolean);
+    if (segments[0] && languages.some((language)=>language.toLowerCase() === segments[0].toLowerCase())) return matches(`/${segments.slice(1).join('/')}`);
+    return false;
 };
 const getLanguageFromPath = (req, urlPath, languages)=>{
-    const url = new URL(req.url, `http://${req.header().host}`);
-    const pathname = url.pathname;
-    const remainingPath = stripUrlPathPrefix(pathname, urlPath);
-    const segments = remainingPath.split('/').filter(Boolean);
-    const firstSegment = segments[0];
-    if (languages.includes(firstSegment)) return firstSegment;
-    return null;
+    const host = req.header?.().host;
+    const url = new URL(req.url, host ? `http://${host}` : void 0);
+    const firstSegment = stripUrlPathPrefix(url.pathname, urlPath).split('/').filter(Boolean)[0];
+    return languages.find((language)=>language.toLowerCase() === firstSegment?.toLowerCase()) ?? null;
 };
-const buildLocalizedUrl = (req, urlPath, language, languages, localisedUrls)=>{
+const buildLocalizedUrl = (req, urlPath, language, languages, urlStrategy)=>{
     const url = new URL(req.url);
-    const pathname = url.pathname;
     const basePath = urlPath.replace('/*', '');
-    const remainingPath = stripUrlPathPrefix(pathname, urlPath);
-    const newPathname = (0, i18n_runtime_extensions_namespaceObject.localiseTargetPathname)(remainingPath, language, languages, localisedUrls);
-    const suffix = `${url.search}${url.hash}`;
-    const localizedUrl = '/' === basePath ? newPathname + suffix : basePath + newPathname + suffix;
-    return localizedUrl;
+    const remainingPath = stripUrlPathPrefix(url.pathname, urlPath);
+    const segments = remainingPath.split('/').filter(Boolean);
+    if (segments[0] && languages.some((item)=>item.toLowerCase() === segments[0].toLowerCase())) segments[0] = language;
+    else segments.unshift(language);
+    const strategy = (0, urlStrategy_js_namespaceObject.asI18nUrlStrategy)(urlStrategy);
+    const pathname = strategy ? strategy.localizePathname(remainingPath, language, languages) : `/${segments.join('/')}`;
+    return `${'/' === basePath ? '' : basePath}${pathname}${url.search}${url.hash}`;
 };
 const createLocaleRedirectResponse = (location)=>new Response(null, {
         status: 302,

package/dist/cjs/shared/mappedUrlStrategy.js

@@ -0,0 +1,63 @@
+"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__, {
+    createMappedUrlStrategy: ()=>createMappedUrlStrategy,
+    isDefaultLocaleRedirectSkipPath: ()=>i18n_runtime_extensions_namespaceObject.isDefaultLocaleRedirectSkipPath,
+    resolveMappedUrlStrategy: ()=>resolveMappedUrlStrategy
+});
+const i18n_runtime_extensions_namespaceObject = require("@modern-js/i18n-runtime-extensions");
+const createMappedUrlStrategy = (localisedUrls)=>({
+        localizePathname: (pathname, language, languages)=>(0, i18n_runtime_extensions_namespaceObject.localiseTargetPathname)(pathname, language, [
+                ...languages
+            ], localisedUrls),
+        canonicalPathname: (pathname, languages)=>(0, i18n_runtime_extensions_namespaceObject.canonicalTargetPathname)(pathname, [
+                ...languages
+            ], localisedUrls),
+        shouldSkipRedirect: (pathname, languages)=>(0, i18n_runtime_extensions_namespaceObject.isDefaultLocaleRedirectSkipPath)(pathname, [
+                ...languages
+            ])
+    });
+const resolveMappedUrlStrategy = (localeDetection)=>{
+    if (!localeDetection || 'object' != typeof localeDetection) return;
+    const localisedUrls = Reflect.get(localeDetection, 'localisedUrls');
+    if (!localisedUrls || 'object' != typeof localisedUrls || 0 === Object.keys(localisedUrls).length) return;
+    return createMappedUrlStrategy(localisedUrls);
+};
+exports.createMappedUrlStrategy = __webpack_exports__.createMappedUrlStrategy;
+exports.isDefaultLocaleRedirectSkipPath = __webpack_exports__.isDefaultLocaleRedirectSkipPath;
+exports.resolveMappedUrlStrategy = __webpack_exports__.resolveMappedUrlStrategy;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createMappedUrlStrategy",
+    "isDefaultLocaleRedirectSkipPath",
+    "resolveMappedUrlStrategy"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});