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

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/localisedUrls.test.ts

@@ -272,6 +272,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 +346,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 +559,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 +566,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', () => {

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');
 

package/tests/type-fixture/fixture-globals.d.ts

@@ -0,0 +1,11 @@
+// The Window._SSR_DATA augmentation lives in @modern-js/runtime's internal
+// core/types module, which this fixture's isolated program never pulls in.
+interface Window {
+  _SSR_DATA?: {
+    data?: {
+      i18nData?: {
+        lng?: string;
+      };
+    };
+  };
+}

package/tests/type-fixture/tsconfig.json

@@ -7,6 +7,7 @@
     "noEmit": true,
     "skipLibCheck": true,
     "lib": ["ESNext", "DOM"],
+    "types": ["node"],
     "paths": {
       "@modern-js/plugin-i18n/runtime": ["../../src/runtime/index.tsx"]
     }