@bleedingdev/modern-js-i18n-runtime-extensions 3.9.0-ultramodern.1 → 3.9.0-ultramodern.10

package/dist/cjs/index.js

@@ -6,6 +6,9 @@ var __webpack_modules__ = {
     "./language-sync/react" (module) {
         module.exports = require("./language-sync/react.js");
     },
+    "./localeRedirectPolicy" (module) {
+        module.exports = require("./localeRedirectPolicy.js");
+    },
     "./localisedUrls/index" (module) {
         module.exports = require("./localisedUrls/index.js");
     }
@@ -65,9 +68,13 @@ var __webpack_exports__ = {};
     var __rspack_reexport = {};
     for(const __rspack_import_key in _language_sync_react__rspack_import_1)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_language_sync_react__rspack_import_1[__rspack_import_key];
     __webpack_require__.d(__webpack_exports__, __rspack_reexport);
-    var _localisedUrls_index__rspack_import_2 = __webpack_require__("./localisedUrls/index");
+    var _localeRedirectPolicy__rspack_import_2 = __webpack_require__("./localeRedirectPolicy");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _localeRedirectPolicy__rspack_import_2)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_localeRedirectPolicy__rspack_import_2[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _localisedUrls_index__rspack_import_3 = __webpack_require__("./localisedUrls/index");
     var __rspack_reexport = {};
-    for(const __rspack_import_key in _localisedUrls_index__rspack_import_2)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_localisedUrls_index__rspack_import_2[__rspack_import_key];
+    for(const __rspack_import_key in _localisedUrls_index__rspack_import_3)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_localisedUrls_index__rspack_import_3[__rspack_import_key];
     __webpack_require__.d(__webpack_exports__, __rspack_reexport);
 })();
 for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];

package/dist/cjs/localeRedirectPolicy.js

@@ -0,0 +1,96 @@
+"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__, {
+    buildLocalizedUrl: ()=>buildLocalizedUrl,
+    createLocaleRedirectResponse: ()=>createLocaleRedirectResponse,
+    getLanguageFromPath: ()=>getLanguageFromPath,
+    isStaticResourceRequest: ()=>isStaticResourceRequest,
+    shouldIgnoreRedirect: ()=>shouldIgnoreRedirect
+});
+const index_js_namespaceObject = require("./localisedUrls/index.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 || '/';
+};
+const shouldIgnoreRedirect = (pathname, urlPath, ignoreRedirectRoutes)=>{
+    const remainingPath = stripUrlPathPrefix(pathname, urlPath);
+    return (0, index_js_namespaceObject.shouldSkipLocaleRedirect)(remainingPath, [], ignoreRedirectRoutes);
+};
+const isStaticResourceRequest = (pathname, staticRoutePrefixes, languages = [])=>{
+    if ((0, index_js_namespaceObject.isDefaultLocaleRedirectSkipPath)(pathname, languages)) return true;
+    const matchesStaticRoutePrefix = (targetPathname)=>staticRoutePrefixes.some((prefix)=>(0, index_js_namespaceObject.matchesPathPrefix)(targetPathname, prefix));
+    if (matchesStaticRoutePrefix(pathname)) return true;
+    const pathWithoutLanguage = (0, index_js_namespaceObject.stripLanguagePrefix)(pathname, languages);
+    return pathWithoutLanguage !== pathname && matchesStaticRoutePrefix(pathWithoutLanguage);
+};
+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 buildLocalizedUrl = (req, urlPath, language, languages, localisedUrls)=>{
+    const url = new URL(req.url);
+    const pathname = url.pathname;
+    const basePath = urlPath.replace('/*', '');
+    const remainingPath = stripUrlPathPrefix(pathname, urlPath);
+    const newPathname = (0, index_js_namespaceObject.localiseTargetPathname)(remainingPath, language, languages, localisedUrls);
+    const suffix = `${url.search}${url.hash}`;
+    const localizedUrl = '/' === basePath ? newPathname + suffix : basePath + newPathname + suffix;
+    return localizedUrl;
+};
+const createLocaleRedirectResponse = (location)=>new Response(null, {
+        status: 302,
+        headers: {
+            'Cache-Control': 'private, no-store',
+            Location: location,
+            Vary: 'Accept-Language, Cookie'
+        }
+    });
+exports.buildLocalizedUrl = __webpack_exports__.buildLocalizedUrl;
+exports.createLocaleRedirectResponse = __webpack_exports__.createLocaleRedirectResponse;
+exports.getLanguageFromPath = __webpack_exports__.getLanguageFromPath;
+exports.isStaticResourceRequest = __webpack_exports__.isStaticResourceRequest;
+exports.shouldIgnoreRedirect = __webpack_exports__.shouldIgnoreRedirect;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "buildLocalizedUrl",
+    "createLocaleRedirectResponse",
+    "getLanguageFromPath",
+    "isStaticResourceRequest",
+    "shouldIgnoreRedirect"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/localisedUrls/index.js

@@ -32,6 +32,8 @@ __webpack_require__.d(__webpack_exports__, {
     applyLocalisedUrlsToRoutes: ()=>external_routes_js_namespaceObject.applyLocalisedUrlsToRoutes,
     buildPathFromPattern: ()=>external_patterns_js_namespaceObject.buildPathFromPattern,
     canonicalTargetPathname: ()=>external_pathname_js_namespaceObject.canonicalTargetPathname,
+    canonicaliseLocalisedRoutes: ()=>external_routeIdentity_js_namespaceObject.canonicaliseLocalisedRoutes,
+    createLocalisedRouteRewrite: ()=>external_routeIdentity_js_namespaceObject.createLocalisedRouteRewrite,
     isDefaultLocaleRedirectSkipPath: ()=>external_redirect_js_namespaceObject.isDefaultLocaleRedirectSkipPath,
     localiseTargetPathname: ()=>external_pathname_js_namespaceObject.localiseTargetPathname,
     matchPathPattern: ()=>external_patterns_js_namespaceObject.matchPathPattern,
@@ -51,11 +53,14 @@ const external_pathname_js_namespaceObject = require("./pathname.js");
 const external_patterns_js_namespaceObject = require("./patterns.js");
 const external_redirect_js_namespaceObject = require("./redirect.js");
 const external_resolve_js_namespaceObject = require("./resolve.js");
+const external_routeIdentity_js_namespaceObject = require("./routeIdentity.js");
 const external_routes_js_namespaceObject = require("./routes.js");
 exports.DEFAULT_LOCALE_REDIRECT_SKIP_RULES = __webpack_exports__.DEFAULT_LOCALE_REDIRECT_SKIP_RULES;
 exports.applyLocalisedUrlsToRoutes = __webpack_exports__.applyLocalisedUrlsToRoutes;
 exports.buildPathFromPattern = __webpack_exports__.buildPathFromPattern;
 exports.canonicalTargetPathname = __webpack_exports__.canonicalTargetPathname;
+exports.canonicaliseLocalisedRoutes = __webpack_exports__.canonicaliseLocalisedRoutes;
+exports.createLocalisedRouteRewrite = __webpack_exports__.createLocalisedRouteRewrite;
 exports.isDefaultLocaleRedirectSkipPath = __webpack_exports__.isDefaultLocaleRedirectSkipPath;
 exports.localiseTargetPathname = __webpack_exports__.localiseTargetPathname;
 exports.matchPathPattern = __webpack_exports__.matchPathPattern;
@@ -73,6 +78,8 @@ for(var __rspack_i in __webpack_exports__)if (-1 === [
     "applyLocalisedUrlsToRoutes",
     "buildPathFromPattern",
     "canonicalTargetPathname",
+    "canonicaliseLocalisedRoutes",
+    "createLocalisedRouteRewrite",
     "isDefaultLocaleRedirectSkipPath",
     "localiseTargetPathname",
     "matchPathPattern",

package/dist/cjs/localisedUrls/redirect.js

@@ -40,10 +40,6 @@ const DEFAULT_LOCALE_REDIRECT_SKIP_RULES = [
         type: 'exact',
         path: '/backend-mf-manifest.json'
     },
-    {
-        type: 'exact',
-        path: '/backendRemoteEntry.cjs'
-    },
     {
         type: 'exact',
         path: '/mf-manifest.json'
@@ -53,8 +49,8 @@ const DEFAULT_LOCALE_REDIRECT_SKIP_RULES = [
         path: '/mf-stats.json'
     },
     {
-        type: 'exact',
-        path: '/remoteEntry.js'
+        type: 'pattern',
+        path: /^\/(?:backendRemoteEntry(?:\.[a-zA-Z0-9_-]+)?\.cjs|remoteEntry(?:\.[a-zA-Z0-9_-]+)?\.js)$/
     },
     {
         type: 'prefix',
@@ -73,6 +69,7 @@ const matchesPathPrefix = (pathname, prefix)=>{
 };
 const matchesSkipRule = (pathname, rule)=>{
     if ('exact' === rule.type) return (0, external_normalise_js_namespaceObject.normalisePathname)(pathname) === (0, external_normalise_js_namespaceObject.normalisePathname)(rule.path);
+    if ('pattern' === rule.type) return rule.path.test((0, external_normalise_js_namespaceObject.normalisePathname)(pathname));
     return matchesPathPrefix(pathname, rule.path);
 };
 const isDefaultLocaleRedirectSkipPath = (pathname, languages = [])=>{

package/dist/cjs/localisedUrls/routeIdentity.js

@@ -0,0 +1,118 @@
+"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__, {
+    canonicaliseLocalisedRoutes: ()=>canonicaliseLocalisedRoutes,
+    createLocalisedRouteRewrite: ()=>createLocalisedRouteRewrite
+});
+const external_normalise_js_namespaceObject = require("./normalise.js");
+const external_patterns_js_namespaceObject = require("./patterns.js");
+function canonicaliseLocalisedRoutes(routes) {
+    const seen = new Set();
+    return routes.flatMap((route)=>{
+        const identity = route.modernLocalisedRoute;
+        const key = identity?.id ?? identity?.path;
+        if (void 0 !== key) {
+            if (seen.has(key)) return [];
+            seen.add(key);
+        }
+        return [
+            {
+                ...route,
+                ...identity ? {
+                    id: identity.id,
+                    path: identity.path
+                } : {},
+                ...route.children ? {
+                    children: canonicaliseLocalisedRoutes(route.children)
+                } : {}
+            }
+        ];
+    });
+}
+function rewritePath(url, mappings) {
+    for (const { from, to } of mappings){
+        const params = (0, external_patterns_js_namespaceObject.matchPathPattern)(url.pathname, from);
+        if (params) {
+            url.pathname = (0, external_patterns_js_namespaceObject.buildPathFromPattern)(to, params);
+            break;
+        }
+    }
+    return url;
+}
+function createLocalisedRouteRewrite(routes) {
+    const input = [];
+    const output = [];
+    const visit = (nodes, parent)=>{
+        for (const route of nodes){
+            const fullPath = (0, external_normalise_js_namespaceObject.normalisePathPattern)(`${parent}/${route.path ?? ''}`);
+            const identity = route.modernLocalisedRoute;
+            if (identity?.paths && fullPath.endsWith(identity.canonicalPath)) {
+                const prefix = fullPath.slice(0, -identity.canonicalPath.length);
+                const hasLocale = prefix.split('/').some((segment)=>/^:(?:lang|locale|language)\??$/.test(segment));
+                for (const [language, localisedPath] of Object.entries(identity.paths)){
+                    const localePrefix = prefix.split('/').map((segment)=>/^:(?:lang|locale|language)\??$/.test(segment) ? language : segment).join('/');
+                    const canonical = (0, external_normalise_js_namespaceObject.normalisePathPattern)(`${localePrefix}/${identity.canonicalPath}`);
+                    const localised = (0, external_normalise_js_namespaceObject.normalisePathPattern)(`${localePrefix}/${localisedPath}`);
+                    if (canonical !== localised) {
+                        input.push({
+                            from: localised,
+                            to: canonical
+                        });
+                        if (hasLocale) output.push({
+                            from: canonical,
+                            to: localised
+                        });
+                    }
+                }
+            }
+            if (route.children) visit(route.children, fullPath);
+        }
+    };
+    visit(canonicaliseLocalisedRoutes(routes), '');
+    if (0 === input.length) return;
+    const specificity = (pattern)=>pattern.split('/').filter((segment)=>segment && !segment.startsWith(':') && '*' !== segment).length;
+    for (const mappings of [
+        input,
+        output
+    ])mappings.sort((a, b)=>specificity(b.from) - specificity(a.from));
+    return {
+        input: ({ url })=>rewritePath(url, input),
+        output: ({ url })=>rewritePath(url, output)
+    };
+}
+exports.canonicaliseLocalisedRoutes = __webpack_exports__.canonicaliseLocalisedRoutes;
+exports.createLocalisedRouteRewrite = __webpack_exports__.createLocalisedRouteRewrite;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "canonicaliseLocalisedRoutes",
+    "createLocalisedRouteRewrite"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/localisedUrls/routes.js

@@ -134,6 +134,14 @@ const transformLocalisedRoute = (route, parentCanonicalPath, parentLocalisedPath
     const children = 'children' in route && route.children ? route.children.flatMap((child)=>transformLocalisedRoute(child, canonicalPath, routeLocalisedPaths, languages, localisedUrls)) : void 0;
     const baseRoute = {
         ...route,
+        ...!isFrameworkInternalRoutePath(canonicalPath) ? {
+            modernLocalisedRoute: {
+                id: route.id,
+                path: route.path,
+                canonicalPath,
+                paths: localisedUrlEntry
+            }
+        } : {},
         ...children ? {
             children
         } : {}

package/dist/cjs/paths.js

@@ -0,0 +1,56 @@
+"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__, {
+    buildLocalizedUrl: ()=>buildLocalizedUrl,
+    canonicalPath: ()=>canonicalPath,
+    localizePath: ()=>localizePath
+});
+const url_namespaceObject = require("@modern-js/runtime-utils/url");
+const index_js_namespaceObject = require("./localisedUrls/index.js");
+const buildLocalizedUrl = (target, language, languages, localisedUrls)=>{
+    const { pathname, search, hash } = (0, url_namespaceObject.splitUrlTarget)(target);
+    return `${(0, index_js_namespaceObject.localiseTargetPathname)(pathname, language, languages, localisedUrls)}${search}${hash}`;
+};
+const localizePath = (target, language, config)=>buildLocalizedUrl(target, language, config.languages, config.localisedUrls);
+const canonicalPath = (target, config)=>{
+    const { pathname, search, hash } = (0, url_namespaceObject.splitUrlTarget)(target);
+    return `${(0, index_js_namespaceObject.canonicalTargetPathname)(pathname, config.languages, config.localisedUrls)}${search}${hash}`;
+};
+exports.buildLocalizedUrl = __webpack_exports__.buildLocalizedUrl;
+exports.canonicalPath = __webpack_exports__.canonicalPath;
+exports.localizePath = __webpack_exports__.localizePath;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "buildLocalizedUrl",
+    "canonicalPath",
+    "localizePath"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/router-navigation/adapter.js

@@ -0,0 +1,235 @@
+"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__, {
+    createI18nRouterNavigation: ()=>createI18nRouterNavigation
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const runtime_namespaceObject = require("@modern-js/runtime");
+const context_namespaceObject = require("@modern-js/runtime/context");
+const router_state_namespaceObject = require("@modern-js/runtime-extensions/router-state");
+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, router_state_namespaceObject.getRouterRuntimeState)(internalContext)?.framework || (0, router_state_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, router_state_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 createI18nRouterNavigation = ({ I18nNavigationProvider, useNativeI18nRouterAdapter })=>{
+    const useIntegratedRouterAdapter = ()=>{
+        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 native = useNativeI18nRouterAdapter();
+        const inReactRouter = native.hasRouter;
+        const reactRouterNavigate = native.navigate;
+        const reactRouterLocation = inReactRouter ? native.location : null;
+        const reactRouterParams = native.params;
+        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 slotRouter = getRouterInstance(internalContext, contextRouter);
+        const drivableSlotRouter = ('tanstack' === framework || 'react-router' === framework) && 'function' == typeof slotRouter?.navigate;
+        const hasRouter = Boolean(reactRouterNavigate) || drivableSlotRouter;
+        const subscribeToRouter = (0, external_react_namespaceObject.useCallback)((update)=>{
+            const unsubscribers = [];
+            const unsubscribeFromSlot = (0, router_state_namespaceObject.subscribeRouterRuntimeState)(internalContext, update);
+            if ('function' == typeof unsubscribeFromSlot) unsubscribers.push(unsubscribeFromSlot);
+            const router = getRouterInstance(internalContext, contextRouter);
+            if (!router) return ()=>{
+                for (const unsubscribe of unsubscribers)unsubscribe();
+            };
+            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;
+        return {
+            framework,
+            hasRouter,
+            location,
+            navigate: hasRouter ? navigate : null,
+            Link,
+            params,
+            ...'tanstack' === framework ? {
+                createLinkProps: createTanstackLinkProps
+            } : {}
+        };
+    };
+    const createTanstackLinkProps = (target)=>{
+        const preload = void 0 !== target.preload ? target.preload : 'none' === target.prefetch ? false : target.prefetch;
+        return {
+            to: target.pathname,
+            ...target.search ? {
+                search: target.search
+            } : {},
+            ...target.hash ? {
+                hash: target.hash
+            } : {},
+            ...void 0 === target.hashScrollIntoView ? {} : {
+                hashScrollIntoView: target.hashScrollIntoView
+            },
+            ...void 0 === preload ? {} : {
+                preload
+            }
+        };
+    };
+    const I18nRouterNavigationProvider = ({ children })=>{
+        const value = useIntegratedRouterAdapter();
+        const native = useNativeI18nRouterAdapter();
+        if (!value.hasRouter || native.hasRouter) return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(jsx_runtime_namespaceObject.Fragment, {
+            children: children
+        });
+        return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(I18nNavigationProvider, {
+            value: value,
+            children: children
+        });
+    };
+    return {
+        useIntegratedRouterAdapter,
+        I18nRouterNavigationProvider
+    };
+};
+exports.createI18nRouterNavigation = __webpack_exports__.createI18nRouterNavigation;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createI18nRouterNavigation"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/router-navigation/index.js

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

package/dist/esm/index.mjs

@@ -1,3 +1,4 @@
 export * from "./language-sync/controller.mjs";
 export * from "./language-sync/react.mjs";
+export * from "./localeRedirectPolicy.mjs";
 export * from "./localisedUrls/index.mjs";