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

package/src/localisedUrls/redirect.ts

@@ -9,15 +9,26 @@ export type LocaleRedirectSkipRule =
   | {
       type: 'prefix';
       path: string;
+    }
+  | {
+      type: 'pattern';
+      path: RegExp;
     };
 
+/**
+ * Federation artifacts are never pages. The remote entries match the same
+ * shapes the federation layer itself recognises and serves (`mfCache.ts`):
+ * a manifest may name a root entry such as `remoteEntry.catalog.js`.
+ */
 export const DEFAULT_LOCALE_REDIRECT_SKIP_RULES: readonly LocaleRedirectSkipRule[] =
   [
     { type: 'exact', path: '/backend-mf-manifest.json' },
-    { type: 'exact', path: '/backendRemoteEntry.cjs' },
     { type: 'exact', path: '/mf-manifest.json' },
     { type: 'exact', 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', path: '/static/' },
     { type: 'prefix', path: '/upload/' },
   ];
@@ -45,6 +56,9 @@ const matchesSkipRule = (
   if (rule.type === 'exact') {
     return normalisePathname(pathname) === normalisePathname(rule.path);
   }
+  if (rule.type === 'pattern') {
+    return rule.path.test(normalisePathname(pathname));
+  }
 
   return matchesPathPrefix(pathname, rule.path);
 };

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/src/paths.ts

@@ -0,0 +1,37 @@
+import { splitUrlTarget } from '@modern-js/runtime-utils/url';
+import {
+  canonicalTargetPathname,
+  type LocalisedUrlsOption,
+  localiseTargetPathname,
+} from './localisedUrls';
+
+export interface LocalizedPathsConfig {
+  languages: string[];
+  localisedUrls?: LocalisedUrlsOption;
+}
+
+/** Synchronous mapped URL construction, independent of React/plugin setup. */
+export const buildLocalizedUrl = (
+  target: string,
+  language: string,
+  languages: string[],
+  localisedUrls?: LocalisedUrlsOption,
+): string => {
+  const { pathname, search, hash } = splitUrlTarget(target);
+  return `${localiseTargetPathname(pathname, language, languages, localisedUrls)}${search}${hash}`;
+};
+
+export const localizePath = (
+  target: string,
+  language: string,
+  config: LocalizedPathsConfig,
+): string =>
+  buildLocalizedUrl(target, language, config.languages, config.localisedUrls);
+
+export const canonicalPath = (
+  target: string,
+  config: LocalizedPathsConfig,
+): string => {
+  const { pathname, search, hash } = splitUrlTarget(target);
+  return `${canonicalTargetPathname(pathname, config.languages, config.localisedUrls)}${search}${hash}`;
+};