@bleedingdev/modern-js-i18n-runtime-extensions 3.9.0-ultramodern.2 → 3.9.0-ultramodern.4

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

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/types/localisedUrls/index.d.ts

@@ -5,5 +5,6 @@ export { buildPathFromPattern, matchPathPattern } from './patterns.js';
 export type { LocaleRedirectSkipRule } from './redirect.js';
 export { DEFAULT_LOCALE_REDIRECT_SKIP_RULES, isDefaultLocaleRedirectSkipPath, matchesPathPrefix, shouldSkipLocaleRedirect, } from './redirect.js';
 export { resolveCanonicalLocalisedPath, resolveLocalisedPath } from './resolve.js';
+export { canonicaliseLocalisedRoutes, createLocalisedRouteRewrite, } from './routeIdentity.js';
 export { applyLocalisedUrlsToRoutes, validateLocalisedUrls } from './routes.js';
 export type { LocalisedRoute, LocalisedUrlPathMap, LocalisedUrlsMap, LocalisedUrlsOption, ResolvedLocalisedUrlsConfig, } from './types.js';

package/dist/types/localisedUrls/routeIdentity.d.ts

@@ -0,0 +1,24 @@
+interface RouteIdentity {
+    id?: string;
+    path?: string;
+    canonicalPath: string;
+    paths?: Record<string, string>;
+}
+interface RouteNode {
+    id?: string;
+    path?: string;
+    children?: RouteNode[];
+    modernLocalisedRoute?: RouteIdentity;
+}
+/** Restore one source route identity for routers with strict route-ID hooks. */
+export declare function canonicaliseLocalisedRoutes<T extends RouteNode>(routes: T[]): T[];
+/** Use the router's URL rewrite seam; browser URLs retain their locale spelling. */
+export declare function createLocalisedRouteRewrite(routes: RouteNode[]): {
+    input: ({ url }: {
+        url: URL;
+    }) => URL;
+    output: ({ url }: {
+        url: URL;
+    }) => URL;
+} | undefined;
+export {};

package/package.json

@@ -17,7 +17,7 @@
     "modern.js",
     "i18n"
   ],
-  "version": "3.9.0-ultramodern.2",
+  "version": "3.9.0-ultramodern.4",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.mjs",
@@ -47,11 +47,11 @@
     "i18next-browser-languagedetector": "^8.2.1"
   },
   "peerDependencies": {
-    "@modern-js/runtime": "3.9.0-ultramodern.2",
+    "@modern-js/runtime": "3.9.0-ultramodern.4",
     "react": "^19.2.8"
   },
   "devDependencies": {
-    "@modern-js/runtime": "npm:@bleedingdev/modern-js-runtime@3.9.0-ultramodern.2",
+    "@modern-js/runtime": "npm:@bleedingdev/modern-js-runtime@3.9.0-ultramodern.4",
     "@rslib/core": "1.0.0",
     "@scripts/rstest-config": "2.66.0",
     "@types/node": "^26.4.1",

package/src/localisedUrls/index.ts

@@ -14,6 +14,10 @@ export {
   shouldSkipLocaleRedirect,
 } from './redirect';
 export { resolveCanonicalLocalisedPath, resolveLocalisedPath } from './resolve';
+export {
+  canonicaliseLocalisedRoutes,
+  createLocalisedRouteRewrite,
+} from './routeIdentity';
 export { applyLocalisedUrlsToRoutes, validateLocalisedUrls } from './routes';
 export type {
   LocalisedRoute,

package/src/localisedUrls/routeIdentity.ts

@@ -0,0 +1,107 @@
+import { normalisePathPattern } from './normalise';
+import { buildPathFromPattern, matchPathPattern } from './patterns';
+
+interface RouteIdentity {
+  id?: string;
+  path?: string;
+  canonicalPath: string;
+  paths?: Record<string, string>;
+}
+
+interface RouteNode {
+  id?: string;
+  path?: string;
+  children?: RouteNode[];
+  modernLocalisedRoute?: RouteIdentity;
+}
+
+/** Restore one source route identity for routers with strict route-ID hooks. */
+export function canonicaliseLocalisedRoutes<T extends RouteNode>(
+  routes: T[],
+): T[] {
+  const seen = new Set<string>();
+  return routes.flatMap(route => {
+    const identity = route.modernLocalisedRoute;
+    const key = identity?.id ?? identity?.path;
+    if (key !== undefined) {
+      if (seen.has(key)) return [];
+      seen.add(key);
+    }
+    return [
+      {
+        ...route,
+        ...(identity ? { id: identity.id, path: identity.path } : {}),
+        ...(route.children
+          ? { children: canonicaliseLocalisedRoutes(route.children) }
+          : {}),
+      },
+    ];
+  });
+}
+
+type PathRewrite = { from: string; to: string };
+
+function rewritePath(url: URL, mappings: PathRewrite[]) {
+  for (const { from, to } of mappings) {
+    const params = matchPathPattern(url.pathname, from);
+    if (params) {
+      url.pathname = buildPathFromPattern(to, params);
+      break;
+    }
+  }
+  return url;
+}
+
+/** Use the router's URL rewrite seam; browser URLs retain their locale spelling. */
+export function createLocalisedRouteRewrite(routes: RouteNode[]) {
+  const input: PathRewrite[] = [];
+  const output: PathRewrite[] = [];
+  const visit = (nodes: RouteNode[], parent: string) => {
+    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 (input.length === 0) return undefined;
+  const specificity = (pattern: string) =>
+    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 }: { url: URL }) => rewritePath(url, input),
+    output: ({ url }: { url: URL }) => rewritePath(url, output),
+  };
+}

package/src/localisedUrls/routes.ts

@@ -291,6 +291,16 @@ const transformLocalisedRoute = (
 
   const baseRoute = {
     ...route,
+    ...(!isFrameworkInternalRoutePath(canonicalPath)
+      ? {
+          modernLocalisedRoute: {
+            id: route.id,
+            path: route.path,
+            canonicalPath,
+            paths: localisedUrlEntry,
+          },
+        }
+      : {}),
     ...(children ? { children } : {}),
   } as LocalisedRoute;
 

package/tests/reactLanguageSync.test.tsx

@@ -49,7 +49,11 @@ test('an abandoned suspended render cannot publish an uncommitted target', async
   const container = document.createElement('div');
   const root = createRoot(container);
   await act(async () => {
-    root.render(<Harness target={first} />);
+    root.render(
+      <Suspense fallback={<p>loading</p>}>
+        <Harness target={first} />
+      </Suspense>,
+    );
   });
   expect(changes).toEqual(['first']);