@bleedingdev/modern-js-plugin-i18n 3.5.0-ultramodern.30 → 3.5.0-ultramodern.31

package/src/server/redirectPolicy.ts

@@ -0,0 +1,152 @@
+import { localiseTargetPathname } from '../shared/localisedUrls.js';
+import type { LocaleDetectionOptions } from '../shared/type';
+
+/**
+ * Check if the given pathname should ignore automatic locale redirect
+ */
+export const shouldIgnoreRedirect = (
+  pathname: string,
+  urlPath: string,
+  ignoreRedirectRoutes?: string[] | ((pathname: string) => boolean),
+): boolean => {
+  if (!ignoreRedirectRoutes) {
+    return false;
+  }
+
+  // Remove urlPath prefix to get remaining path for matching
+  const basePath = urlPath.replace('/*', '');
+  const remainingPath = pathname.startsWith(basePath)
+    ? pathname.slice(basePath.length)
+    : pathname;
+
+  // Normalize path (ensure it starts with /)
+  const normalizedPath = remainingPath.startsWith('/')
+    ? remainingPath
+    : `/${remainingPath}`;
+
+  if (typeof ignoreRedirectRoutes === 'function') {
+    return ignoreRedirectRoutes(normalizedPath);
+  }
+
+  // Check if pathname matches any of the ignore patterns
+  return ignoreRedirectRoutes.some(pattern => {
+    // Support both exact match and prefix match
+    return (
+      normalizedPath === pattern || normalizedPath.startsWith(`${pattern}/`)
+    );
+  });
+};
+
+/**
+ * Check if the given pathname is a static resource request
+ * This includes:
+ * 1. Paths matching staticRoutePrefixes (from public directories)
+ * 2. Standard static resource paths like /static/, /upload/
+ * 3. Paths with language prefix like /en/static/, /zh/static/
+ */
+export const isStaticResourceRequest = (
+  pathname: string,
+  staticRoutePrefixes: string[],
+  languages: string[] = [],
+): boolean => {
+  // Check against staticRoutePrefixes (from public directories)
+  if (
+    staticRoutePrefixes.some(
+      prefix => pathname.startsWith(`${prefix}/`) || pathname === prefix,
+    )
+  ) {
+    return true;
+  }
+
+  // Check standard static resource paths
+  const standardStaticPrefixes = ['/static/', '/upload/'];
+  if (standardStaticPrefixes.some(prefix => pathname.startsWith(prefix))) {
+    return true;
+  }
+
+  // Check paths with language prefix (e.g., /en/static/, /zh/static/)
+  // Remove language prefix if present and check again
+  const pathSegments = pathname.split('/').filter(Boolean);
+  if (pathSegments.length > 0 && languages.includes(pathSegments[0])) {
+    const pathWithoutLang = '/' + pathSegments.slice(1).join('/');
+    if (
+      standardStaticPrefixes.some(prefix =>
+        pathWithoutLang.startsWith(prefix),
+      ) ||
+      staticRoutePrefixes.some(
+        prefix =>
+          pathWithoutLang.startsWith(`${prefix}/`) ||
+          pathWithoutLang === prefix,
+      )
+    ) {
+      return true;
+    }
+  }
+
+  return false;
+};
+
+export const getLanguageFromPath = (
+  req: any,
+  urlPath: string,
+  languages: string[],
+): string | null => {
+  const url = new URL(req.url, `http://${req.header().host}`);
+  const pathname = url.pathname;
+
+  // Remove urlPath prefix to get remaining path
+  // urlPath format is /lang/*, need to remove /lang part
+  const basePath = urlPath.replace('/*', '');
+  const remainingPath = pathname.startsWith(basePath)
+    ? pathname.slice(basePath.length)
+    : pathname;
+
+  const segments = remainingPath.split('/').filter(Boolean);
+  const firstSegment = segments[0];
+
+  if (languages.includes(firstSegment)) {
+    return firstSegment;
+  }
+
+  return null;
+};
+
+export const buildLocalizedUrl = (
+  req: any,
+  urlPath: string,
+  language: string,
+  languages: string[],
+  localisedUrls?: LocaleDetectionOptions['localisedUrls'],
+): string => {
+  const url = new URL(req.url);
+  const pathname = url.pathname;
+
+  // Remove urlPath prefix to get remaining path
+  const basePath = urlPath.replace('/*', '');
+  const remainingPath = pathname.startsWith(basePath)
+    ? pathname.slice(basePath.length)
+    : pathname;
+
+  const newPathname = localiseTargetPathname(
+    remainingPath,
+    language,
+    languages,
+    localisedUrls,
+  );
+  // Handle root path case to avoid double slashes like //en
+  const suffix = `${url.search}${url.hash}`;
+  const localizedUrl =
+    basePath === '/' ? newPathname + suffix : basePath + newPathname + suffix;
+
+  return localizedUrl;
+};
+
+export const createLocaleRedirectResponse = (location: string): Response =>
+  new Response(null, {
+    status: 302,
+    headers: {
+      'Cache-Control': 'private, no-store',
+      Location: location,
+      Vary: 'Accept-Language, Cookie',
+    },
+  });

package/src/shared/localisedUrls/config.ts

@@ -0,0 +1,18 @@
+import type { LocalisedUrlsOption, ResolvedLocalisedUrlsConfig } from './types';
+
+/**
+ * Localised URLs are strictly opt-in: only an explicit, non-empty map enables
+ * route expansion and validation. `true`, `false`, an empty map and absence
+ * all resolve to disabled, so upstream-style configs (`localePathRedirect` +
+ * `languages` without a map) keep plain locale-prefix behavior instead of
+ * failing the build for every route missing from a map they never wrote.
+ */
+export const resolveLocalisedUrlsConfig = (
+  option: LocalisedUrlsOption | undefined,
+): ResolvedLocalisedUrlsConfig => {
+  if (option && typeof option === 'object' && Object.keys(option).length > 0) {
+    return { enabled: true, map: option };
+  }
+
+  return { enabled: false, map: {} };
+};

package/src/shared/localisedUrls/index.ts

@@ -0,0 +1,13 @@
+export { resolveLocalisedUrlsConfig } from './config';
+export { normalisePathname, normalisePathPattern } from './normalise';
+export { canonicalTargetPathname, localiseTargetPathname } from './pathname';
+export { buildPathFromPattern, matchPathPattern } from './patterns';
+export { resolveCanonicalLocalisedPath, resolveLocalisedPath } from './resolve';
+export { applyLocalisedUrlsToRoutes, validateLocalisedUrls } from './routes';
+export type {
+  LocalisedRoute,
+  LocalisedUrlPathMap,
+  LocalisedUrlsMap,
+  LocalisedUrlsOption,
+  ResolvedLocalisedUrlsConfig,
+} from './types';

package/src/shared/localisedUrls/normalise.ts

@@ -0,0 +1,67 @@
+const LOCALE_PARAM_NAMES = new Set(['lang', 'locale', 'language']);
+
+const normaliseSlashes = (path: string): string => {
+  const withoutDuplicateSlashes = path.replace(/\/+/g, '/');
+  const withLeadingSlash = withoutDuplicateSlashes.startsWith('/')
+    ? withoutDuplicateSlashes
+    : `/${withoutDuplicateSlashes}`;
+
+  return withLeadingSlash.length > 1
+    ? withLeadingSlash.replace(/\/+$/, '')
+    : withLeadingSlash;
+};
+
+export const normalisePathPattern = (path: string): string =>
+  normaliseSlashes(path).replace(/\[(.+?)\]/g, ':$1');
+
+/**
+ * Normalise a concrete request pathname: slash cleanup only. Unlike
+ * {@link normalisePathPattern} it must not rewrite literal `[x]` segments to
+ * `:x` params — pathnames are values, not patterns.
+ */
+export const normalisePathname = (pathname: string): string =>
+  normaliseSlashes(pathname);
+
+export const normaliseRoutePath = (path: string): string => {
+  const normalized = normalisePathPattern(path);
+  return normalized === '/' ? '' : normalized.slice(1);
+};
+
+const getLocaleParamSegment = (segment: string): string | null => {
+  if (!segment.startsWith(':')) {
+    return null;
+  }
+
+  const paramName = segment.slice(1).replace(/\?$/, '');
+  return LOCALE_PARAM_NAMES.has(paramName) ? segment : null;
+};
+
+const splitPathSegments = (path?: string): string[] => {
+  if (!path) {
+    return [];
+  }
+
+  return normalisePathPattern(path).split('/').filter(Boolean);
+};
+
+export const stripLeadingLocaleParam = (path?: string): string | undefined => {
+  const segments = splitPathSegments(path);
+  const leadingLocaleParam = getLocaleParamSegment(segments[0] || '');
+
+  if (!leadingLocaleParam) {
+    return path;
+  }
+
+  const remainingPath = segments.slice(1).join('/');
+  return remainingPath ? `/${remainingPath}` : undefined;
+};
+
+export const getLeadingLocaleParam = (path?: string): string | null => {
+  const segments = splitPathSegments(path);
+  return getLocaleParamSegment(segments[0] || '');
+};
+
+const isLocaleParamPath = (path?: string): boolean => {
+  const segments = splitPathSegments(path);
+  return segments.length === 1 && Boolean(getLocaleParamSegment(segments[0]));
+};

package/src/shared/localisedUrls/pathname.ts

@@ -0,0 +1,57 @@
+import { resolveLocalisedUrlsConfig } from './config';
+
+import { resolveCanonicalLocalisedPath, resolveLocalisedPath } from './resolve';
+
+import type { LocalisedUrlsOption } from './types';
+
+const stripLanguagePrefix = (pathname: string, languages: string[]): string => {
+  const segments = pathname.split('/').filter(Boolean);
+  const firstSegment = segments[0]?.toLowerCase();
+
+  if (
+    firstSegment &&
+    languages.some(language => language.toLowerCase() === firstSegment)
+  ) {
+    return `/${segments.slice(1).join('/')}`;
+  }
+
+  return pathname || '/';
+};
+
+export const localiseTargetPathname = (
+  pathname: string,
+  language: string,
+  languages: string[],
+  localisedUrls?: LocalisedUrlsOption,
+): string => {
+  const pathWithoutLanguage = stripLanguagePrefix(pathname, languages);
+  const localisedUrlsConfig = resolveLocalisedUrlsConfig(localisedUrls);
+  const resolvedPath = localisedUrlsConfig.enabled
+    ? resolveLocalisedPath(
+        pathWithoutLanguage,
+        language,
+        languages,
+        localisedUrlsConfig.map,
+      )
+    : pathWithoutLanguage;
+  const resolvedSegments = resolvedPath.split('/').filter(Boolean);
+
+  return `/${[language, ...resolvedSegments].join('/')}`;
+};
+
+export const canonicalTargetPathname = (
+  pathname: string,
+  languages: string[],
+  localisedUrls?: LocalisedUrlsOption,
+): string => {
+  const pathWithoutLanguage = stripLanguagePrefix(pathname, languages);
+  const localisedUrlsConfig = resolveLocalisedUrlsConfig(localisedUrls);
+
+  return localisedUrlsConfig.enabled
+    ? resolveCanonicalLocalisedPath(
+        pathWithoutLanguage,
+        languages,
+        localisedUrlsConfig.map,
+      )
+    : pathWithoutLanguage;
+};

package/src/shared/localisedUrls/patterns.ts

@@ -0,0 +1,160 @@
+import { normalisePathname, normalisePathPattern } from './normalise';
+
+const escapeRegExp = (value: string): string =>
+  value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+
+const getParamName = (segment: string): string =>
+  segment.slice(1).replace(/\?$/, '');
+
+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 splatSegments = 0;
+
+  for (const segment of segments) {
+    if (segment === '*') {
+      splatSegments++;
+    } else if (segment.startsWith(':')) {
+      dynamicSegments++;
+    } else {
+      staticSegments++;
+    }
+  }
+
+  return {
+    staticSegments,
+    dynamicSegments,
+    splatSegments,
+    totalSegments: segments.length,
+  };
+};
+
+const comparePatternSpecificity = (left: string, right: string): number => {
+  const a = getPatternSpecificity(left);
+  const b = getPatternSpecificity(right);
+
+  return (
+    b.staticSegments - a.staticSegments ||
+    b.totalSegments - a.totalSegments ||
+    a.splatSegments - b.splatSegments ||
+    a.dynamicSegments - b.dynamicSegments
+  );
+};
+
+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,
+        ) || 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;
+    }
+    params[names[index]] = decoded;
+  }
+
+  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 param = params[getParamName(segment)];
+        return param ? encodeURIComponent(param) : '';
+      }
+      if (segment === '*') {
+        return encodeSplatParam(params['*'] || '');
+      }
+      return segment;
+    })
+    .filter(Boolean)
+    .join('/');
+
+  return `/${path}`;
+};

package/src/shared/localisedUrls/resolve.ts

@@ -0,0 +1,118 @@
+import { normalisePathname } from './normalise';
+
+import {
+  buildPathFromPattern,
+  matchPathPattern,
+  sortPatternsBySpecificity,
+} from './patterns';
+
+import type { LocalisedUrlsMap } from './types';
+
+export const resolveLocalisedPath = (
+  pathname: string,
+  targetLanguage: string,
+  languages: string[],
+  localisedUrls: LocalisedUrlsMap,
+): string => {
+  const normalizedPathname = normalisePathname(pathname);
+
+  // Canonical keys take precedence: authors write language-agnostic paths,
+  // which are the map keys, even when no language pattern equals the key.
+  const canonicalCandidates = sortPatternsBySpecificity(
+    Object.entries(localisedUrls).map(
+      ([canonicalPattern, localisedUrlEntry]) => ({
+        pattern: canonicalPattern,
+        canonicalPattern,
+        localisedUrlEntry,
+      }),
+    ),
+  );
+
+  for (const { canonicalPattern, localisedUrlEntry } of canonicalCandidates) {
+    const targetPattern = localisedUrlEntry[targetLanguage];
+    if (!targetPattern) {
+      continue;
+    }
+
+    const params = matchPathPattern(normalizedPathname, canonicalPattern);
+    if (params) {
+      return buildPathFromPattern(targetPattern, params);
+    }
+  }
+
+  const localisedCandidates = sortPatternsBySpecificity(
+    Object.values(localisedUrls).flatMap(localisedUrlEntry => {
+      const targetPattern = localisedUrlEntry[targetLanguage];
+      if (!targetPattern) {
+        return [];
+      }
+
+      return languages
+        .map(language => localisedUrlEntry[language])
+        .filter((sourcePattern): sourcePattern is string =>
+          Boolean(sourcePattern),
+        )
+        .map(sourcePattern => ({
+          pattern: sourcePattern,
+          sourcePattern,
+          targetPattern,
+        }));
+    }),
+  );
+
+  for (const { sourcePattern, targetPattern } of localisedCandidates) {
+    const params = matchPathPattern(normalizedPathname, sourcePattern);
+    if (params) {
+      return buildPathFromPattern(targetPattern, params);
+    }
+  }
+
+  return normalizedPathname;
+};
+
+/**
+ * Reverse-map a language-specific pathname (without language prefix) back to
+ * the canonical, language-agnostic path: localized slug patterns are matched
+ * against every language variant and rebuilt from the canonical map key.
+ */
+export const resolveCanonicalLocalisedPath = (
+  pathname: string,
+  languages: string[],
+  localisedUrls: LocalisedUrlsMap,
+): string => {
+  const normalizedPathname = normalisePathname(pathname);
+
+  const canonicalCandidates = sortPatternsBySpecificity(
+    Object.entries(localisedUrls).map(
+      ([canonicalPattern, localisedUrlEntry]) => ({
+        pattern: canonicalPattern,
+        canonicalPattern,
+        localisedUrlEntry,
+      }),
+    ),
+  );
+
+  for (const { canonicalPattern, localisedUrlEntry } of canonicalCandidates) {
+    const canonicalParams = matchPathPattern(
+      normalizedPathname,
+      canonicalPattern,
+    );
+    if (canonicalParams) {
+      return buildPathFromPattern(canonicalPattern, canonicalParams);
+    }
+
+    for (const language of languages) {
+      const sourcePattern = localisedUrlEntry[language];
+      if (!sourcePattern) {
+        continue;
+      }
+
+      const params = matchPathPattern(normalizedPathname, sourcePattern);
+      if (params) {
+        return buildPathFromPattern(canonicalPattern, params);
+      }
+    }
+  }
+
+  return normalizedPathname;
+};