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

package/src/localisedUrls/patterns.ts

@@ -1,283 +0,0 @@
-import { normalisePathname, normalisePathPattern } from './normalise';
-
-const escapeRegExp = (value: string): string =>
-  value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-
-const getParamName = (segment: string): string =>
-  segment.slice(1).replace(/\?$/, '');
-
-export const getOrderedPathParamSignature = (pattern: string): string[] =>
-  normalisePathPattern(pattern)
-    .split('/')
-    .filter(Boolean)
-    .flatMap(segment => {
-      if (segment === '*') {
-        return ['*'];
-      }
-      if (!segment.startsWith(':')) {
-        return [];
-      }
-
-      return [`:${getParamName(segment)}${segment.endsWith('?') ? '?' : ''}`];
-    });
-
-export const getPathParamSignature = (pattern: string): string[] =>
-  getOrderedPathParamSignature(pattern).sort((left, right) =>
-    left < right ? -1 : left > right ? 1 : 0,
-  );
-
-export const getPathPatternValidationIssue = (
-  pattern: string,
-): string | undefined => {
-  const segments = normalisePathPattern(pattern).split('/').filter(Boolean);
-  const seenParams = new Set<string>();
-
-  for (const [index, segment] of segments.entries()) {
-    if (segment === '*') {
-      if (index !== segments.length - 1) {
-        return 'splat parameter "*" must be the final segment';
-      }
-      if (seenParams.has('*')) {
-        return 'duplicate splat parameter "*"';
-      }
-      seenParams.add('*');
-      continue;
-    }
-    if (!segment.startsWith(':')) {
-      continue;
-    }
-
-    const paramName = getParamName(segment);
-    if (seenParams.has(paramName)) {
-      return `duplicate path parameter ":${paramName}"`;
-    }
-    seenParams.add(paramName);
-  }
-
-  return undefined;
-};
-
-export const getPhysicalPathPattern = (pattern: string): string => {
-  const segments = normalisePathPattern(pattern).split('/').filter(Boolean);
-  const physicalSegments = segments.map(segment => {
-    if (segment === '*') {
-      return '*';
-    }
-    if (segment.startsWith(':')) {
-      return segment.endsWith('?') ? ':param?' : ':param';
-    }
-    return segment;
-  });
-
-  return `/${physicalSegments.join('/')}`;
-};
-
-interface CompiledPathPattern {
-  names: string[];
-  regexp: RegExp;
-}
-
-const compiledPathPatternCache = new Map<string, CompiledPathPattern>();
-
-const compilePathPattern = (pattern: string): CompiledPathPattern => {
-  const normalizedPattern = normalisePathPattern(pattern);
-  const cached = compiledPathPatternCache.get(normalizedPattern);
-  if (cached) {
-    return cached;
-  }
-
-  const names: string[] = [];
-  const segments = normalizedPattern.split('/').filter(Boolean);
-  const source = segments
-    .map(segment => {
-      if (segment.startsWith(':')) {
-        names.push(getParamName(segment));
-        const paramPattern = '([^/]+)';
-        return segment.endsWith('?')
-          ? `(?:/${paramPattern})?`
-          : `/${paramPattern}`;
-      }
-      if (segment === '*') {
-        names.push('*');
-        return '(?:/(.*))?';
-      }
-      return `/${escapeRegExp(segment)}`;
-    })
-    .join('');
-
-  const compiled = {
-    names,
-    regexp: new RegExp(`^${source || '/'}$`),
-  };
-  compiledPathPatternCache.set(normalizedPattern, compiled);
-
-  return compiled;
-};
-
-const getPatternSpecificity = (pattern: string) => {
-  const segments = normalisePathPattern(pattern).split('/').filter(Boolean);
-  let staticSegments = 0;
-  let dynamicSegments = 0;
-  let optionalSegments = 0;
-  let splatSegments = 0;
-
-  for (const segment of segments) {
-    if (segment === '*') {
-      splatSegments++;
-    } else if (segment.startsWith(':')) {
-      dynamicSegments++;
-      if (segment.endsWith('?')) {
-        optionalSegments++;
-      }
-    } else {
-      staticSegments++;
-    }
-  }
-
-  return {
-    staticSegments,
-    dynamicSegments,
-    optionalSegments,
-    splatSegments,
-    totalSegments: segments.length,
-  };
-};
-
-const comparePatternSpecificity = (left: string, right: string): number => {
-  const a = getPatternSpecificity(left);
-  const b = getPatternSpecificity(right);
-
-  return (
-    b.staticSegments - a.staticSegments ||
-    a.splatSegments - b.splatSegments ||
-    a.optionalSegments - b.optionalSegments ||
-    b.totalSegments - a.totalSegments ||
-    a.dynamicSegments - b.dynamicSegments
-  );
-};
-
-export const haveEqualPatternSpecificity = (
-  left: string,
-  right: string,
-): boolean => comparePatternSpecificity(left, right) === 0;
-
-export const doPathPatternsOverlap = (left: string, right: string): boolean => {
-  const leftSegments = normalisePathPattern(left).split('/').filter(Boolean);
-  const rightSegments = normalisePathPattern(right).split('/').filter(Boolean);
-  if (leftSegments.length !== rightSegments.length) {
-    return false;
-  }
-
-  return leftSegments.every((leftSegment, index) => {
-    const rightSegment = rightSegments[index];
-    const leftIsDynamic = leftSegment === '*' || leftSegment.startsWith(':');
-    const rightIsDynamic = rightSegment === '*' || rightSegment.startsWith(':');
-    return leftIsDynamic || rightIsDynamic || leftSegment === rightSegment;
-  });
-};
-
-const comparePatternNames = (left: string, right: string): number => {
-  const normalizedLeft = normalisePathPattern(left);
-  const normalizedRight = normalisePathPattern(right);
-
-  return normalizedLeft < normalizedRight
-    ? -1
-    : normalizedLeft > normalizedRight
-      ? 1
-      : 0;
-};
-
-export const sortPatternsBySpecificity = <T extends { pattern: string }>(
-  patterns: T[],
-): T[] =>
-  patterns
-    .map((pattern, index) => ({ pattern, index }))
-    .sort(
-      (left, right) =>
-        comparePatternSpecificity(
-          left.pattern.pattern,
-          right.pattern.pattern,
-        ) ||
-        comparePatternNames(left.pattern.pattern, right.pattern.pattern) ||
-        left.index - right.index,
-    )
-    .map(({ pattern }) => pattern);
-
-/**
- * `decodeURIComponent` throws `URIError` on malformed percent-encoding
- * (e.g. `%E0%A4%A`), which attacker-controlled request URLs can carry.
- * Treat such segments as undecodable instead of throwing.
- */
-const decodePathParam = (value: string): string | null => {
-  try {
-    return decodeURIComponent(value);
-  } catch {
-    return null;
-  }
-};
-
-const encodeSplatParam = (value: string): string =>
-  value.split('/').map(encodeURIComponent).join('/');
-
-export const matchPathPattern = (
-  pathname: string,
-  pattern: string,
-): Record<string, string> | null => {
-  const { names, regexp } = compilePathPattern(pattern);
-  const match = regexp.exec(normalisePathname(pathname));
-  if (!match) {
-    return null;
-  }
-
-  const params: Record<string, string> = {};
-  for (let index = 0; index < names.length; index++) {
-    const decoded = decodePathParam(match[index + 1] || '');
-    if (decoded === null) {
-      // Malformed encoding cannot identify a localised route: no match.
-      return null;
-    }
-    Object.defineProperty(params, names[index], {
-      configurable: true,
-      enumerable: true,
-      value: decoded,
-      writable: true,
-    });
-  }
-
-  return params;
-};
-
-export const buildPathFromPattern = (
-  pattern: string,
-  params: Record<string, string>,
-): string => {
-  const segments = normalisePathPattern(pattern).split('/').filter(Boolean);
-  const path = segments
-    .map(segment => {
-      if (segment.startsWith(':')) {
-        const paramName = getParamName(segment);
-        const param = Object.hasOwn(params, paramName)
-          ? params[paramName]
-          : undefined;
-        if (param === undefined || param === '') {
-          if (segment.endsWith('?')) {
-            return '';
-          }
-          throw new Error(
-            `Missing required path parameter "${paramName}" for pattern "${normalisePathPattern(
-              pattern,
-            )}".`,
-          );
-        }
-        return encodeURIComponent(param);
-      }
-      if (segment === '*') {
-        return encodeSplatParam(params['*'] || '');
-      }
-      return segment;
-    })
-    .filter(Boolean)
-    .join('/');
-
-  return `/${path}`;
-};

package/src/localisedUrls/redirect.ts

@@ -1,107 +0,0 @@
-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)$/,
-    },
-    { 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

@@ -1,106 +0,0 @@
-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

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