@bleedingdev/modern-js-i18n-runtime-extensions 3.9.0-ultramodern.3 → 3.9.0-ultramodern.5

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

package/dist/esm/localeRedirectPolicy.mjs

@@ -0,0 +1,46 @@
+import { isDefaultLocaleRedirectSkipPath, localiseTargetPathname, matchesPathPrefix, shouldSkipLocaleRedirect, stripLanguagePrefix } from "./localisedUrls/index.mjs";
+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 shouldSkipLocaleRedirect(remainingPath, [], ignoreRedirectRoutes);
+};
+const isStaticResourceRequest = (pathname, staticRoutePrefixes, languages = [])=>{
+    if (isDefaultLocaleRedirectSkipPath(pathname, languages)) return true;
+    const matchesStaticRoutePrefix = (targetPathname)=>staticRoutePrefixes.some((prefix)=>matchesPathPrefix(targetPathname, prefix));
+    if (matchesStaticRoutePrefix(pathname)) return true;
+    const pathWithoutLanguage = 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 = 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'
+        }
+    });
+export { buildLocalizedUrl, createLocaleRedirectResponse, getLanguageFromPath, isStaticResourceRequest, shouldIgnoreRedirect };

package/dist/esm/localisedUrls/index.mjs

@@ -4,4 +4,5 @@ export { canonicalTargetPathname, localiseTargetPathname, stripLanguagePrefix }
 export { buildPathFromPattern, matchPathPattern } from "./patterns.mjs";
 export { DEFAULT_LOCALE_REDIRECT_SKIP_RULES, isDefaultLocaleRedirectSkipPath, matchesPathPrefix, shouldSkipLocaleRedirect } from "./redirect.mjs";
 export { resolveCanonicalLocalisedPath, resolveLocalisedPath } from "./resolve.mjs";
+export { canonicaliseLocalisedRoutes, createLocalisedRouteRewrite } from "./routeIdentity.mjs";
 export { applyLocalisedUrlsToRoutes, validateLocalisedUrls } from "./routes.mjs";

package/dist/esm/localisedUrls/routeIdentity.mjs

@@ -0,0 +1,77 @@
+import { normalisePathPattern } from "./normalise.mjs";
+import { buildPathFromPattern, matchPathPattern } from "./patterns.mjs";
+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 = matchPathPattern(url.pathname, from);
+        if (params) {
+            url.pathname = buildPathFromPattern(to, params);
+            break;
+        }
+    }
+    return url;
+}
+function createLocalisedRouteRewrite(routes) {
+    const input = [];
+    const output = [];
+    const visit = (nodes, parent)=>{
+        for (const route of nodes){
+            const fullPath = 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 = normalisePathPattern(`${localePrefix}/${identity.canonicalPath}`);
+                    const localised = 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)
+    };
+}
+export { canonicaliseLocalisedRoutes, createLocalisedRouteRewrite };

package/dist/esm/localisedUrls/routes.mjs

@@ -101,6 +101,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/esm/paths.mjs

@@ -0,0 +1,12 @@
+import { splitUrlTarget } from "@modern-js/runtime-utils/url";
+import { canonicalTargetPathname, localiseTargetPathname } from "./localisedUrls/index.mjs";
+const buildLocalizedUrl = (target, language, languages, localisedUrls)=>{
+    const { pathname, search, hash } = splitUrlTarget(target);
+    return `${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 } = splitUrlTarget(target);
+    return `${canonicalTargetPathname(pathname, config.languages, config.localisedUrls)}${search}${hash}`;
+};
+export { buildLocalizedUrl, canonicalPath, localizePath };

package/dist/esm-node/index.mjs

@@ -1,4 +1,5 @@
 import "node:module";
 export * from "./language-sync/controller.mjs";
 export * from "./language-sync/react.mjs";
+export * from "./localeRedirectPolicy.mjs";
 export * from "./localisedUrls/index.mjs";

package/dist/esm-node/localeRedirectPolicy.mjs

@@ -0,0 +1,47 @@
+import "node:module";
+import { isDefaultLocaleRedirectSkipPath, localiseTargetPathname, matchesPathPrefix, shouldSkipLocaleRedirect, stripLanguagePrefix } from "./localisedUrls/index.mjs";
+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 shouldSkipLocaleRedirect(remainingPath, [], ignoreRedirectRoutes);
+};
+const isStaticResourceRequest = (pathname, staticRoutePrefixes, languages = [])=>{
+    if (isDefaultLocaleRedirectSkipPath(pathname, languages)) return true;
+    const matchesStaticRoutePrefix = (targetPathname)=>staticRoutePrefixes.some((prefix)=>matchesPathPrefix(targetPathname, prefix));
+    if (matchesStaticRoutePrefix(pathname)) return true;
+    const pathWithoutLanguage = 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 = 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'
+        }
+    });
+export { buildLocalizedUrl, createLocaleRedirectResponse, getLanguageFromPath, isStaticResourceRequest, shouldIgnoreRedirect };

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

@@ -5,4 +5,5 @@ export { canonicalTargetPathname, localiseTargetPathname, stripLanguagePrefix }
 export { buildPathFromPattern, matchPathPattern } from "./patterns.mjs";
 export { DEFAULT_LOCALE_REDIRECT_SKIP_RULES, isDefaultLocaleRedirectSkipPath, matchesPathPrefix, shouldSkipLocaleRedirect } from "./redirect.mjs";
 export { resolveCanonicalLocalisedPath, resolveLocalisedPath } from "./resolve.mjs";
+export { canonicaliseLocalisedRoutes, createLocalisedRouteRewrite } from "./routeIdentity.mjs";
 export { applyLocalisedUrlsToRoutes, validateLocalisedUrls } from "./routes.mjs";

package/dist/esm-node/localisedUrls/routeIdentity.mjs

@@ -0,0 +1,78 @@
+import "node:module";
+import { normalisePathPattern } from "./normalise.mjs";
+import { buildPathFromPattern, matchPathPattern } from "./patterns.mjs";
+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 = matchPathPattern(url.pathname, from);
+        if (params) {
+            url.pathname = buildPathFromPattern(to, params);
+            break;
+        }
+    }
+    return url;
+}
+function createLocalisedRouteRewrite(routes) {
+    const input = [];
+    const output = [];
+    const visit = (nodes, parent)=>{
+        for (const route of nodes){
+            const fullPath = 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 = normalisePathPattern(`${localePrefix}/${identity.canonicalPath}`);
+                    const localised = 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)
+    };
+}
+export { canonicaliseLocalisedRoutes, createLocalisedRouteRewrite };