@bleedingdev/modern-js-plugin-i18n 3.5.0-ultramodern.36 → 3.5.0-ultramodern.37

package/src/server/redirectPolicy.ts

@@ -1,106 +1,86 @@
-import { localiseTargetPathname } from '../shared/localisedUrls.js';
+import {
+  isDefaultLocaleRedirectSkipPath,
+  localiseTargetPathname,
+  matchesPathPrefix,
+  shouldSkipLocaleRedirect,
+  stripLanguagePrefix,
+} 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;
-  }
+interface LocaleRedirectRequest {
+  url: string;
+  header: () => {
+    host?: string;
+  };
+}
 
-  // Remove urlPath prefix to get remaining path for matching
+const stripUrlPathPrefix = (pathname: string, urlPath: string): string => {
   const basePath = urlPath.replace('/*', '');
+
+  if (!basePath || basePath === '/') {
+    return pathname;
+  }
+
   const remainingPath = pathname.startsWith(basePath)
     ? pathname.slice(basePath.length)
     : pathname;
 
-  // Normalize path (ensure it starts with /)
-  const normalizedPath = remainingPath.startsWith('/')
-    ? remainingPath
-    : `/${remainingPath}`;
+  return remainingPath || '/';
+};
 
-  if (typeof ignoreRedirectRoutes === 'function') {
-    return ignoreRedirectRoutes(normalizedPath);
-  }
+/**
+ * Check if pathname should ignore automatic locale redirect.
+ */
+export const shouldIgnoreRedirect = (
+  pathname: string,
+  urlPath: string,
+  ignoreRedirectRoutes?: string[] | ((pathname: string) => boolean),
+): boolean => {
+  const remainingPath = stripUrlPathPrefix(pathname, urlPath);
 
-  // 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}/`)
-    );
-  });
+  return shouldSkipLocaleRedirect(remainingPath, [], ignoreRedirectRoutes);
 };
 
 /**
- * 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/
+ * Check if pathname is a static or federation resource request.
+ *
+ * This includes configured staticRoutePrefixes, the shared default skip policy
+ * from ADR-0002, and language-prefixed variants such as /en/static/app.js.
  */
 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,
-    )
-  ) {
+  if (isDefaultLocaleRedirectSkipPath(pathname, languages)) {
     return true;
   }
 
-  // Check standard static resource paths
-  const standardStaticPrefixes = ['/static/', '/upload/'];
-  if (standardStaticPrefixes.some(prefix => pathname.startsWith(prefix))) {
+  const matchesStaticRoutePrefix = (targetPathname: string): boolean =>
+    staticRoutePrefixes.some(prefix =>
+      matchesPathPrefix(targetPathname, prefix),
+    );
+
+  if (matchesStaticRoutePrefix(pathname)) {
     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;
-    }
-  }
+  const pathWithoutLanguage = stripLanguagePrefix(pathname, languages);
 
-  return false;
+  return (
+    pathWithoutLanguage !== pathname &&
+    matchesStaticRoutePrefix(pathWithoutLanguage)
+  );
 };
 
 export const getLanguageFromPath = (
-  req: any,
+  req: LocaleRedirectRequest,
   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 remainingPath = stripUrlPathPrefix(pathname, urlPath);
   const segments = remainingPath.split('/').filter(Boolean);
   const firstSegment = segments[0];
 
@@ -112,7 +92,7 @@ export const getLanguageFromPath = (
 };
 
 export const buildLocalizedUrl = (
-  req: any,
+  req: LocaleRedirectRequest,
   urlPath: string,
   language: string,
   languages: string[],
@@ -120,12 +100,8 @@ export const buildLocalizedUrl = (
 ): 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 remainingPath = stripUrlPathPrefix(pathname, urlPath);
 
   const newPathname = localiseTargetPathname(
     remainingPath,
@@ -133,7 +109,6 @@ export const buildLocalizedUrl = (
     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;

package/src/shared/detection.ts

@@ -8,7 +8,7 @@ import type { LanguageDetectorOptions } from '../runtime/i18n/instance';
  * Detect language from request using the same detection logic as i18next
  * This ensures consistency between server-side and client-side detection
  */
-export function detectLanguageFromRequest(
+function detectLanguageFromRequest(
   req: {
     url: string;
     headers:

package/src/shared/localisedUrls/index.ts

@@ -1,7 +1,18 @@
 export { resolveLocalisedUrlsConfig } from './config';
 export { normalisePathname, normalisePathPattern } from './normalise';
-export { canonicalTargetPathname, localiseTargetPathname } from './pathname';
+export {
+  canonicalTargetPathname,
+  localiseTargetPathname,
+  stripLanguagePrefix,
+} from './pathname';
 export { buildPathFromPattern, matchPathPattern } from './patterns';
+export type { LocaleRedirectSkipRule } from './redirect';
+export {
+  DEFAULT_LOCALE_REDIRECT_SKIP_RULES,
+  isDefaultLocaleRedirectSkipPath,
+  matchesPathPrefix,
+  shouldSkipLocaleRedirect,
+} from './redirect';
 export { resolveCanonicalLocalisedPath, resolveLocalisedPath } from './resolve';
 export { applyLocalisedUrlsToRoutes, validateLocalisedUrls } from './routes';
 export type {

package/src/shared/localisedUrls/pathname.ts

@@ -4,7 +4,10 @@ import { resolveCanonicalLocalisedPath, resolveLocalisedPath } from './resolve';
 
 import type { LocalisedUrlsOption } from './types';
 
-const stripLanguagePrefix = (pathname: string, languages: string[]): string => {
+export const stripLanguagePrefix = (
+  pathname: string,
+  languages: string[],
+): string => {
   const segments = pathname.split('/').filter(Boolean);
   const firstSegment = segments[0]?.toLowerCase();
 

package/src/shared/localisedUrls/redirect.ts

@@ -0,0 +1,91 @@
+import { normalisePathname } from './normalise';
+import { stripLanguagePrefix } from './pathname';
+
+export type LocaleRedirectSkipRule =
+  | {
+      type: 'exact';
+      path: string;
+    }
+  | {
+      type: 'prefix';
+      path: string;
+    };
+
+export const DEFAULT_LOCALE_REDIRECT_SKIP_RULES: readonly LocaleRedirectSkipRule[] =
+  [
+    { type: 'exact', path: '/mf-manifest.json' },
+    { type: 'exact', path: '/mf-stats.json' },
+    { type: 'exact', path: '/remoteEntry.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);
+  }
+
+  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/shared/localisedUrls/resolve.ts

@@ -8,17 +8,25 @@ import {
 
 import type { LocalisedUrlsMap } from './types';
 
-export const resolveLocalisedPath = (
-  pathname: string,
-  targetLanguage: string,
-  languages: string[],
-  localisedUrls: LocalisedUrlsMap,
-): string => {
-  const normalizedPathname = normalisePathname(pathname);
+type CanonicalCandidate = {
+  pattern: string;
+  canonicalPattern: string;
+  localisedUrlEntry: LocalisedUrlsMap[string];
+};
 
-  // 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(
+type ResolveLocalisedUrlPathOptions =
+  | {
+      mode: 'localised';
+      targetLanguage: string;
+    }
+  | {
+      mode: 'canonical';
+    };
+
+const getCanonicalCandidates = (
+  localisedUrls: LocalisedUrlsMap,
+): CanonicalCandidate[] =>
+  sortPatternsBySpecificity(
     Object.entries(localisedUrls).map(
       ([canonicalPattern, localisedUrlEntry]) => ({
         pattern: canonicalPattern,
@@ -28,91 +36,100 @@ export const resolveLocalisedPath = (
     ),
   );
 
-  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 = (
+const resolveLocalisedUrlPath = (
   pathname: string,
   languages: string[],
   localisedUrls: LocalisedUrlsMap,
+  options: ResolveLocalisedUrlPathOptions,
 ): string => {
   const normalizedPathname = normalisePathname(pathname);
-
-  const canonicalCandidates = sortPatternsBySpecificity(
-    Object.entries(localisedUrls).map(
-      ([canonicalPattern, localisedUrlEntry]) => ({
-        pattern: canonicalPattern,
-        canonicalPattern,
-        localisedUrlEntry,
-      }),
-    ),
-  );
+  const canonicalCandidates = getCanonicalCandidates(localisedUrls);
 
   for (const { canonicalPattern, localisedUrlEntry } of canonicalCandidates) {
+    const targetPattern =
+      options.mode === 'localised'
+        ? localisedUrlEntry[options.targetLanguage]
+        : canonicalPattern;
+
+    if (!targetPattern) {
+      continue;
+    }
+
     const canonicalParams = matchPathPattern(
       normalizedPathname,
       canonicalPattern,
     );
     if (canonicalParams) {
-      return buildPathFromPattern(canonicalPattern, canonicalParams);
+      return buildPathFromPattern(targetPattern, canonicalParams);
     }
 
-    for (const language of languages) {
-      const sourcePattern = localisedUrlEntry[language];
-      if (!sourcePattern) {
-        continue;
+    if (options.mode === 'canonical') {
+      for (const language of languages) {
+        const sourcePattern = localisedUrlEntry[language];
+        if (!sourcePattern) {
+          continue;
+        }
+
+        const params = matchPathPattern(normalizedPathname, sourcePattern);
+        if (params) {
+          return buildPathFromPattern(canonicalPattern, params);
+        }
       }
+    }
+  }
 
+  if (options.mode === 'localised') {
+    const localisedCandidates = sortPatternsBySpecificity(
+      Object.values(localisedUrls).flatMap(localisedUrlEntry => {
+        const targetPattern = localisedUrlEntry[options.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(canonicalPattern, 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/shared/localisedUrls.ts

@@ -1,4 +1,5 @@
 export type {
+  LocaleRedirectSkipRule,
   LocalisedRoute,
   LocalisedUrlPathMap,
   LocalisedUrlsMap,
@@ -9,12 +10,17 @@ export {
   applyLocalisedUrlsToRoutes,
   buildPathFromPattern,
   canonicalTargetPathname,
+  DEFAULT_LOCALE_REDIRECT_SKIP_RULES,
+  isDefaultLocaleRedirectSkipPath,
   localiseTargetPathname,
+  matchesPathPrefix,
   matchPathPattern,
   normalisePathname,
   normalisePathPattern,
   resolveCanonicalLocalisedPath,
   resolveLocalisedPath,
   resolveLocalisedUrlsConfig,
+  shouldSkipLocaleRedirect,
+  stripLanguagePrefix,
   validateLocalisedUrls,
 } from './localisedUrls/index';

package/src/shared/utils.ts

@@ -5,7 +5,7 @@ import type {
   LocaleDetectionOptions,
 } from './type';
 
-export function getEntryConfig<T extends Record<string, any>>(
+function getEntryConfig<T extends Record<string, any>>(
   entryName: string,
   config: T,
   entryKey: string,
@@ -16,7 +16,7 @@ export function getEntryConfig<T extends Record<string, any>>(
   return entryConfigMap?.[entryName];
 }
 
-export function removeEntryConfigKey<T extends Record<string, any>>(
+function removeEntryConfigKey<T extends Record<string, any>>(
   config: T,
   entryKey: string,
 ): Omit<T, typeof entryKey> {

package/tests/redirectPolicy.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, test } from '@rstest/core';
+import { shouldIgnoreRedirect as shouldIgnoreRuntimeRedirect } from '../src/runtime/utils';
+import {
+  isStaticResourceRequest,
+  shouldIgnoreRedirect as shouldIgnoreServerRedirect,
+} from '../src/server/redirectPolicy';
+
+const languages = ['en', 'cs'];
+
+const defaultSkippedPaths = [
+  '/mf-manifest.json',
+  '/mf-stats.json',
+  '/remoteEntry.js',
+  '/static/app.js',
+  '/upload/avatar.png',
+];
+
+describe('locale redirect default skip policy', () => {
+  test('skips ADR-0002 Module Federation and static endpoints on the server', () => {
+    for (const pathname of defaultSkippedPaths) {
+      expect(isStaticResourceRequest(pathname, [], languages)).toBe(true);
+      expect(shouldIgnoreServerRedirect(pathname, '/', undefined)).toBe(true);
+    }
+  });
+
+  test('skips language-prefixed static and upload endpoints', () => {
+    expect(isStaticResourceRequest('/cs/static/app.js', [], languages)).toBe(
+      true,
+    );
+    expect(
+      isStaticResourceRequest('/en/upload/avatar.png', [], languages),
+    ).toBe(true);
+  });
+
+  test('uses the same default skip policy in runtime redirects', () => {
+    for (const pathname of defaultSkippedPaths) {
+      expect(shouldIgnoreRuntimeRedirect(pathname, languages)).toBe(true);
+      expect(shouldIgnoreRuntimeRedirect(`/cs${pathname}`, languages)).toBe(
+        true,
+      );
+    }
+  });
+});