@bleedingdev/modern-js-plugin-i18n 3.9.0-ultramodern.8 → 3.9.3-ultramodern.1

package/src/server/redirectPolicy.ts

@@ -1,4 +1,5 @@
-import type { I18nUrlStrategy } from '../shared/urlStrategy';
+import { isDefaultLocaleRedirectSkipPath } from '../shared/mappedUrlStrategy';
+import { asI18nUrlStrategy, type I18nUrlStrategy } from '../shared/urlStrategy';
 
 interface LocaleRedirectRequest {
   url: string;
@@ -23,7 +24,20 @@ export const shouldIgnoreRedirect = (
   languages: string[] = [],
 ): boolean => {
   const remainingPath = stripUrlPathPrefix(pathname, urlPath);
-  if (urlStrategy?.shouldSkipRedirect?.(remainingPath, languages)) {
+  // Federation artifacts (`backend-mf-manifest.json`, `backendRemoteEntry.cjs`,
+  // `mf-manifest.json`, …) are never pages: redirecting them to a locale
+  // prefix hands a remote consumer an HTML document. This is native policy and
+  // does not depend on a URL strategy being configured; a strategy can only
+  // add exclusions.
+  if (isDefaultLocaleRedirectSkipPath(remainingPath, languages)) {
+    return true;
+  }
+  if (
+    asI18nUrlStrategy(urlStrategy)?.shouldSkipRedirect?.(
+      remainingPath,
+      languages,
+    )
+  ) {
     return true;
   }
   if (!ignoreRedirectRoutes) {
@@ -110,8 +124,9 @@ export const buildLocalizedUrl = (
   } else {
     segments.unshift(language);
   }
-  const pathname = urlStrategy
-    ? urlStrategy.localizePathname(remainingPath, language, languages)
+  const strategy = asI18nUrlStrategy(urlStrategy);
+  const pathname = strategy
+    ? strategy.localizePathname(remainingPath, language, languages)
     : `/${segments.join('/')}`;
   return `${basePath === '/' ? '' : basePath}${pathname}${url.search}${url.hash}`;
 };

package/src/shared/detection.ts

@@ -8,14 +8,13 @@ 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
  */
-function detectLanguageFromRequest(
+export function detectLanguageFromRequest(
   req: {
     url: string;
     headers:
-      | {
-          get: (name: string) => string | null;
-        }
-      | Headers;
+      | Headers
+      | { get: (name: string) => string | null }
+      | Record<string, string | string[] | undefined>;
   },
   languages: string[],
   detectionOptions?: LanguageDetectorOptions,
@@ -39,11 +38,21 @@ function detectLanguageFromRequest(
       order.length > 0 ? order : ['querystring', 'cookie', 'header'];
 
     // Helper to get header value
+    // req.headers is a Fetch API Headers instance when the caller passes the raw
+    // Request (e.g. ssrContext.request.raw), but modern.js's own SSR request object
+    // (ssrContext.request) carries headers as a plain, lower-cased key/value object.
     const getHeader = (name: string): string | null => {
-      if (req.headers instanceof Headers) {
-        return req.headers.get(name);
+      const headers = req.headers;
+      if (typeof (headers as Headers)?.get === 'function') {
+        return (headers as Headers).get(name);
+      }
+      const value = (headers as Record<string, string | string[] | undefined>)[
+        name.toLowerCase()
+      ];
+      if (Array.isArray(value)) {
+        return value[0] ?? null;
       }
-      return req.headers.get(name);
+      return value ?? null;
     };
 
     // Try each detection method in order
@@ -94,7 +103,8 @@ function detectLanguageFromRequest(
               .map((lang: string) => {
                 const [code, q] = lang.trim().split(';');
                 return {
-                  code: code.split('-')[0], // Extract base language code
+                  code,
+                  baseCode: code.split('-')[0],
                   quality: q ? parseFloat(q.split('=')[1]) : 1.0,
                 };
               })
@@ -103,12 +113,17 @@ function detectLanguageFromRequest(
                   b.quality - a.quality,
               );
 
-            // Find first matching language
+            // Find first matching language, preferring an exact tag match
+            // (e.g. 'zh-Hant-TW') over the base language code (e.g. 'zh')
             for (const lang of languagesList) {
               if (languages.length === 0 || languages.includes(lang.code)) {
                 detectedLang = lang.code;
                 break;
               }
+              if (languages.includes(lang.baseCode)) {
+                detectedLang = lang.baseCode;
+                break;
+              }
             }
           }
           break;
@@ -122,6 +137,15 @@ function detectLanguageFromRequest(
       ) {
         return detectedLang;
       }
+
+      // Match query and cookie values like header values: exact tag first,
+      // then the supported base language (e.g. 'zh-CN' -> 'zh').
+      if (detectedLang) {
+        const baseLang = detectedLang.split('-')[0];
+        if (languages.includes(baseLang)) {
+          return baseLang;
+        }
+      }
     }
   } catch (error) {
     // Silently ignore errors

package/src/shared/mappedUrlStrategy.ts

@@ -0,0 +1,59 @@
+import {
+  canonicalTargetPathname,
+  isDefaultLocaleRedirectSkipPath,
+  type LocalisedUrlsOption,
+  localiseTargetPathname,
+} from '@modern-js/i18n-runtime-extensions';
+import type { I18nUrlStrategy } from './urlStrategy';
+
+/**
+ * The fork's native locale-redirect exclusions (federation artifacts, static
+ * and upload prefixes). Re-exported from this fork-owned seam so the native
+ * runtime and server redirect paths apply them without importing the
+ * extensions package themselves.
+ */
+export { isDefaultLocaleRedirectSkipPath } from '@modern-js/i18n-runtime-extensions';
+
+/**
+ * Build the URL policy from a mapped-locale-URL configuration.
+ *
+ * `localeDetection.localisedUrls` is plain data, so unlike a `urlStrategy`
+ * object it survives the JSON boundary between `modern.config.ts` and the
+ * generated runtime registration. It is therefore the one configuration both
+ * sides can rely on for mapped URLs.
+ *
+ * This is shared rather than server-only on purpose. The server and the client
+ * have to agree on the mapping or a hydrated `<Link>` navigates to a path the
+ * server will not serve: SSR renders `/cs/obchodni-podminky` while a
+ * client-side navigation asks for `/cs/terms-of-service`. The helpers below are
+ * pure pathname functions from `@modern-js/i18n-runtime-extensions`, so the
+ * client cost is a few hundred bytes of string work and no i18n engine.
+ */
+export const createMappedUrlStrategy = (
+  localisedUrls?: LocalisedUrlsOption,
+): I18nUrlStrategy => ({
+  localizePathname: (pathname, language, languages) =>
+    localiseTargetPathname(pathname, language, [...languages], localisedUrls),
+  canonicalPathname: (pathname, languages) =>
+    canonicalTargetPathname(pathname, [...languages], localisedUrls),
+  shouldSkipRedirect: (pathname, languages) =>
+    isDefaultLocaleRedirectSkipPath(pathname, [...languages]),
+});
+
+/** Only a non-empty map needs a derived policy. */
+export const resolveMappedUrlStrategy = (
+  localeDetection: unknown,
+): I18nUrlStrategy | undefined => {
+  if (!localeDetection || typeof localeDetection !== 'object') {
+    return undefined;
+  }
+  const localisedUrls = Reflect.get(localeDetection, 'localisedUrls');
+  if (
+    !localisedUrls ||
+    typeof localisedUrls !== 'object' ||
+    Object.keys(localisedUrls).length === 0
+  ) {
+    return undefined;
+  }
+  return createMappedUrlStrategy(localisedUrls as LocalisedUrlsOption);
+};

package/src/shared/type.ts

@@ -10,6 +10,16 @@ export interface BaseLocaleDetectionOptions {
   fallbackLanguage?: string;
   detection?: LanguageDetectorOptions;
   ignoreRedirectRoutes?: string[] | ((pathname: string) => boolean);
+  /**
+   * Canonical-path -> per-language path map, e.g.
+   * `{ '/products': { en: '/products', cs: '/produkty' } }`.
+   *
+   * Plain data on purpose: the generated runtime registration carries plugin
+   * options as JSON, so a map survives the trip where a `urlStrategy` object
+   * would lose its methods. The CLI expands file-system routes from it, and
+   * the server derives its URL strategy from it, with no extra plugin.
+   */
+  localisedUrls?: boolean | Record<string, Record<string, string>>;
 }
 
 export interface LocaleDetectionOptions extends BaseLocaleDetectionOptions {

package/src/shared/urlStrategy.ts

@@ -9,3 +9,30 @@ export interface I18nUrlStrategy {
   /** Adds exclusions; it cannot enable redirects excluded by native rules. */
   shouldSkipRedirect?(pathname: string, languages: readonly string[]): boolean;
 }
+
+/**
+ * A URL strategy reaches the runtime through the generated runtime
+ * registration, which carries plugin options as JSON. Functions do not survive
+ * that, so a configured strategy can arrive as an empty object — which is
+ * truthy and would make every call site throw. Anything that is not a complete
+ * strategy is treated as absent, and the caller falls back to the built-in
+ * language-prefix behaviour.
+ */
+export const asI18nUrlStrategy = (
+  candidate: unknown,
+): I18nUrlStrategy | undefined => {
+  if (!candidate || typeof candidate !== 'object') {
+    return undefined;
+  }
+  const strategy = candidate as Partial<I18nUrlStrategy>;
+  return typeof strategy.localizePathname === 'function' &&
+    typeof strategy.canonicalPathname === 'function'
+    ? (strategy as I18nUrlStrategy)
+    : undefined;
+};
+
+/** `true` when a value was configured as a strategy but cannot be used as one. */
+export const isUnusableI18nUrlStrategy = (candidate: unknown): boolean =>
+  Boolean(candidate) &&
+  typeof candidate === 'object' &&
+  asI18nUrlStrategy(candidate) === undefined;

package/rslib.config.mts

@@ -1,4 +0,0 @@
-import { rslibConfig } from '@modern-js/rslib';
-import { defineConfig } from '@rslib/core';
-
-export default defineConfig(rslibConfig);

package/rstest.config.mts

@@ -1,46 +0,0 @@
-import { dirname, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import type { ProjectConfig } from '@rstest/core';
-import { withTestPreset } from '@scripts/rstest-config';
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-
-const commonConfig: ProjectConfig = {
-  setupFiles: [resolve(__dirname, '../../../scripts/rstest-config/setup.ts')],
-  globals: true,
-  tools: {
-    swc: {
-      jsc: {
-        transform: {
-          react: {
-            runtime: 'automatic',
-          },
-        },
-      },
-    },
-  },
-};
-
-export default {
-  projects: [
-    withTestPreset({
-      name: 'plugin-i18n-node',
-      testEnvironment: 'node',
-      include: [
-        'tests/i18nUtils.test.ts',
-        'tests/localisedUrls.test.ts',
-        'tests/backendDefaults.test.ts',
-        'tests/redirectPolicy.test.ts',
-        'tests/reactI18nextRuntimeBoundary.test.ts',
-        'tests/federatedI18nBoundaryResolver.test.tsx',
-      ],
-      extends: commonConfig,
-    }),
-    withTestPreset({
-      name: 'plugin-i18n-client',
-      testEnvironment: 'happy-dom',
-      include: ['tests/routerAdapter.test.tsx', 'tests/link.test.tsx'],
-      extends: commonConfig,
-    }),
-  ],
-};

package/tests/backendDefaults.test.ts

@@ -1,30 +0,0 @@
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { describe, expect, test } from '@rstest/core';
-import { resolveDefaultLocalesDir } from '../src/runtime/i18n/backend/defaults.node';
-
-const makeTempDir = (...dirs: string[]): string => {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'i18n-defaults-'));
-  for (const dir of dirs) {
-    fs.mkdirSync(path.join(root, dir), { recursive: true });
-  }
-  return root;
-};
-
-describe('node backend default loadPath', () => {
-  test('prefers the project-root ./locales convention (the detection root)', () => {
-    const root = makeTempDir('locales', 'config/public/locales');
-    expect(resolveDefaultLocalesDir(root)).toBe('./locales');
-  });
-
-  test('falls back to ./config/public/locales when only it exists', () => {
-    const root = makeTempDir('config/public/locales');
-    expect(resolveDefaultLocalesDir(root)).toBe('./config/public/locales');
-  });
-
-  test('defaults to ./locales when neither conventional directory exists', () => {
-    const root = makeTempDir();
-    expect(resolveDefaultLocalesDir(root)).toBe('./locales');
-  });
-});

package/tests/federatedI18nBoundaryResolver.test.tsx

@@ -1,65 +0,0 @@
-import { RuntimeComponentResolverContext } from '@modern-js/runtime/context';
-import { describe, expect, test } from '@rstest/core';
-import { useState } from 'react';
-import { renderToStaticMarkup } from 'react-dom/server';
-import {
-  FederatedI18nBoundary,
-  type FederatedI18nBoundaryProps,
-} from '../src/runtime/context';
-
-const props: FederatedI18nBoundaryProps = {
-  defaultNamespace: 'inventory',
-  resources: {},
-  children: <span>child content</span>,
-};
-
-describe('native federation resolver wrapper', () => {
-  test('retains the actionable fallback when a resolver does not handle i18n', () => {
-    expect(() =>
-      renderToStaticMarkup(
-        <RuntimeComponentResolverContext.Provider
-          value={component => component}
-        >
-          <FederatedI18nBoundary {...props} />
-        </RuntimeComponentResolverContext.Provider>,
-      ),
-    ).toThrow(/requires the @modern-js\/i18n-integration runtime plugin/);
-  });
-
-  test('rejects resolution back to the native wrapper', () => {
-    expect(() =>
-      renderToStaticMarkup(
-        <RuntimeComponentResolverContext.Provider
-          value={() => FederatedI18nBoundary}
-        >
-          <FederatedI18nBoundary {...props} />
-        </RuntimeComponentResolverContext.Provider>,
-      ),
-    ).toThrow(/resolver returned its own wrapper/);
-  });
-
-  test('renders the resolved hook-bearing component with unchanged props', () => {
-    let receivedProps: FederatedI18nBoundaryProps | undefined;
-    function ResolvedBoundary(value: FederatedI18nBoundaryProps) {
-      receivedProps = value;
-      const [label] = useState('resolved');
-      return (
-        <section>
-          {label}:{value.children}
-        </section>
-      );
-    }
-    const html = renderToStaticMarkup(
-      <RuntimeComponentResolverContext.Provider
-        value={(component, { name }) =>
-          name === 'i18n.FederatedI18nBoundary' ? ResolvedBoundary : component
-        }
-      >
-        <FederatedI18nBoundary {...props} />
-      </RuntimeComponentResolverContext.Provider>,
-    );
-    expect(html).toBe('<section>resolved:<span>child content</span></section>');
-    expect(receivedProps?.resources).toBe(props.resources);
-    expect(receivedProps?.defaultNamespace).toBe('inventory');
-  });
-});

package/tests/i18nUtils.test.ts

@@ -1,60 +0,0 @@
-import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { describe, expect, test } from '@rstest/core';
-import {
-  FsBackendWithSave,
-  resolveFsBackendConstructor,
-} from '../src/runtime/i18n/backend/middleware.node';
-
-describe('i18n runtime utils', () => {
-  test('normalizes node fs backend CJS and ESM namespace shapes', () => {
-    class FakeBackend {}
-
-    expect(resolveFsBackendConstructor(FakeBackend)).toBe(FakeBackend);
-    expect(resolveFsBackendConstructor({ default: FakeBackend })).toBe(
-      FakeBackend,
-    );
-    expect(resolveFsBackendConstructor({ 'module.exports': FakeBackend })).toBe(
-      FakeBackend,
-    );
-    expect(
-      resolveFsBackendConstructor({ default: { default: FakeBackend } }),
-    ).toBe(FakeBackend);
-    expect(
-      resolveFsBackendConstructor({
-        default: { 'module.exports': FakeBackend },
-      }),
-    ).toBe(FakeBackend);
-  });
-
-  test('loads translation resources through the node fs backend', async () => {
-    const root = await mkdtemp(join(tmpdir(), 'i18n-backend-'));
-
-    try {
-      await mkdir(join(root, 'cs'), { recursive: true });
-      await writeFile(
-        join(root, 'cs', 'common.json'),
-        JSON.stringify({ title: 'Ahoj' }),
-      );
-      const backend = new FsBackendWithSave(
-        {},
-        { loadPath: join(root, '{{lng}}', '{{ns}}.json') },
-        {},
-      );
-      const resources = await new Promise<unknown>((resolve, reject) => {
-        backend.read('cs', 'common', (error: Error | null, data: unknown) => {
-          if (error) {
-            reject(error);
-          } else {
-            resolve(data);
-          }
-        });
-      });
-
-      expect(resources).toEqual({ title: 'Ahoj' });
-    } finally {
-      await rm(root, { force: true, recursive: true });
-    }
-  });
-});

package/tests/link.test.tsx

@@ -1,139 +0,0 @@
-import type { I18nInstance } from '../src/runtime/i18n';
-import { detectLanguageWithPriority } from '../src/runtime/i18n/detection';
-import { interpolateRouteParams } from '../src/runtime/Link';
-import { canonicalPath, localizePath } from '../src/runtime/localizedPaths';
-import { buildLocalizedUrl, splitUrlTarget } from '../src/runtime/utils';
-
-const languages = ['en', 'cs'];
-
-function createI18nInstance(language = 'en'): I18nInstance {
-  return {
-    language,
-    isInitialized: true,
-    init: () => Promise.resolve(undefined),
-    use: () => {},
-    t: (key: string | string[]) => (Array.isArray(key) ? key[0] : key),
-    createInstance: () => createI18nInstance(language),
-    services: {},
-    options: {},
-  };
-}
-
-describe('splitUrlTarget public compatibility export', () => {
-  test('retains the shared suffix splitter', () => {
-    expect(splitUrlTarget('/a?q=1#x')).toEqual({
-      pathname: '/a',
-      search: '?q=1',
-      hash: '#x',
-    });
-  });
-});
-
-describe('buildLocalizedUrl suffix handling', () => {
-  test('hash-only target keeps the hash and drops the trailing slash', () => {
-    expect(buildLocalizedUrl('/#work-with-me', 'en', languages)).toBe(
-      '/en#work-with-me',
-    );
-  });
-
-  test('query-only target keeps the query', () => {
-    expect(buildLocalizedUrl('/products?tag=x', 'en', languages)).toBe(
-      '/en/products?tag=x',
-    );
-  });
-
-  test('root path', () => {
-    expect(buildLocalizedUrl('/', 'cs', languages)).toBe('/cs');
-  });
-});
-
-describe('interpolateRouteParams', () => {
-  test('interpolates $param and :param segments', () => {
-    expect(interpolateRouteParams('/talks/$slug', { slug: 'ai slop' })).toBe(
-      '/talks/ai%20slop',
-    );
-    expect(interpolateRouteParams('/talks/:slug', { slug: 'x' })).toBe(
-      '/talks/x',
-    );
-  });
-
-  test('drops missing optional segments', () => {
-    expect(interpolateRouteParams('/opt/{-$slug}', {})).toBe('/opt');
-    expect(interpolateRouteParams('/opt/:slug?', {})).toBe('/opt');
-    expect(interpolateRouteParams('/opt/{-$slug}', { slug: 'v' })).toBe(
-      '/opt/v',
-    );
-  });
-
-  test('expands splat params', () => {
-    expect(interpolateRouteParams('/files/$', { _splat: 'a/b' })).toBe(
-      '/files/a/b',
-    );
-    expect(interpolateRouteParams('/files/*', { '*': 'a' })).toBe('/files/a');
-  });
-});
-
-describe('native URL strategy helpers', () => {
-  test('preserves suffixes when adding or stripping only a language prefix', () => {
-    expect(localizePath('/products?q=1#x', 'cs', { languages })).toBe(
-      '/cs/products?q=1#x',
-    );
-    expect(canonicalPath('/CS/products?q=1#x', { languages })).toBe(
-      '/products?q=1#x',
-    );
-  });
-});
-
-describe('language detection priority', () => {
-  test('path locale overrides stale SSR data', async () => {
-    const previousSsrData = (window as any)._SSR_DATA;
-    (window as any)._SSR_DATA = { data: { i18nData: { lng: 'en' } } };
-
-    try {
-      await expect(
-        detectLanguageWithPriority(createI18nInstance('en'), {
-          languages,
-          fallbackLanguage: 'en',
-          localePathRedirect: true,
-          i18nextDetector: false,
-          detection: {},
-          userInitOptions: {},
-          pathname: '/cs/produkty',
-          ssrContext: undefined,
-        }),
-      ).resolves.toEqual({ detectedLanguage: 'cs', finalLanguage: 'cs' });
-    } finally {
-      if (previousSsrData === undefined) {
-        delete (window as any)._SSR_DATA;
-      } else {
-        (window as any)._SSR_DATA = previousSsrData;
-      }
-    }
-  });
-
-  test('regional SSR language resolves to supported base language', async () => {
-    const previousSsrData = (window as any)._SSR_DATA;
-    (window as any)._SSR_DATA = { data: { i18nData: { lng: 'en-US' } } };
-
-    try {
-      await expect(
-        detectLanguageWithPriority(createI18nInstance('cs'), {
-          languages,
-          fallbackLanguage: 'cs',
-          localePathRedirect: true,
-          i18nextDetector: false,
-          detection: {},
-          userInitOptions: {},
-          pathname: '/products',
-          ssrContext: undefined,
-        }),
-      ).resolves.toEqual({ detectedLanguage: 'en', finalLanguage: 'en' });
-    } finally {
-      if (previousSsrData === undefined) {
-        delete (window as any)._SSR_DATA;
-      } else {
-        (window as any)._SSR_DATA = previousSsrData;
-      }
-    }
-  });
-});