@bleedingdev/modern-js-plugin-i18n 3.9.0-ultramodern.2 → 3.9.0-ultramodern.20

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

package/dist/cjs/shared/urlStrategy.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__);
+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,7 +1,9 @@
-import { applyLocalisedUrlsToRoutes, resolveLocalisedUrlsConfig } from "@modern-js/i18n-runtime-extensions";
 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 +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({
@@ -43,27 +49,10 @@ const i18nPlugin = (options = {})=>({
                     plugins
                 };
             });
-            api.modifyFileSystemRoutes(({ entrypoint, routes })=>{
-                if (!localeDetection) return {
+            api.modifyFileSystemRoutes(({ entrypoint, routes })=>({
                     entrypoint,
-                    routes
-                };
-                const localeDetectionOptions = getLocaleDetectionOptions(entrypoint.entryName, localeDetection);
-                const { localePathRedirect, languages = [], localisedUrls } = localeDetectionOptions;
-                if (!localePathRedirect || 0 === languages.length) return {
-                    entrypoint,
-                    routes
-                };
-                const localisedUrlsConfig = resolveLocalisedUrlsConfig(localisedUrls);
-                if (!localisedUrlsConfig.enabled) return {
-                    entrypoint,
-                    routes
-                };
-                return {
-                    entrypoint,
-                    routes: applyLocalisedUrlsToRoutes(routes, languages, localisedUrlsConfig.map)
-                };
-            });
+                    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/Link.mjs

@@ -9,10 +9,10 @@ const EXTERNAL_TARGET_RE = /^(?:[a-z][a-z0-9+.-]*:|\/\/)/i;
 const Link = (props)=>{
     const { to, params, children, hash: hashProp, search: searchProp, hashScrollIntoView, activeOptions, activeProps, prefetch, preload, ...rest } = props;
     const adapter = useI18nRouterAdapter();
-    const { language, supportedLanguages, localisedUrls } = useModernI18n();
+    const { language, supportedLanguages, urlStrategy } = useModernI18n();
     const config = {
         languages: supportedLanguages,
-        localisedUrls
+        urlStrategy
     };
     const isExternal = EXTERNAL_TARGET_RE.test(to);
     const isBareHash = to.startsWith('#');
@@ -22,7 +22,7 @@ const Link = (props)=>{
         const interpolated = interpolateRouteParams(pathname || '/', params);
         const firstSegment = interpolated.split('/').filter(Boolean)[0];
         if (firstSegment && supportedLanguages.includes(firstSegment)) warnOnce(`lang-prefix:${to}`, `[plugin-i18n] <Link to="${to}"> starts with a language prefix. Write language-agnostic canonical paths; the Link localizes them automatically.`);
-        const localizedPathname = buildLocalizedUrl(interpolated, language, supportedLanguages, localisedUrls);
+        const localizedPathname = buildLocalizedUrl(interpolated, language, supportedLanguages, urlStrategy);
         const hash = hashProp ?? (hashFromTo ? hashFromTo.slice(1) : '');
         const { searchString, searchObject } = normalizeSearch(searchProp, searchFromTo);
         return {
@@ -42,7 +42,7 @@ const Link = (props)=>{
         isBareHash,
         language,
         supportedLanguages,
-        localisedUrls
+        urlStrategy
     ]);
     const isActive = useMemo(()=>{
         if (!target || !adapter.location) return false;
@@ -57,7 +57,7 @@ const Link = (props)=>{
         adapter.location,
         activeOptions?.exact,
         supportedLanguages,
-        localisedUrls
+        urlStrategy
     ]);
     const resolvedActiveProps = splitActiveProps(isActive, activeProps);
     const activeAttributes = isActive ? {
@@ -72,7 +72,7 @@ const Link = (props)=>{
             children: children
         });
     }
-    const { Link: RouterLink, hasRouter, framework } = adapter;
+    const { Link: RouterLink, hasRouter } = adapter;
     if (!hasRouter || !RouterLink) {
         const { replace: _replace, ...anchorProps } = rest;
         const { className: activeClassName, style: activeStyle, ...activeRest } = resolvedActiveProps;
@@ -95,38 +95,25 @@ const Link = (props)=>{
         ...rest.style,
         ...activeStyle
     };
-    if ('tanstack' === framework) {
-        const tanstackPreload = void 0 !== preload ? preload : void 0 === prefetch ? void 0 : 'none' === prefetch ? false : prefetch;
-        return /*#__PURE__*/ jsx(RouterLink, {
-            to: target.localizedPathname,
-            ...target.searchObject ? {
-                search: target.searchObject
-            } : {},
-            ...target.hash ? {
-                hash: target.hash
-            } : {},
-            ...void 0 === hashScrollIntoView ? {} : {
-                hashScrollIntoView
-            },
-            ...void 0 === tanstackPreload ? {} : {
-                preload: tanstackPreload
-            },
-            ...rest,
-            ...activeRest,
-            ...activeAttributes,
-            className: mergedClassName,
-            style: mergedStyle,
-            children: children
-        });
-    }
-    return /*#__PURE__*/ jsx(RouterLink, {
+    const routerProps = adapter.createLinkProps?.({
+        pathname: target.localizedPathname,
+        href: target.href,
+        search: target.searchObject,
+        hash: target.hash,
+        hashScrollIntoView,
+        prefetch,
+        preload
+    }) ?? {
         to: target.href,
         ...void 0 === prefetch ? {} : {
             prefetch
         },
         ...void 0 === preload ? {} : {
             preload
-        },
+        }
+    };
+    return /*#__PURE__*/ jsx(RouterLink, {
+        ...routerProps,
         ...rest,
         ...activeRest,
         ...activeAttributes,

package/dist/esm/runtime/context.mjs

@@ -1,17 +1,9 @@
 import { jsx } from "react/jsx-runtime";
-import { createContext, useCallback, useContext, useEffect, useMemo } from "react";
+import { RuntimeComponentResolverContext } from "@modern-js/runtime/context";
+import { useCallback, useContext, useEffect, useMemo } from "react";
 import { changeModernI18nLanguage, getPathLanguage, isI18nLanguageSupported, isI18nResourcesReady, translateI18n } from "./contextHelpers.mjs";
-import { getActualI18nextInstance } from "./i18n/instance.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,
@@ -22,68 +14,23 @@ const ModernI18nProvider = ({ children, i18nextProvider, value })=>{
         children: content
     });
 };
-const FederatedI18nBoundary = ({ children, defaultNamespace, fallbackLanguage, resources, supportedLanguages })=>{
-    const parent = useContext(ModernI18nContext);
-    const I18nextProvider = useContext(ReactI18nextProviderContext);
-    if (!parent) throw new Error('FederatedI18nBoundary must be used within ModernI18nProvider');
-    const languages = supportedLanguages ?? parent.languages ?? Object.keys(resources);
-    const scopedInstance = useMemo(()=>{
-        const parentInstance = getActualI18nextInstance(parent.i18nInstance);
-        const clone = parentInstance.cloneInstance?.({
-            defaultNS: defaultNamespace,
-            fallbackLng: fallbackLanguage ?? languages[0] ?? parent.language,
-            forkResourceStore: true,
-            initImmediate: false,
-            lng: parent.language,
-            ns: [
-                defaultNamespace
-            ],
-            resources,
-            supportedLngs: languages
-        });
-        if (!clone) throw new Error('FederatedI18nBoundary requires an i18n instance with cloneInstance support');
-        const resourceStore = clone.store;
-        const parentResourceStore = parentInstance.store;
-        const sharesNestedResourceState = Object.entries(resourceStore?.data ?? {}).some(([language, namespaces])=>{
-            const parentNamespaces = parentResourceStore?.data?.[language];
-            return namespaces === parentNamespaces || Object.entries(namespaces).some(([namespace, resource])=>null !== resource && 'object' == typeof resource && resource === parentNamespaces?.[namespace]);
-        });
-        if (clone === parentInstance || resourceStore === parentResourceStore || resourceStore?.data === parentResourceStore?.data || sharesNestedResourceState) throw new Error('FederatedI18nBoundary cloneInstance did not isolate the host resource store');
-        if (!resourceStore?.addResourceBundle || !clone.removeResourceBundle || !resourceStore.data) throw new Error('FederatedI18nBoundary requires an isolated mutable i18n resource store');
-        for (const [language, namespaces] of Object.entries(resourceStore.data))for (const namespace of Object.keys(namespaces))clone.removeResourceBundle(language, namespace);
-        for (const [language, namespaces] of Object.entries(resources))for (const [namespace, resource] of Object.entries(namespaces))resourceStore.addResourceBundle(language, namespace, resource, true, true);
-        return clone;
-    }, [
-        defaultNamespace,
-        fallbackLanguage,
-        languages,
-        parent.i18nInstance,
-        parent.language,
-        resources
-    ]);
-    const value = useMemo(()=>({
-            ...parent,
-            i18nInstance: scopedInstance,
-            language: parent.language,
-            languages
-        }), [
-        languages,
-        parent,
-        scopedInstance
-    ]);
-    const scopedContent = /*#__PURE__*/ jsx(ModernI18nProvider, {
-        value: value,
-        children: children
+const MissingFederatedI18nBoundary = ()=>{
+    throw new Error('FederatedI18nBoundary requires the @modern-js/i18n-integration runtime plugin');
+};
+const FederatedI18nBoundary = (props)=>{
+    const resolveComponent = useContext(RuntimeComponentResolverContext);
+    const Boundary = resolveComponent?.(MissingFederatedI18nBoundary, {
+        name: 'i18n.FederatedI18nBoundary'
+    }) ?? MissingFederatedI18nBoundary;
+    if (Boundary === FederatedI18nBoundary) throw new Error('FederatedI18nBoundary resolver returned its own wrapper');
+    return /*#__PURE__*/ jsx(Boundary, {
+        ...props
     });
-    return I18nextProvider ? /*#__PURE__*/ jsx(I18nextProvider, {
-        i18n: scopedInstance,
-        children: scopedContent
-    }) : scopedContent;
 };
 const useModernI18n = ()=>{
     const context = useContext(ModernI18nContext);
     if (!context) throw new Error('useModernI18n must be used within ModernI18nProvider');
-    const { language: contextLanguage, i18nInstance, languages, localePathRedirect, ignoreRedirectRoutes, localisedUrls, updateLanguage, synchronizeLanguage } = context;
+    const { language: contextLanguage, i18nInstance, languages, localePathRedirect, ignoreRedirectRoutes, urlStrategy, updateLanguage, synchronizeLanguage } = context;
     const { navigate, location, hasRouter } = useI18nRouterAdapter();
     const pathLanguage = useMemo(()=>getPathLanguage(location?.pathname, languages, localePathRedirect), [
         languages,
@@ -102,7 +49,7 @@ const useModernI18n = ()=>{
             updateLanguage,
             localePathRedirect,
             ignoreRedirectRoutes,
-            localisedUrls,
+            urlStrategy,
             languages,
             hasRouter,
             navigate,
@@ -112,7 +59,7 @@ const useModernI18n = ()=>{
         updateLanguage,
         localePathRedirect,
         ignoreRedirectRoutes,
-        localisedUrls,
+        urlStrategy,
         languages,
         hasRouter,
         navigate,
@@ -135,9 +82,10 @@ const useModernI18n = ()=>{
         t,
         i18nInstance: i18nInstance,
         supportedLanguages: languages || [],
-        localisedUrls,
+        urlStrategy,
         isLanguageSupported,
         isResourcesReady
     };
 };
-export { FederatedI18nBoundary, ModernI18nProvider, useModernI18n };
+export { getActualI18nextInstance } from "./i18n/instance.mjs";
+export { FederatedI18nBoundary, ModernI18nContext, ModernI18nProvider, ReactI18nextProviderContext, useModernI18n };

package/dist/esm/runtime/contextHelpers.mjs

@@ -17,7 +17,7 @@ async function changeI18nInstanceLanguage(i18nInstance, language) {
     else await i18nInstance.changeLanguage?.(language);
 }
 async function changeModernI18nLanguage(newLang, options) {
-    const { i18nInstance, updateLanguage, localePathRedirect, ignoreRedirectRoutes, localisedUrls, languages, hasRouter, navigate, location } = options;
+    const { i18nInstance, updateLanguage, localePathRedirect, ignoreRedirectRoutes, urlStrategy, languages, hasRouter, navigate, location } = options;
     try {
         if (!newLang || 'string' != typeof newLang) throw new Error('Language must be non-empty string');
         await changeI18nInstanceLanguage(i18nInstance, newLang);
@@ -28,8 +28,8 @@ async function changeModernI18nLanguage(newLang, options) {
             const relativePath = currentPath.replace(entryPath, '');
             const pathLanguage = detectLanguageFromPath(currentPath, languages || [], localePathRedirect);
             if (pathLanguage.detected && pathLanguage.language === newLang) return void updateLanguage?.(newLang);
-            if (!shouldIgnoreRedirect(relativePath, languages || [], ignoreRedirectRoutes)) {
-                const newPath = buildLocalizedUrl(relativePath, newLang, languages || [], localisedUrls);
+            if (!shouldIgnoreRedirect(relativePath, languages || [], ignoreRedirectRoutes, urlStrategy)) {
+                const newPath = buildLocalizedUrl(relativePath, newLang, languages || [], urlStrategy);
                 const newUrl = entryPath + newPath + location.search + location.hash;
                 await navigate(newUrl, {
                     replace: true
@@ -41,8 +41,8 @@ async function changeModernI18nLanguage(newLang, options) {
             const relativePath = currentPath.replace(entryPath, '');
             const pathLanguage = detectLanguageFromPath(currentPath, languages || [], localePathRedirect);
             if (pathLanguage.detected && pathLanguage.language === newLang) return void updateLanguage?.(newLang);
-            if (!shouldIgnoreRedirect(relativePath, languages || [], ignoreRedirectRoutes)) {
-                const newPath = buildLocalizedUrl(relativePath, newLang, languages || [], localisedUrls);
+            if (!shouldIgnoreRedirect(relativePath, languages || [], ignoreRedirectRoutes, urlStrategy)) {
+                const newPath = buildLocalizedUrl(relativePath, newLang, languages || [], urlStrategy);
                 const newUrl = entryPath + newPath + window.location.search + window.location.hash;
                 window.history.pushState(null, '', newUrl);
             }

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";
@@ -5,9 +8,10 @@ import "./types.mjs";
 const createI18nPlugin = (loadReactI18nextIntegration)=>(options)=>({
             name: '@modern-js/plugin-i18n',
             setup: (api)=>{
-                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 { 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,15 +39,18 @@ const createI18nPlugin = (loadReactI18nextIntegration)=>(options)=>({
                     languages,
                     fallbackLanguage,
                     ignoreRedirectRoutes,
-                    localisedUrls,
+                    urlStrategy: resolvedUrlStrategy,
+                    NavigationProvider: NavigationProvider ?? I18nRouterNavigationProvider,
+                    LanguageSynchronization,
                     getLatestI18nInstance: ()=>latestI18nInstance,
                     getI18nextProvider: ()=>I18nextProvider
                 }));
             }
         });
+export { I18nNavigationProvider, useI18nRouterAdapter, useNativeI18nRouterAdapter } from "./routerAdapter.mjs";
 export { FederatedI18nBoundary, useModernI18n } from "./context.mjs";
 export { I18nLink } from "./I18nLink.mjs";
 export { Link } from "./Link.mjs";
-export { canonicalPath, localizePath, useLocalizedLocation, useLocalizedPaths } from "./localizedPaths.mjs";
-export { buildLocalizedUrl, splitUrlTarget } from "./utils.mjs";
-export { createI18nPlugin };
+export { useLocalizedLocation, useLocalizedPaths } from "./localizedPaths.mjs";
+export { splitUrlTarget } from "./utils.mjs";
+export { I18nRouterNavigationProvider, createI18nPlugin, useIntegratedRouterAdapter };