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

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/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': {

package/tests/reactI18nextRuntimeBoundary.test.ts

@@ -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', () => {

package/tests/routerAdapter.test.tsx

@@ -399,6 +399,62 @@ describe('i18n router adapter', () => {
     });
   });
 
+  test('updates provider language when target locale is already in URL', async () => {
+    window.history.replaceState(null, '', '/cs/podminky-pouzivani');
+
+    const router = createTanstackRouter('/cs/podminky-pouzivani', 'cs');
+    const i18nInstance = createI18nInstance('en');
+    const updateLanguage = rstest.fn();
+    let changeLanguagePromise: Promise<void> | undefined;
+
+    const Harness = () => {
+      const { changeLanguage } = useModernI18n();
+      return (
+        <button
+          type="button"
+          onClick={() => {
+            changeLanguagePromise = changeLanguage('cs');
+          }}
+        >
+          Change language
+        </button>
+      );
+    };
+
+    rendered = await renderWithRuntime(
+      <ModernI18nProvider
+        value={{
+          language: 'en',
+          i18nInstance,
+          languages: ['en', 'cs'],
+          localePathRedirect: true,
+          localisedUrls,
+          updateLanguage,
+        }}
+      >
+        <Harness />
+      </ModernI18nProvider>,
+      createTanstackRuntimeContext(router),
+    );
+
+    const button = rendered.container.querySelector('button');
+    updateLanguage.mockClear();
+
+    await act(async () => {
+      button?.dispatchEvent(
+        new MouseEvent('click', {
+          bubbles: true,
+          cancelable: true,
+          button: 0,
+        }),
+      );
+      await changeLanguagePromise;
+    });
+
+    expect(updateLanguage).toHaveBeenCalledWith('cs');
+    expect(router.navigate).not.toHaveBeenCalled();
+  });
+
   test('keeps React Router positional replacement when changeLanguage updates the URL', async () => {
     window.history.replaceState(null, '', '/en/terms-of-service');