@bleedingdev/modern-js-plugin-i18n 3.5.0-ultramodern.4 → 3.5.0-ultramodern.41

package/tests/fixtures/localised-routes.golden.json

@@ -0,0 +1,156 @@
+[
+  {
+    "id": ":lang",
+    "path": ":lang",
+    "type": "nested",
+    "origin": "file-system",
+    "routeType": "layout",
+    "_component": ":lang.tsx",
+    "children": [
+      {
+        "id": "about",
+        "path": "about",
+        "type": "nested",
+        "origin": "file-system",
+        "routeType": "page",
+        "_component": "about.tsx",
+        "modernCanonicalPath": "/about"
+      },
+      {
+        "id": "about__localised_o-nas",
+        "path": "o-nas",
+        "type": "nested",
+        "origin": "file-system",
+        "routeType": "page",
+        "_component": "about.tsx",
+        "modernCanonicalPath": "/about"
+      },
+      {
+        "id": "about__localised_ueber-uns",
+        "path": "ueber-uns",
+        "type": "nested",
+        "origin": "file-system",
+        "routeType": "page",
+        "_component": "about.tsx",
+        "modernCanonicalPath": "/about"
+      },
+      {
+        "id": "products",
+        "path": "products",
+        "type": "nested",
+        "origin": "file-system",
+        "routeType": "layout",
+        "_component": "products.tsx",
+        "children": [
+          {
+            "id": ":slug",
+            "path": ":slug",
+            "type": "nested",
+            "origin": "file-system",
+            "routeType": "page",
+            "_component": ":slug.tsx",
+            "modernCanonicalPath": "/products/:slug"
+          }
+        ],
+        "modernCanonicalPath": "/products"
+      },
+      {
+        "id": "products__localised_produkty",
+        "path": "produkty",
+        "type": "nested",
+        "origin": "file-system",
+        "routeType": "layout",
+        "_component": "products.tsx",
+        "children": [
+          {
+            "id": ":slug__localised_produkty",
+            "path": ":slug",
+            "type": "nested",
+            "origin": "file-system",
+            "routeType": "page",
+            "_component": ":slug.tsx",
+            "modernCanonicalPath": "/products/:slug"
+          }
+        ],
+        "modernCanonicalPath": "/products"
+      },
+      {
+        "id": "products__localised_produkte",
+        "path": "produkte",
+        "type": "nested",
+        "origin": "file-system",
+        "routeType": "layout",
+        "_component": "products.tsx",
+        "children": [
+          {
+            "id": ":slug__localised_produkte",
+            "path": ":slug",
+            "type": "nested",
+            "origin": "file-system",
+            "routeType": "page",
+            "_component": ":slug.tsx",
+            "modernCanonicalPath": "/products/:slug"
+          }
+        ],
+        "modernCanonicalPath": "/products"
+      },
+      {
+        "id": "docs",
+        "path": "docs",
+        "type": "nested",
+        "origin": "file-system",
+        "routeType": "layout",
+        "_component": "docs.tsx",
+        "children": [
+          {
+            "id": "*",
+            "path": "*",
+            "type": "nested",
+            "origin": "file-system",
+            "routeType": "page",
+            "_component": "*.tsx"
+          }
+        ],
+        "modernCanonicalPath": "/docs"
+      },
+      {
+        "id": "docs__localised_dokumenty",
+        "path": "dokumenty",
+        "type": "nested",
+        "origin": "file-system",
+        "routeType": "layout",
+        "_component": "docs.tsx",
+        "children": [
+          {
+            "id": "*__localised_dokumenty",
+            "path": "*",
+            "type": "nested",
+            "origin": "file-system",
+            "routeType": "page",
+            "_component": "*.tsx"
+          }
+        ],
+        "modernCanonicalPath": "/docs"
+      },
+      {
+        "id": "docs__localised_dokumente",
+        "path": "dokumente",
+        "type": "nested",
+        "origin": "file-system",
+        "routeType": "layout",
+        "_component": "docs.tsx",
+        "children": [
+          {
+            "id": "*__localised_dokumente",
+            "path": "*",
+            "type": "nested",
+            "origin": "file-system",
+            "routeType": "page",
+            "_component": "*.tsx"
+          }
+        ],
+        "modernCanonicalPath": "/docs"
+      }
+    ]
+  }
+]

package/tests/link.test.tsx

@@ -4,6 +4,7 @@ import { act } from 'react';
 import { createRoot, type Root } from 'react-dom/client';
 import { ModernI18nProvider } from '../src/runtime/context';
 import type { I18nInstance } from '../src/runtime/i18n';
+import { detectLanguageWithPriority } from '../src/runtime/i18n/detection';
 import { interpolateRouteParams, Link } from '../src/runtime/Link';
 import {
   canonicalPath,
@@ -270,6 +271,60 @@ describe('localization utilities', () => {
   });
 });
 
+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;
+      }
+    }
+  });
+});
+
 describe('framework Link', () => {
   let rendered: { container: HTMLElement; root: Root } | undefined;
 
@@ -328,6 +383,26 @@ describe('framework Link', () => {
     expect(props.hash).toBe('list');
   });
 
+  test('preserves array search values natively', async () => {
+    const router = createTanstackRouter('/en/products', 'en');
+    rendered = await renderWithRuntime(
+      <ModernI18nProvider value={providerValue('en')}>
+        <Link
+          to="/products"
+          search={{ tag: ['boots', 'sale'], page: 2 }}
+          data-testid="q"
+        >
+          Products
+        </Link>
+      </ModernI18nProvider>,
+      createTanstackRuntimeContext(router),
+    );
+
+    const props = capturedLinkProps.at(-1);
+    expect(props.to).toBe('/en/products');
+    expect(props.search).toEqual({ tag: ['boots', 'sale'], page: '2' });
+  });
+
   test('renders a plain anchor for external targets', async () => {
     const router = createTanstackRouter('/en', 'en');
     rendered = await renderWithRuntime(
@@ -381,6 +456,42 @@ describe('framework Link', () => {
     expect(link?.hasAttribute('prefetch')).toBe(false);
   });
 
+  test('serializes array search values for fallback anchors', async () => {
+    rendered = await renderWithRuntime(
+      <ModernI18nProvider value={providerValue('en')}>
+        <Link
+          to="/products"
+          search={{ tag: ['boots', 'sale'], page: 2 }}
+          data-testid="q"
+        >
+          Products
+        </Link>
+      </ModernI18nProvider>,
+      { isBrowser: true, requestContext, context: requestContext } as any,
+    );
+
+    const link = rendered.container.querySelector('[data-testid="q"]');
+    expect(link?.getAttribute('href')).toBe(
+      '/en/products?tag=boots&tag=sale&page=2',
+    );
+  });
+
+  test('empty search prop clears query from target fallback anchors', async () => {
+    rendered = await renderWithRuntime(
+      <ModernI18nProvider value={providerValue('en')}>
+        <Link to="/products?tag=x" search="" data-testid="clear-query">
+          Products
+        </Link>
+      </ModernI18nProvider>,
+      { isBrowser: true, requestContext, context: requestContext } as any,
+    );
+
+    const link = rendered.container.querySelector(
+      '[data-testid="clear-query"]',
+    );
+    expect(link?.getAttribute('href')).toBe('/en/products');
+  });
+
   test('maps prefetch to the TanStack preload prop', async () => {
     const router = createTanstackRouter('/en/products', 'en');
     rendered = await renderWithRuntime(

package/tests/linkTypes.test.ts

@@ -3,10 +3,21 @@ import path from 'node:path';
 
 const fixtureDir = path.resolve(__dirname, 'type-fixture');
 
-const tsgoBin = path.join(
-  path.dirname(require.resolve('@typescript/native-preview/package.json')),
-  'bin/tsgo.js',
-);
+function resolveTsgoBin() {
+  const pkgPath = require.resolve('@typescript/native-preview/package.json');
+  const pkgDir = path.dirname(pkgPath);
+  const pkg = require(pkgPath) as {
+    bin?:
+      | string
+      | {
+          tsgo?: string;
+        };
+  };
+  const binEntry = typeof pkg.bin === 'string' ? pkg.bin : pkg.bin?.tsgo;
+  return path.resolve(pkgDir, binEntry ?? 'bin/tsgo.js');
+}
+
+const tsgoBin = resolveTsgoBin();
 
 describe('Link type-level tests', () => {
   test('fixture type-checks correctly: valid uses compile, invalid uses are rejected', () => {

package/tests/localisedUrlRewriteMatrix.fork.test.ts

@@ -0,0 +1,147 @@
+import { describe, expect, test } from '@rstest/core';
+import {
+  interpolateRouteParams,
+  normalizeSearch,
+} from '../src/runtime/linkHelpers';
+import { canonicalPath, localizePath } from '../src/runtime/localizedPaths';
+import { buildLocalizedUrl } from '../src/runtime/utils';
+import type { LocalisedUrlsMap } from '../src/shared/localisedUrls';
+
+const languages = ['en', 'cs'];
+
+const localisedUrls = {
+  '/products/:slug': {
+    en: '/products/:slug',
+    cs: '/produkty/:slug',
+  },
+  '/files/*': {
+    en: '/files/*',
+    cs: '/soubory/*',
+  },
+  '/app/products/:slug': {
+    en: '/app/products/:slug',
+    cs: '/app/produkty/:slug',
+  },
+} satisfies LocalisedUrlsMap;
+
+const pathsConfig = {
+  languages,
+  localisedUrls,
+};
+
+describe('fork-owned localised URL rewrite matrix', () => {
+  const rewriteScenarios = [
+    {
+      name: 'adds the target locale prefix and localises canonical segments',
+      target: '/products/red-shoe',
+      language: 'cs',
+      expected: '/cs/produkty/red-shoe',
+    },
+    {
+      name: 'strips a case-insensitive source locale before relocalising',
+      target: '/CS/produkty/red%20shoe?tag=boots#details',
+      language: 'en',
+      expected: '/en/products/red%20shoe?tag=boots#details',
+    },
+    {
+      name: 'preserves repeated query keys and the fragment',
+      target: '/products/red-shoe?tag=boots&tag=sale#details',
+      language: 'cs',
+      expected: '/cs/produkty/red-shoe?tag=boots&tag=sale#details',
+    },
+    {
+      name: 'keeps a base-path segment inside the localised route map',
+      target: '/app/products/red-shoe?ref=nav#details',
+      language: 'cs',
+      expected: '/cs/app/produkty/red-shoe?ref=nav#details',
+    },
+    {
+      name: 'keeps the default locale explicitly prefixed',
+      target: '/products/red-shoe',
+      language: 'en',
+      expected: '/en/products/red-shoe',
+    },
+    {
+      name: 'does not double-prefix an already-localised URL',
+      target: '/cs/produkty/red-shoe?tag=boots#details',
+      language: 'cs',
+      expected: '/cs/produkty/red-shoe?tag=boots#details',
+    },
+  ];
+
+  for (const scenario of rewriteScenarios) {
+    test(scenario.name, () => {
+      expect(
+        buildLocalizedUrl(
+          scenario.target,
+          scenario.language,
+          languages,
+          localisedUrls,
+        ),
+      ).toBe(scenario.expected);
+    });
+  }
+
+  test('canonical and localized path helpers strip and add prefixes exactly', () => {
+    expect(
+      canonicalPath('/CS/produkty/red-shoe?tag=boots#details', pathsConfig),
+    ).toBe('/products/red-shoe?tag=boots#details');
+    expect(
+      localizePath('/products/red-shoe?tag=boots#details', 'cs', pathsConfig),
+    ).toBe('/cs/produkty/red-shoe?tag=boots#details');
+  });
+
+  test('splat params preserve separators and percent-encode each segment', () => {
+    const target = interpolateRouteParams('/files/*', {
+      '*': 'resume drafts/Q1 deck.pdf',
+    });
+
+    expect(target).toBe('/files/resume%20drafts/Q1%20deck.pdf');
+    expect(buildLocalizedUrl(target, 'cs', languages, localisedUrls)).toBe(
+      '/cs/soubory/resume%20drafts/Q1%20deck.pdf',
+    );
+  });
+
+  const searchScenarios: Array<{
+    name: string;
+    search: Parameters<typeof normalizeSearch>[0];
+    searchFromTo: string;
+    expected: ReturnType<typeof normalizeSearch>;
+  }> = [
+    {
+      name: 'object array values are preserved',
+      search: { tag: ['boots', 'sale'], page: 2 },
+      searchFromTo: '?ignored=1',
+      expected: {
+        searchString: '?tag=boots&tag=sale&page=2',
+        searchObject: { tag: ['boots', 'sale'], page: '2' },
+      },
+    },
+    {
+      name: 'target query arrays are preserved',
+      search: undefined,
+      searchFromTo: '?tag=boots&tag=sale&page=2',
+      expected: {
+        searchString: '?tag=boots&tag=sale&page=2',
+        searchObject: { tag: ['boots', 'sale'], page: '2' },
+      },
+    },
+    {
+      name: 'empty search clears the target query',
+      search: '',
+      searchFromTo: '?tag=boots&tag=sale',
+      expected: {
+        searchString: '',
+        searchObject: undefined,
+      },
+    },
+  ];
+
+  for (const scenario of searchScenarios) {
+    test(`normalizes search: ${scenario.name}`, () => {
+      expect(normalizeSearch(scenario.search, scenario.searchFromTo)).toEqual(
+        scenario.expected,
+      );
+    });
+  }
+});

package/tests/localisedUrls.test.ts

@@ -1,3 +1,5 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
 import type { NestedRouteForCli } from '@modern-js/types';
 import { describe, expect, test } from '@rstest/core';
 import { i18nPlugin as i18nCliPlugin } from '../src/cli';
@@ -17,6 +19,12 @@ import {
   validateLocalisedUrls,
 } from '../src/shared/localisedUrls';
 
+const localisedRoutesGoldenPath = path.join(
+  __dirname,
+  'fixtures',
+  'localised-routes.golden.json',
+);
+
 const createRoute = (
   path: string,
   children?: NestedRouteForCli[],
@@ -37,6 +45,9 @@ const createRequestContext = (pathname: string) =>
     },
   }) as any;
 
+const serializeRoutesForGolden = (routes: unknown): string =>
+  `${JSON.stringify(routes, null, 2)}\n`;
+
 describe('resolveLocalisedUrlsConfig', () => {
   test('is opt-in: only a non-empty map enables the feature', () => {
     const map = { '/about': { en: '/about', cs: '/o-nas' } };
@@ -108,6 +119,70 @@ describe('cli modifyFileSystemRoutes', () => {
     return modifyRoutes!;
   };
 
+  const generateLocalisedRoutesGolden = (): string => {
+    const modifyRoutes = setupModifyRoutes({
+      localePathRedirect: true,
+      languages: ['en', 'cs', 'de'],
+      localisedUrls: {
+        '/about': {
+          en: '/about',
+          cs: '/o-nas',
+          de: '/ueber-uns',
+        },
+        '/products': {
+          en: '/products',
+          cs: '/produkty',
+          de: '/produkte',
+        },
+        '/products/:slug': {
+          en: '/products/:slug',
+          cs: '/produkty/:slug',
+          de: '/produkte/:slug',
+        },
+        '/docs': {
+          en: '/docs',
+          cs: '/dokumenty',
+          de: '/dokumente',
+        },
+        '/docs/*': {
+          en: '/docs/*',
+          cs: '/dokumenty/*',
+          de: '/dokumente/*',
+        },
+      },
+    });
+    const routes = [
+      createRoute(':lang', [
+        createRoute('about'),
+        createRoute('products', [createRoute(':slug')]),
+        createRoute('docs', [createRoute('*')]),
+      ]),
+    ];
+
+    const result = modifyRoutes({
+      entrypoint: { entryName: 'main' },
+      routes,
+    });
+
+    return serializeRoutesForGolden(result.routes);
+  };
+
+  test('matches checked-in localised routes golden output', async () => {
+    const localisedRoutes = generateLocalisedRoutesGolden();
+    const repeatedLocalisedRoutes = generateLocalisedRoutesGolden();
+
+    expect(repeatedLocalisedRoutes).toBe(localisedRoutes);
+
+    if (process.env.UPDATE_I18N_LOCALISED_ROUTES_GOLDEN === '1') {
+      await mkdir(path.dirname(localisedRoutesGoldenPath), { recursive: true });
+      await writeFile(localisedRoutesGoldenPath, localisedRoutes);
+    }
+
+    await expect(readFile(localisedRoutesGoldenPath, 'utf8')).resolves.toBe(
+      localisedRoutes,
+    );
+  });
+
   test('upstream-style configs without a map keep routes untouched', () => {
     const modifyRoutes = setupModifyRoutes({
       localePathRedirect: true,
@@ -272,6 +347,31 @@ describe('localisedUrls', () => {
     ).toBe('/products/cervena-bota');
   });
 
+  test('encodes wildcard params while preserving path separators', () => {
+    const localisedUrls = {
+      '/docs/*': {
+        en: '/docs/*',
+        cs: '/dokumenty/*',
+      },
+    };
+
+    expect(
+      resolveLocalisedPath(
+        '/docs/a%20b/c%23d',
+        'cs',
+        ['en', 'cs'],
+        localisedUrls,
+      ),
+    ).toBe('/dokumenty/a%20b/c%23d');
+    expect(
+      resolveCanonicalLocalisedPath(
+        '/dokumenty/a%20b/c%23d',
+        ['en', 'cs'],
+        localisedUrls,
+      ),
+    ).toBe('/docs/a%20b/c%23d');
+  });
+
   test('resolves static patterns before param patterns', () => {
     const localisedUrls = {
       '/products/:slug': {
@@ -321,6 +421,31 @@ describe('localisedUrls', () => {
     ).toBe('/products/cervena-bota');
   });
 
+  test('strips case-insensitive locale prefixes before relocalising full pathnames', () => {
+    const localisedUrls = {
+      '/products/:slug': {
+        en: '/products/:slug',
+        cs: '/produkty/:slug',
+      },
+    };
+
+    expect(
+      localiseTargetPathname(
+        '/CS/produkty/cervena-bota',
+        'en',
+        ['en', 'cs'],
+        localisedUrls,
+      ),
+    ).toBe('/en/products/cervena-bota');
+    expect(
+      canonicalTargetPathname(
+        '/CS/produkty/cervena-bota',
+        ['en', 'cs'],
+        localisedUrls,
+      ),
+    ).toBe('/products/cervena-bota');
+  });
+
   test('resolves nested optional route params with translated ancestors', () => {
     const localisedUrls = {
       '/checkout': {
@@ -509,7 +634,6 @@ describe('i18n server API prefix skips', () => {
           header: () => ({ host: 'localhost' }),
         },
         get: () => null,
-        redirect: (url: string) => ({ redirectedTo: url }),
       }) as any;
 
     // Sanity: well-formed non-canonical slugs still redirect.
@@ -517,7 +641,10 @@ describe('i18n server API prefix skips', () => {
       createContext('/cs/products/bota'),
       async () => {},
     );
-    expect(redirected).toEqual({ redirectedTo: '/cs/produkty/bota' });
+    expect(redirected.status).toBe(302);
+    expect(redirected.headers.get('location')).toBe('/cs/produkty/bota');
+    expect(redirected.headers.get('cache-control')).toBe('private, no-store');
+    expect(redirected.headers.get('vary')).toBe('Accept-Language, Cookie');
 
     // Malformed encoding must fall through to next() instead of throwing.
     let nextCalls = 0;

package/tests/reactI18nextRuntimeBoundary.test.ts

@@ -7,7 +7,7 @@ const __dirname = dirname(fileURLToPath(import.meta.url));
 const runtimeRoot = resolve(__dirname, '../src/runtime');
 
 const readRuntimeSource = (file: string) =>
-  readFileSync(resolve(runtimeRoot, file), 'utf8');
+  readFileSync(resolve(runtimeRoot, file), 'utf8').replace(/\r\n/gu, '\n');
 
 describe('react-i18next runtime boundary', () => {
   test('keeps the disabled runtime entry free of the optional adapter edge', () => {
@@ -21,11 +21,14 @@ describe('react-i18next runtime boundary', () => {
 
   test('keeps the runtime plugin factory entry synchronous for federation', () => {
     const core = readRuntimeSource('core.tsx');
+    const pluginSetup = readRuntimeSource('pluginSetup.ts');
 
     expect(core).not.toContain("from './i18n/backend/middleware'");
     expect(core).not.toContain("from './i18n/utils'");
-    expect(core).toContain("import('./i18n/backend/middleware')");
-    expect(core).toContain("import('./i18n/utils')");
+    expect(pluginSetup).not.toContain("from './i18n/backend/middleware'");
+    expect(pluginSetup).not.toContain("from './i18n/utils'");
+    expect(pluginSetup).toContain("import('./i18n/backend/middleware')");
+    expect(pluginSetup).toContain("import('./i18n/utils')");
   });
 
   test('keeps the Modern i18n context stable across federated runtime copies', () => {