@bleedingdev/modern-js-runtime-extensions 3.9.0-ultramodern.9 → 3.9.3-ultramodern.2

package/src/localisedUrls/redirect.ts

@@ -0,0 +1,110 @@
+import { normalisePathname } from './normalise';
+import { stripLanguagePrefix } from './pathname';
+
+export type LocaleRedirectSkipRule =
+  | {
+      type: 'exact';
+      path: string;
+    }
+  | {
+      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: '/mf-manifest.json' },
+    { type: 'exact', path: '/mf-stats.json' },
+    {
+      type: 'pattern',
+      path: /^\/(?:backendRemoteEntry(?:\.[a-zA-Z0-9_-]+)?\.cjs|remoteEntry(?:\.[a-zA-Z0-9_-]+)?\.js)$/,
+    },
+    // The static server admits only the container assets named by its
+    // manifest; locale middleware must not redirect their Node chunk URLs.
+    { type: 'pattern', path: /^\/bundles\/(?:[^/]+\/)*[^/]+\.(?:js|cjs|mjs)$/ },
+    { type: 'prefix', path: '/static/' },
+    { type: 'prefix', path: '/upload/' },
+  ];
+
+const stripTrailingSlash = (pathname: string): string =>
+  pathname.length > 1 ? pathname.replace(/\/+$/, '') : pathname;
+
+export const matchesPathPrefix = (
+  pathname: string,
+  prefix: string,
+): boolean => {
+  const normalizedPathname = normalisePathname(pathname);
+  const normalizedPrefix = stripTrailingSlash(normalisePathname(prefix));
+
+  return (
+    normalizedPathname === normalizedPrefix ||
+    normalizedPathname.startsWith(`${normalizedPrefix}/`)
+  );
+};
+
+const matchesSkipRule = (
+  pathname: string,
+  rule: LocaleRedirectSkipRule,
+): boolean => {
+  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);
+};
+
+export const isDefaultLocaleRedirectSkipPath = (
+  pathname: string,
+  languages: string[] = [],
+): boolean => {
+  const normalizedPathname = normalisePathname(pathname);
+  const pathWithoutLanguage = stripLanguagePrefix(
+    normalizedPathname,
+    languages,
+  );
+
+  return DEFAULT_LOCALE_REDIRECT_SKIP_RULES.some(rule =>
+    matchesSkipRule(pathWithoutLanguage, rule),
+  );
+};
+
+export const shouldSkipLocaleRedirect = (
+  pathname: string,
+  languages: string[] = [],
+  ignoreRedirectRoutes?: string[] | ((pathname: string) => boolean),
+): boolean => {
+  const normalizedPathname = normalisePathname(pathname);
+  const pathWithoutLanguage = stripLanguagePrefix(
+    normalizedPathname,
+    languages,
+  );
+
+  if (isDefaultLocaleRedirectSkipPath(pathWithoutLanguage)) {
+    return true;
+  }
+
+  if (!ignoreRedirectRoutes) {
+    return false;
+  }
+
+  if (typeof ignoreRedirectRoutes === 'function') {
+    return ignoreRedirectRoutes(pathWithoutLanguage);
+  }
+
+  return ignoreRedirectRoutes.some(pattern =>
+    matchesPathPrefix(pathWithoutLanguage, pattern),
+  );
+};

package/src/localisedUrls/resolve.ts

@@ -0,0 +1,106 @@
+import { normalisePathname } from './normalise';
+
+import {
+  buildPathFromPattern,
+  matchPathPattern,
+  sortPatternsBySpecificity,
+} from './patterns';
+
+import type { LocalisedUrlsMap } from './types';
+
+type CanonicalCandidate = {
+  pattern: string;
+  canonicalPattern: string;
+  localisedUrlEntry: LocalisedUrlsMap[string];
+};
+
+type ResolveLocalisedUrlPathOptions =
+  | {
+      mode: 'localised';
+      targetLanguage: string;
+    }
+  | {
+      mode: 'canonical';
+    };
+
+const getCanonicalCandidates = (
+  localisedUrls: LocalisedUrlsMap,
+): CanonicalCandidate[] =>
+  sortPatternsBySpecificity(
+    Object.entries(localisedUrls).map(
+      ([canonicalPattern, localisedUrlEntry]) => ({
+        pattern: canonicalPattern,
+        canonicalPattern,
+        localisedUrlEntry,
+      }),
+    ),
+  );
+
+const resolveLocalisedUrlPath = (
+  pathname: string,
+  languages: string[],
+  localisedUrls: LocalisedUrlsMap,
+  options: ResolveLocalisedUrlPathOptions,
+): string => {
+  const normalizedPathname = normalisePathname(pathname);
+  const canonicalCandidates = getCanonicalCandidates(localisedUrls);
+
+  const candidates = sortPatternsBySpecificity(
+    canonicalCandidates.flatMap(({ canonicalPattern, localisedUrlEntry }) => {
+      const targetPattern =
+        options.mode === 'localised'
+          ? localisedUrlEntry[options.targetLanguage]
+          : canonicalPattern;
+      if (!targetPattern) {
+        return [];
+      }
+
+      const sourcePatterns = new Set([
+        canonicalPattern,
+        ...languages
+          .map(language => localisedUrlEntry[language])
+          .filter((sourcePattern): sourcePattern is string =>
+            Boolean(sourcePattern),
+          ),
+      ]);
+      return Array.from(sourcePatterns, sourcePattern => ({
+        pattern: sourcePattern,
+        sourcePattern,
+        targetPattern,
+      }));
+    }),
+  );
+
+  for (const { sourcePattern, targetPattern } of candidates) {
+    const params = matchPathPattern(normalizedPathname, sourcePattern);
+    if (params) {
+      return buildPathFromPattern(targetPattern, params);
+    }
+  }
+
+  return normalizedPathname;
+};
+
+export const resolveLocalisedPath = (
+  pathname: string,
+  targetLanguage: string,
+  languages: string[],
+  localisedUrls: LocalisedUrlsMap,
+): string =>
+  resolveLocalisedUrlPath(pathname, languages, localisedUrls, {
+    mode: 'localised',
+    targetLanguage,
+  });
+
+/**
+ * Reverse-map language-specific pathnames back to language-agnostic
+ * LocalisedUrlsMap keys.
+ */
+export const resolveCanonicalLocalisedPath = (
+  pathname: string,
+  languages: string[],
+  localisedUrls: LocalisedUrlsMap,
+): string =>
+  resolveLocalisedUrlPath(pathname, languages, localisedUrls, {
+    mode: 'canonical',
+  });

package/src/localisedUrls/routeIdentity.ts

@@ -0,0 +1,83 @@
+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;
+}
+
+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(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),
+  };
+}