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

package/dist/cjs/shared/detection.js

@@ -1,7 +1,123 @@
 "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__ = {};
-require("../runtime/i18n/detection/config.js");
-for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    detectLanguageFromRequest: ()=>detectLanguageFromRequest
+});
+const config_js_namespaceObject = require("../runtime/i18n/detection/config.js");
+function detectLanguageFromRequest(req, languages, detectionOptions) {
+    try {
+        const mergedDetection = detectionOptions ? (0, config_js_namespaceObject.mergeDetectionOptions)(detectionOptions) : config_js_namespaceObject.DEFAULT_I18NEXT_DETECTION_OPTIONS;
+        const order = (mergedDetection.order || []).filter((item)=>![
+                'path',
+                'localStorage',
+                'navigator',
+                'htmlTag',
+                'subdomain'
+            ].includes(item));
+        const detectionOrder = order.length > 0 ? order : [
+            'querystring',
+            'cookie',
+            'header'
+        ];
+        const getHeader = (name)=>{
+            const headers = req.headers;
+            if ('function' == typeof headers?.get) return headers.get(name);
+            const value = headers[name.toLowerCase()];
+            if (Array.isArray(value)) return value[0] ?? null;
+            return value ?? null;
+        };
+        for (const method of detectionOrder){
+            let detectedLang = null;
+            switch(method){
+                case 'querystring':
+                    {
+                        const lookupKey = mergedDetection.lookupQuerystring || config_js_namespaceObject.DEFAULT_I18NEXT_DETECTION_OPTIONS.lookupQuerystring || 'lng';
+                        const host = getHeader('host') || 'localhost';
+                        const url = new URL(req.url, `http://${host}`);
+                        detectedLang = url.searchParams.get(lookupKey);
+                        break;
+                    }
+                case 'cookie':
+                    {
+                        const lookupKey = mergedDetection.lookupCookie || config_js_namespaceObject.DEFAULT_I18NEXT_DETECTION_OPTIONS.lookupCookie || 'i18next';
+                        const cookieHeader = getHeader('Cookie');
+                        if (cookieHeader) {
+                            const cookies = cookieHeader.split(';').reduce((acc, item)=>{
+                                const [key, value] = item.trim().split('=');
+                                if (key && value) acc[key] = value;
+                                return acc;
+                            }, {});
+                            detectedLang = cookies[lookupKey] || null;
+                        }
+                        break;
+                    }
+                case 'header':
+                    {
+                        const lookupKey = mergedDetection.lookupHeader || config_js_namespaceObject.DEFAULT_I18NEXT_DETECTION_OPTIONS.lookupHeader || 'accept-language';
+                        const acceptLanguage = getHeader(lookupKey);
+                        if (acceptLanguage) {
+                            const languagesList = acceptLanguage.split(',').map((lang)=>{
+                                const [code, q] = lang.trim().split(';');
+                                return {
+                                    code,
+                                    baseCode: code.split('-')[0],
+                                    quality: q ? parseFloat(q.split('=')[1]) : 1.0
+                                };
+                            }).sort((a, b)=>b.quality - a.quality);
+                            for (const lang of languagesList){
+                                if (0 === languages.length || languages.includes(lang.code)) {
+                                    detectedLang = lang.code;
+                                    break;
+                                }
+                                if (languages.includes(lang.baseCode)) {
+                                    detectedLang = lang.baseCode;
+                                    break;
+                                }
+                            }
+                        }
+                        break;
+                    }
+            }
+            if (detectedLang && (0 === languages.length || languages.includes(detectedLang))) return detectedLang;
+            if (detectedLang) {
+                const baseLang = detectedLang.split('-')[0];
+                if (languages.includes(baseLang)) return baseLang;
+            }
+        }
+    } catch (error) {}
+    return null;
+}
+exports.detectLanguageFromRequest = __webpack_exports__.detectLanguageFromRequest;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "detectLanguageFromRequest"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true
 });

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

package/dist/cjs/shared/urlStrategy.js

@@ -1,5 +1,20 @@
 "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, {
@@ -12,7 +27,22 @@ var __webpack_require__ = {};
 })();
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
-for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+const asI18nUrlStrategy = (candidate)=>{
+    if (!candidate || 'object' != typeof candidate) return;
+    const strategy = candidate;
+    return 'function' == typeof strategy.localizePathname && 'function' == typeof strategy.canonicalPathname ? strategy : void 0;
+};
+const isUnusableI18nUrlStrategy = (candidate)=>Boolean(candidate) && 'object' == typeof candidate && void 0 === asI18nUrlStrategy(candidate);
+__webpack_require__.d(__webpack_exports__, {}, {
+    asI18nUrlStrategy: asI18nUrlStrategy,
+    isUnusableI18nUrlStrategy: isUnusableI18nUrlStrategy
+});
+exports.asI18nUrlStrategy = __webpack_exports__.asI18nUrlStrategy;
+exports.isUnusableI18nUrlStrategy = __webpack_exports__.isUnusableI18nUrlStrategy;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "asI18nUrlStrategy",
+    "isUnusableI18nUrlStrategy"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true
 });

package/dist/esm/cli/index.mjs

@@ -1,6 +1,9 @@
 import { getPublicDirRoutePrefixes } from "@modern-js/server-core";
+import { logger } from "@modern-js/utils";
+import { isUnusableI18nUrlStrategy } from "../shared/urlStrategy.mjs";
 import { getBackendOptions, getLocaleDetectionOptions } from "../shared/utils.mjs";
 import { applyDetectedBackendPaths, detectLocalesDirectory } from "./locales.mjs";
+import { applyLocalisedRoutes } from "./localisedRoutes.mjs";
 import "../runtime/types.mjs";
 const i18nPlugin = (options = {})=>({
         name: '@modern-js/plugin-i18n',
@@ -30,6 +33,10 @@ const i18nPlugin = (options = {})=>({
                     backend: backendOptions,
                     ...extendedConfig
                 };
+                if (isUnusableI18nUrlStrategy(config.urlStrategy)) {
+                    delete config.urlStrategy;
+                    logger.warn("[i18n] `urlStrategy` cannot be passed through `modern.config.ts`: the generated runtime registration carries plugin options as JSON, which drops its methods. Configure `localeDetection.localisedUrls` instead — the runtime and the server both derive the URL policy from it — or register a runtime plugin that supplies the strategy directly.");
+                }
                 const { reactI18next } = extendedConfig;
                 const runtimePluginPath = customPlugin?.runtime?.path || (false === reactI18next ? `@${metaName}/plugin-i18n/runtime/no-react-i18next` : `@${metaName}/plugin-i18n/runtime`);
                 plugins.push({
@@ -42,6 +49,10 @@ const i18nPlugin = (options = {})=>({
                     plugins
                 };
             });
+            api.modifyFileSystemRoutes(({ entrypoint, routes })=>({
+                    entrypoint,
+                    routes: applyLocalisedRoutes(routes, localeDetection ? getLocaleDetectionOptions(entrypoint.entryName, localeDetection) : void 0, entrypoint)
+                }));
             api._internalServerPlugins(({ plugins })=>{
                 const { serverRoutes, metaName } = api.getAppContext();
                 const normalizedConfig = api.getNormalizedConfig();

package/dist/esm/cli/localisedRoutes.mjs

@@ -0,0 +1,9 @@
+import { applyLocalisedUrlsToRoutes, resolveLocalisedUrlsConfig } from "@modern-js/i18n-runtime-extensions";
+import { getEntrypointRoutesOwner } from "@modern-js/runtime/cli";
+const applyLocalisedRoutes = (routes, localeDetection, entrypoint)=>{
+    const { localePathRedirect, languages = [], localisedUrls } = localeDetection ?? {};
+    const resolved = resolveLocalisedUrlsConfig(localisedUrls);
+    if (!localePathRedirect || !languages.length || !resolved.enabled) return routes;
+    return applyLocalisedUrlsToRoutes(routes, languages, resolved.map, entrypoint && '@modern-js/plugin-tanstack' === getEntrypointRoutesOwner(entrypoint) ? 'canonical' : 'physical');
+};
+export { applyLocalisedRoutes };

package/dist/esm/runtime/context.mjs

@@ -1,17 +1,9 @@
 import { jsx } from "react/jsx-runtime";
 import { RuntimeComponentResolverContext } from "@modern-js/runtime/context";
-import { createContext, useCallback, useContext, useEffect, useMemo } from "react";
+import { useCallback, useContext, useEffect, useMemo } from "react";
 import { changeModernI18nLanguage, getPathLanguage, isI18nLanguageSupported, isI18nResourcesReady, translateI18n } from "./contextHelpers.mjs";
 import { useI18nRouterAdapter } from "./routerAdapter.mjs";
-const modernI18nContextKey = Symbol.for('@modern-js/plugin-i18n/runtime/ModernI18nContext');
-const reactI18nextProviderContextKey = Symbol.for('@modern-js/plugin-i18n/runtime/ReactI18nextProviderContext');
-const getGlobalContext = (key, defaultValue)=>{
-    const globalStore = globalThis;
-    globalStore[key] ??= /*#__PURE__*/ createContext(defaultValue);
-    return globalStore[key];
-};
-const ModernI18nContext = getGlobalContext(modernI18nContextKey, null);
-const ReactI18nextProviderContext = getGlobalContext(reactI18nextProviderContextKey, null);
+import { ModernI18nContext, ReactI18nextProviderContext } from "./sharedContexts.mjs";
 const ModernI18nProvider = ({ children, i18nextProvider, value })=>{
     const content = /*#__PURE__*/ jsx(ModernI18nContext.Provider, {
         value: value,

package/dist/esm/runtime/contexts.mjs

@@ -0,0 +1,5 @@
+import { createContext } from "react";
+const ModernI18nContext = createContext(null);
+const ReactI18nextProviderContext = createContext(null);
+const I18nNavigationContext = createContext(null);
+export { I18nNavigationContext, ModernI18nContext, ReactI18nextProviderContext };

package/dist/esm/runtime/core.mjs

@@ -1,3 +1,6 @@
+import { resolveMappedUrlStrategy } from "../shared/mappedUrlStrategy.mjs";
+import { asI18nUrlStrategy } from "../shared/urlStrategy.mjs";
+import { I18nRouterNavigationProvider, useIntegratedRouterAdapter } from "./navigation.mjs";
 import { setupI18nBeforeRender } from "./pluginSetup.mjs";
 import { createI18nRootWrapper } from "./providerComposition.mjs";
 import { resolveReactI18nextIntegration } from "./reactI18next.mjs";
@@ -8,6 +11,7 @@ const createI18nPlugin = (loadReactI18nextIntegration)=>(options)=>({
                 const { entryName, i18nInstance: userI18nInstance, initOptions, localeDetection, backend, htmlLangAttr = false, reactI18next = true, urlStrategy, NavigationProvider, LanguageSynchronization } = options;
                 const { localePathRedirect = false, i18nextDetector = true, languages = [], fallbackLanguage = 'en', detection, ignoreRedirectRoutes } = localeDetection || {};
                 const { enabled: backendEnabled = false } = backend || {};
+                const resolvedUrlStrategy = asI18nUrlStrategy(urlStrategy) ?? resolveMappedUrlStrategy(localeDetection);
                 let latestI18nInstance;
                 let I18nextProvider;
                 api.onBeforeRender(async (context)=>{
@@ -35,8 +39,8 @@ const createI18nPlugin = (loadReactI18nextIntegration)=>(options)=>({
                     languages,
                     fallbackLanguage,
                     ignoreRedirectRoutes,
-                    urlStrategy,
-                    NavigationProvider,
+                    urlStrategy: resolvedUrlStrategy,
+                    NavigationProvider: NavigationProvider ?? I18nRouterNavigationProvider,
                     LanguageSynchronization,
                     getLatestI18nInstance: ()=>latestI18nInstance,
                     getI18nextProvider: ()=>I18nextProvider
@@ -49,4 +53,4 @@ export { I18nLink } from "./I18nLink.mjs";
 export { Link } from "./Link.mjs";
 export { useLocalizedLocation, useLocalizedPaths } from "./localizedPaths.mjs";
 export { splitUrlTarget } from "./utils.mjs";
-export { createI18nPlugin };
+export { I18nRouterNavigationProvider, createI18nPlugin, useIntegratedRouterAdapter };

package/dist/esm/runtime/i18n/detection/middleware.mjs

@@ -11,7 +11,7 @@ const useI18nextLanguageDetector = (i18nInstance)=>{
     }
     return i18nInstance;
 };
-const readLanguageFromStorage = (detectionOptions)=>{
+const readLanguageFromStorage = (detectionOptions, _request, _languages)=>{
     try {
         const options = detectionOptions || {};
         const order = options.order || [

package/dist/esm/runtime/i18n/detection/middleware.node.mjs

@@ -1,6 +1,15 @@
 import { LanguageDetector } from "i18next-http-middleware";
+import { detectLanguageFromRequest } from "../../../shared/detection.mjs";
+const isDetectionRequest = (request)=>{
+    if (!request || 'object' != typeof request) return false;
+    const { url, headers } = request;
+    return 'string' == typeof url && !!headers && 'object' == typeof headers;
+};
 const cacheUserLanguage = (_i18nInstance, _language, _detectionOptions)=>{};
-const readLanguageFromStorage = (_detectionOptions)=>{};
+const readLanguageFromStorage = (detectionOptions, request, languages = [])=>{
+    if (!isDetectionRequest(request)) return;
+    return detectLanguageFromRequest(request, languages, detectionOptions) ?? void 0;
+};
 const useI18nextLanguageDetector = (i18nInstance)=>{
     if (!i18nInstance.isInitialized) return i18nInstance.use(LanguageDetector);
     return i18nInstance;

package/dist/esm/runtime/i18n/detection/priority.mjs

@@ -9,7 +9,7 @@ const detectLanguageWithPriority = async (i18nInstance, options)=>{
     let detectedLanguage;
     detectedLanguage = detectLanguageFromPathPriority(pathname, languages, localePathRedirect);
     if (!detectedLanguage) detectedLanguage = detectLanguageFromSSR(languages);
-    if (!detectedLanguage && i18nextDetector) detectedLanguage = isI18nWrapperInstance(i18nInstance) ? readLanguageFromStorage(mergeDetectionOptions(i18nextDetector, detection, localePathRedirect, userInitOptions)) : await detectLanguageFromI18nextDetector(i18nInstance, {
+    if (!detectedLanguage && i18nextDetector) detectedLanguage = isI18nWrapperInstance(i18nInstance) ? readLanguageFromStorage(mergeDetectionOptions(i18nextDetector, detection, localePathRedirect, userInitOptions), ssrContext?.request, languages) : await detectLanguageFromI18nextDetector(i18nInstance, {
         languages,
         fallbackLanguage,
         localePathRedirect,

package/dist/esm/runtime/navigation.mjs

@@ -0,0 +1,7 @@
+import { createI18nRouterNavigation } from "@modern-js/i18n-runtime-extensions/router-navigation";
+import { I18nNavigationProvider, useNativeI18nRouterAdapter } from "./routerAdapter.mjs";
+const { I18nRouterNavigationProvider: I18nRouterNavigationProvider, useIntegratedRouterAdapter: useIntegratedRouterAdapter } = createI18nRouterNavigation({
+    I18nNavigationProvider: I18nNavigationProvider,
+    useNativeI18nRouterAdapter: useNativeI18nRouterAdapter
+});
+export { I18nRouterNavigationProvider, useIntegratedRouterAdapter };

package/dist/esm/runtime/routerAdapter.mjs

@@ -1,10 +1,8 @@
 import { jsx } from "react/jsx-runtime";
+import { I18nNavigationContext } from "@modern-js/plugin-i18n/runtime/contexts";
 import { RuntimeContext, isBrowser } from "@modern-js/runtime";
 import { InternalRuntimeContext } from "@modern-js/runtime/context";
-import { createContext, useContext } from "react";
-const navigationContextKey = Symbol.for('@modern-js/plugin-i18n/runtime/I18nNavigationContext');
-const contextStore = globalThis;
-const I18nNavigationContext = contextStore[navigationContextKey] ??= /*#__PURE__*/ createContext(null);
+import { useContext } from "react";
 const I18nNavigationProvider = ({ children, value })=>/*#__PURE__*/ jsx(I18nNavigationContext.Provider, {
         value: value,
         children: children

package/dist/esm/runtime/sharedContexts.mjs

@@ -0,0 +1 @@
+export { ModernI18nContext, ReactI18nextProviderContext } from "@modern-js/plugin-i18n/runtime/contexts";

package/dist/esm/runtime/utils.mjs

@@ -1,6 +1,8 @@
 import { isBrowser } from "@modern-js/runtime";
 import { getGlobalBasename } from "@modern-js/runtime/context";
 import { splitUrlTarget } from "@modern-js/runtime-utils/url";
+import { isDefaultLocaleRedirectSkipPath } from "../shared/mappedUrlStrategy.mjs";
+import { asI18nUrlStrategy } from "../shared/urlStrategy.mjs";
 const getPathname = (context)=>{
     if (isBrowser()) return window.location.pathname;
     return context.ssrContext?.request?.pathname || '/';
@@ -18,7 +20,8 @@ const getLanguageFromPath = (pathname, languages, fallbackLanguage)=>{
 };
 const buildLocalizedUrl = (target, language, languages, urlStrategy)=>{
     const { pathname, search, hash } = splitUrlTarget(target);
-    if (urlStrategy) return `${urlStrategy.localizePathname(pathname, language, languages)}${search}${hash}`;
+    const strategy = 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);
@@ -43,7 +46,8 @@ const detectLanguageFromPath = (pathname, languages, localePathRedirect)=>{
     };
 };
 const shouldIgnoreRedirect = (pathname, languages, ignoreRedirectRoutes, urlStrategy)=>{
-    if (urlStrategy?.shouldSkipRedirect?.(pathname, languages)) return true;
+    if (isDefaultLocaleRedirectSkipPath(pathname, languages)) return true;
+    if (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();

package/dist/esm/server/defaultUrlStrategy.mjs

@@ -0,0 +1,7 @@
+import { createMappedUrlStrategy } from "./mappedUrlStrategy.mjs";
+const createDefaultUrlStrategy = (localisedUrls)=>createMappedUrlStrategy(localisedUrls);
+const resolveDefaultUrlStrategy = (localisedUrls)=>{
+    if (!localisedUrls || 'object' != typeof localisedUrls || 0 === Object.keys(localisedUrls).length) return;
+    return createDefaultUrlStrategy(localisedUrls);
+};
+export { createDefaultUrlStrategy, resolveDefaultUrlStrategy };

package/dist/esm/server/index.mjs

@@ -1,5 +1,7 @@
+import { asI18nUrlStrategy } from "../shared/urlStrategy.mjs";
 import { getLocaleDetectionOptions } from "../shared/utils.mjs";
 import { collectApiPrefixes, matchesApiPrefix } from "./apiPrefix.mjs";
+import { resolveDefaultUrlStrategy } from "./defaultUrlStrategy.mjs";
 import { convertToHonoLanguageDetectorOptions } from "./detectorOptions.mjs";
 import { buildLocalizedUrl, createLocaleRedirectResponse, getLanguageFromPath, isStaticResourceRequest, shouldIgnoreRedirect } from "./redirectPolicy.mjs";
 import * as __rspack_external__modern_js_server_core_hono_0af3baa7 from "@modern-js/server-core/hono";
@@ -26,8 +28,7 @@ const i18nServerPlugin = (options)=>({
                     const entryLocaleDetection = getLocaleDetectionOptions(entryName, options.localeDetection);
                     const { localePathRedirect, i18nextDetector = true, languages = [], fallbackLanguage = 'en', detection, ignoreRedirectRoutes } = entryLocaleDetection;
                     const legacyLocalisedUrls = Reflect.get(entryLocaleDetection, 'localisedUrls');
-                    const urlStrategy = options.resolveUrlStrategy?.(entryName);
-                    if (legacyLocalisedUrls && 'object' == typeof legacyLocalisedUrls && Object.keys(legacyLocalisedUrls).length > 0 && !urlStrategy) throw new Error('Mapped locale URLs require a URL strategy. Use the i18n integration server plugin or supply resolveUrlStrategy.');
+                    const urlStrategy = asI18nUrlStrategy(options.resolveUrlStrategy?.(entryName)) ?? resolveDefaultUrlStrategy(legacyLocalisedUrls);
                     const staticRoutePrefixes = options.staticRoutePrefixes;
                     const originUrlPath = route.urlPath;
                     const urlPath = originUrlPath.endsWith('/') ? `${originUrlPath}*` : `${originUrlPath}/*`;

package/dist/esm/server/mappedUrlStrategy.mjs

@@ -0,0 +1 @@
+export { createMappedUrlStrategy, resolveMappedUrlStrategy } from "../shared/mappedUrlStrategy.mjs";

package/dist/esm/server/redirectPolicy.mjs

@@ -1,3 +1,5 @@
+import { isDefaultLocaleRedirectSkipPath } from "../shared/mappedUrlStrategy.mjs";
+import { asI18nUrlStrategy } from "../shared/urlStrategy.mjs";
 const stripUrlPathPrefix = (pathname, urlPath)=>{
     const basePath = urlPath.replace('/*', '');
     if (!basePath || '/' === basePath) return pathname;
@@ -5,7 +7,8 @@ const stripUrlPathPrefix = (pathname, urlPath)=>{
 };
 const shouldIgnoreRedirect = (pathname, urlPath, ignoreRedirectRoutes, urlStrategy, languages = [])=>{
     const remainingPath = stripUrlPathPrefix(pathname, urlPath);
-    if (urlStrategy?.shouldSkipRedirect?.(remainingPath, languages)) return true;
+    if (isDefaultLocaleRedirectSkipPath(remainingPath, languages)) return true;
+    if (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();
@@ -37,7 +40,8 @@ const buildLocalizedUrl = (req, urlPath, language, languages, urlStrategy)=>{
     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 pathname = urlStrategy ? urlStrategy.localizePathname(remainingPath, language, languages) : `/${segments.join('/')}`;
+    const strategy = 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, {

package/dist/esm/shared/detection.mjs

@@ -1 +1,85 @@
-import "../runtime/i18n/detection/config.mjs";
+import { DEFAULT_I18NEXT_DETECTION_OPTIONS, mergeDetectionOptions } from "../runtime/i18n/detection/config.mjs";
+function detectLanguageFromRequest(req, languages, detectionOptions) {
+    try {
+        const mergedDetection = detectionOptions ? mergeDetectionOptions(detectionOptions) : DEFAULT_I18NEXT_DETECTION_OPTIONS;
+        const order = (mergedDetection.order || []).filter((item)=>![
+                'path',
+                'localStorage',
+                'navigator',
+                'htmlTag',
+                'subdomain'
+            ].includes(item));
+        const detectionOrder = order.length > 0 ? order : [
+            'querystring',
+            'cookie',
+            'header'
+        ];
+        const getHeader = (name)=>{
+            const headers = req.headers;
+            if ('function' == typeof headers?.get) return headers.get(name);
+            const value = headers[name.toLowerCase()];
+            if (Array.isArray(value)) return value[0] ?? null;
+            return value ?? null;
+        };
+        for (const method of detectionOrder){
+            let detectedLang = null;
+            switch(method){
+                case 'querystring':
+                    {
+                        const lookupKey = mergedDetection.lookupQuerystring || DEFAULT_I18NEXT_DETECTION_OPTIONS.lookupQuerystring || 'lng';
+                        const host = getHeader('host') || 'localhost';
+                        const url = new URL(req.url, `http://${host}`);
+                        detectedLang = url.searchParams.get(lookupKey);
+                        break;
+                    }
+                case 'cookie':
+                    {
+                        const lookupKey = mergedDetection.lookupCookie || DEFAULT_I18NEXT_DETECTION_OPTIONS.lookupCookie || 'i18next';
+                        const cookieHeader = getHeader('Cookie');
+                        if (cookieHeader) {
+                            const cookies = cookieHeader.split(';').reduce((acc, item)=>{
+                                const [key, value] = item.trim().split('=');
+                                if (key && value) acc[key] = value;
+                                return acc;
+                            }, {});
+                            detectedLang = cookies[lookupKey] || null;
+                        }
+                        break;
+                    }
+                case 'header':
+                    {
+                        const lookupKey = mergedDetection.lookupHeader || DEFAULT_I18NEXT_DETECTION_OPTIONS.lookupHeader || 'accept-language';
+                        const acceptLanguage = getHeader(lookupKey);
+                        if (acceptLanguage) {
+                            const languagesList = acceptLanguage.split(',').map((lang)=>{
+                                const [code, q] = lang.trim().split(';');
+                                return {
+                                    code,
+                                    baseCode: code.split('-')[0],
+                                    quality: q ? parseFloat(q.split('=')[1]) : 1.0
+                                };
+                            }).sort((a, b)=>b.quality - a.quality);
+                            for (const lang of languagesList){
+                                if (0 === languages.length || languages.includes(lang.code)) {
+                                    detectedLang = lang.code;
+                                    break;
+                                }
+                                if (languages.includes(lang.baseCode)) {
+                                    detectedLang = lang.baseCode;
+                                    break;
+                                }
+                            }
+                        }
+                        break;
+                    }
+            }
+            if (detectedLang && (0 === languages.length || languages.includes(detectedLang))) return detectedLang;
+            if (detectedLang) {
+                const baseLang = detectedLang.split('-')[0];
+                if (languages.includes(baseLang)) return baseLang;
+            }
+        }
+    } catch (error) {}
+    return null;
+}
+export { detectLanguageFromRequest };

package/dist/esm/shared/mappedUrlStrategy.mjs

@@ -0,0 +1,19 @@
+import { canonicalTargetPathname, isDefaultLocaleRedirectSkipPath, localiseTargetPathname } from "@modern-js/i18n-runtime-extensions";
+const createMappedUrlStrategy = (localisedUrls)=>({
+        localizePathname: (pathname, language, languages)=>localiseTargetPathname(pathname, language, [
+                ...languages
+            ], localisedUrls),
+        canonicalPathname: (pathname, languages)=>canonicalTargetPathname(pathname, [
+                ...languages
+            ], localisedUrls),
+        shouldSkipRedirect: (pathname, languages)=>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);
+};
+export { createMappedUrlStrategy, isDefaultLocaleRedirectSkipPath, resolveMappedUrlStrategy };

package/dist/esm/shared/urlStrategy.mjs

@@ -0,0 +1,7 @@
+const asI18nUrlStrategy = (candidate)=>{
+    if (!candidate || 'object' != typeof candidate) return;
+    const strategy = candidate;
+    return 'function' == typeof strategy.localizePathname && 'function' == typeof strategy.canonicalPathname ? strategy : void 0;
+};
+const isUnusableI18nUrlStrategy = (candidate)=>Boolean(candidate) && 'object' == typeof candidate && void 0 === asI18nUrlStrategy(candidate);
+export { asI18nUrlStrategy, isUnusableI18nUrlStrategy };

package/dist/esm-node/cli/index.mjs

@@ -1,7 +1,10 @@
 import "node:module";
 import { getPublicDirRoutePrefixes } from "@modern-js/server-core";
+import { logger } from "@modern-js/utils";
+import { isUnusableI18nUrlStrategy } from "../shared/urlStrategy.mjs";
 import { getBackendOptions, getLocaleDetectionOptions } from "../shared/utils.mjs";
 import { applyDetectedBackendPaths, detectLocalesDirectory } from "./locales.mjs";
+import { applyLocalisedRoutes } from "./localisedRoutes.mjs";
 import "../runtime/types.mjs";
 const i18nPlugin = (options = {})=>({
         name: '@modern-js/plugin-i18n',
@@ -31,6 +34,10 @@ const i18nPlugin = (options = {})=>({
                     backend: backendOptions,
                     ...extendedConfig
                 };
+                if (isUnusableI18nUrlStrategy(config.urlStrategy)) {
+                    delete config.urlStrategy;
+                    logger.warn("[i18n] `urlStrategy` cannot be passed through `modern.config.ts`: the generated runtime registration carries plugin options as JSON, which drops its methods. Configure `localeDetection.localisedUrls` instead — the runtime and the server both derive the URL policy from it — or register a runtime plugin that supplies the strategy directly.");
+                }
                 const { reactI18next } = extendedConfig;
                 const runtimePluginPath = customPlugin?.runtime?.path || (false === reactI18next ? `@${metaName}/plugin-i18n/runtime/no-react-i18next` : `@${metaName}/plugin-i18n/runtime`);
                 plugins.push({
@@ -43,6 +50,10 @@ const i18nPlugin = (options = {})=>({
                     plugins
                 };
             });
+            api.modifyFileSystemRoutes(({ entrypoint, routes })=>({
+                    entrypoint,
+                    routes: applyLocalisedRoutes(routes, localeDetection ? getLocaleDetectionOptions(entrypoint.entryName, localeDetection) : void 0, entrypoint)
+                }));
             api._internalServerPlugins(({ plugins })=>{
                 const { serverRoutes, metaName } = api.getAppContext();
                 const normalizedConfig = api.getNormalizedConfig();