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

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/redirect.mjs

@@ -5,10 +5,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'
@@ -18,8 +14,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',
@@ -38,6 +34,7 @@ const matchesPathPrefix = (pathname, prefix)=>{
 };
 const matchesSkipRule = (pathname, rule)=>{
     if ('exact' === rule.type) return normalisePathname(pathname) === normalisePathname(rule.path);
+    if ('pattern' === rule.type) return rule.path.test(normalisePathname(pathname));
     return matchesPathPrefix(pathname, rule.path);
 };
 const isDefaultLocaleRedirectSkipPath = (pathname, languages = [])=>{

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/router-navigation/adapter.mjs

@@ -0,0 +1,197 @@
+import { Fragment, jsx } from "react/jsx-runtime";
+import { RuntimeContext, isBrowser } from "@modern-js/runtime";
+import { InternalRuntimeContext } from "@modern-js/runtime/context";
+import { getRouterRuntimeState, subscribeRouterRuntimeState } from "@modern-js/runtime-extensions/router-state";
+import { useCallback, useContext, useSyncExternalStore } from "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 (!isBrowser()) return null;
+    return {
+        pathname: window.location.pathname,
+        search: window.location.search,
+        hash: window.location.hash
+    };
+};
+const getRouterFramework = (runtimeContext, internalContext, inReactRouter)=>{
+    const framework = getRouterRuntimeState(internalContext)?.framework || 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 = 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 = useContext(RuntimeContext);
+        const internalContext = useContext(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 = useCallback((update)=>{
+            const unsubscribers = [];
+            const unsubscribeFromSlot = 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 = useCallback(()=>getRouterSnapshot(internalContext, contextRouter), [
+            contextRouter,
+            internalContext
+        ]);
+        useSyncExternalStore(subscribeToRouter, getSnapshot, getSnapshot);
+        const navigate = 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__*/ jsx(Fragment, {
+            children: children
+        });
+        return /*#__PURE__*/ jsx(I18nNavigationProvider, {
+            value: value,
+            children: children
+        });
+    };
+    return {
+        useIntegratedRouterAdapter,
+        I18nRouterNavigationProvider
+    };
+};
+export { createI18nRouterNavigation };

package/dist/esm/router-navigation/index.mjs

@@ -0,0 +1 @@
+export { createI18nRouterNavigation } from "./adapter.mjs";

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/redirect.mjs

@@ -6,10 +6,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'
@@ -19,8 +15,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',
@@ -39,6 +35,7 @@ const matchesPathPrefix = (pathname, prefix)=>{
 };
 const matchesSkipRule = (pathname, rule)=>{
     if ('exact' === rule.type) return normalisePathname(pathname) === normalisePathname(rule.path);
+    if ('pattern' === rule.type) return rule.path.test(normalisePathname(pathname));
     return matchesPathPrefix(pathname, rule.path);
 };
 const isDefaultLocaleRedirectSkipPath = (pathname, languages = [])=>{

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

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

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

@@ -0,0 +1,13 @@
+import "node:module";
+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 };