@bleedingdev/modern-js-plugin-i18n 3.9.0-ultramodern.2 → 3.9.0-ultramodern.21

package/tests/urlStrategySerialization.test.ts

@@ -0,0 +1,122 @@
+import { describe, expect, test } from '@rstest/core';
+import { buildLocalizedUrl, shouldIgnoreRedirect } from '../src/runtime/utils';
+import { resolveMappedUrlStrategy } from '../src/server/mappedUrlStrategy';
+import {
+  buildLocalizedUrl as buildServerLocalizedUrl,
+  shouldIgnoreRedirect as shouldIgnoreServerRedirect,
+} from '../src/server/redirectPolicy';
+import {
+  asI18nUrlStrategy,
+  isUnusableI18nUrlStrategy,
+} from '../src/shared/urlStrategy';
+
+// What a configured `urlStrategy` looks like after the generated runtime
+// registration has carried it through JSON: an object with no methods left.
+const serializedStrategy = {} as any;
+
+const workingStrategy = {
+  localizePathname: (pathname: string, language: string) =>
+    `/${language}${pathname}`,
+  canonicalPathname: (pathname: string) => pathname,
+};
+
+const createRequest = (pathname: string) =>
+  ({ url: `https://example.test${pathname}` }) as any;
+
+describe('URL strategy that lost its methods in transit', () => {
+  test('is recognised as unusable rather than accepted', () => {
+    expect(asI18nUrlStrategy(serializedStrategy)).toBeUndefined();
+    expect(isUnusableI18nUrlStrategy(serializedStrategy)).toBe(true);
+    expect(isUnusableI18nUrlStrategy(undefined)).toBe(false);
+    expect(asI18nUrlStrategy(workingStrategy)).toBe(workingStrategy);
+    expect(isUnusableI18nUrlStrategy(workingStrategy)).toBe(false);
+  });
+
+  test('a partial strategy is unusable too', () => {
+    expect(asI18nUrlStrategy({ localizePathname: () => '/x' })).toBeUndefined();
+  });
+
+  test('the client link builder falls back instead of throwing', () => {
+    expect(() =>
+      buildLocalizedUrl('/about', 'cs', ['en', 'cs'], serializedStrategy),
+    ).not.toThrow();
+    expect(
+      buildLocalizedUrl('/about', 'cs', ['en', 'cs'], serializedStrategy),
+    ).toBe('/cs/about');
+    expect(
+      buildLocalizedUrl('/about', 'cs', ['en', 'cs'], workingStrategy),
+    ).toBe('/cs/about');
+  });
+
+  test('the client redirect check falls back instead of throwing', () => {
+    expect(() =>
+      shouldIgnoreRedirect(
+        '/about',
+        ['en', 'cs'],
+        undefined,
+        serializedStrategy,
+      ),
+    ).not.toThrow();
+    expect(
+      shouldIgnoreRedirect(
+        '/about',
+        ['en', 'cs'],
+        undefined,
+        serializedStrategy,
+      ),
+    ).toBe(false);
+  });
+
+  test('the server redirect builder falls back instead of throwing', () => {
+    expect(() =>
+      buildServerLocalizedUrl(
+        createRequest('/about'),
+        '/*',
+        'cs',
+        ['en', 'cs'],
+        serializedStrategy,
+      ),
+    ).not.toThrow();
+    expect(
+      buildServerLocalizedUrl(
+        createRequest('/about'),
+        '/*',
+        'cs',
+        ['en', 'cs'],
+        serializedStrategy,
+      ),
+    ).toBe('/cs/about');
+  });
+
+  test('the server redirect skip check falls back instead of throwing', () => {
+    expect(() =>
+      shouldIgnoreServerRedirect(
+        '/about',
+        '/*',
+        undefined,
+        serializedStrategy,
+        ['en', 'cs'],
+      ),
+    ).not.toThrow();
+  });
+});
+
+describe('serializable mapped locale URLs', () => {
+  test('produce a working strategy on the server', () => {
+    const strategy = resolveMappedUrlStrategy({
+      languages: ['en', 'cs'],
+      localisedUrls: { '/about': { en: '/about', cs: '/o-nas' } },
+    });
+
+    expect(strategy).toBeDefined();
+    expect(strategy?.localizePathname('/about', 'cs', ['en', 'cs'])).toBe(
+      '/cs/o-nas',
+    );
+  });
+
+  test('are absent when no map is configured', () => {
+    expect(resolveMappedUrlStrategy(undefined)).toBeUndefined();
+    expect(resolveMappedUrlStrategy({ languages: ['en'] })).toBeUndefined();
+    expect(resolveMappedUrlStrategy({ localisedUrls: {} })).toBeUndefined();
+  });
+});

package/tsconfig.json

@@ -6,9 +6,11 @@
     "jsx": "preserve",
     // FORK: `baseUrl` removed. TypeScript 7 / tsgo reject it outright (TS5102),
     // so this package's own tsconfig could not be typechecked at all. `paths`
-    // is empty here, so nothing resolved through baseUrl.
+    // needs no baseUrl.
     "isolatedModules": true,
-    "paths": {},
+    "paths": {
+      "@modern-js/plugin-i18n/runtime/contexts": ["./src/runtime/contexts.ts"]
+    },
     "rootDir": "./src"
   },
   "include": ["src", "types"]

package/tests/federatedI18nBoundary.client.test.tsx

@@ -1,129 +0,0 @@
-import { expect, test } from '@rstest/core';
-import i18next, { type i18n } from 'i18next';
-import { act, useState } from 'react';
-import { hydrateRoot } from 'react-dom/client';
-import { renderToString } from 'react-dom/server';
-import { I18nextProvider, useTranslation } from 'react-i18next';
-import { ModernI18nProvider } from '../src/runtime/context';
-import { FederatedI18nBoundary, useModernI18n } from '../src/runtime/core';
-
-const remoteResources = {
-  cs: {
-    inventory: {
-      'inventory.widgetBody': 'C1 skladová plocha vlastněná MicroVerticalem.',
-    },
-  },
-  en: {
-    inventory: {
-      'inventory.widgetBody':
-        'C1 inventory surface owned by the MicroVertical.',
-    },
-  },
-};
-
-function InventoryCopy() {
-  const modernI18n = useModernI18n<i18n>();
-  const reactI18n = useTranslation('inventory');
-  const reactI18nInstance = reactI18n.i18n as i18n & { __original?: i18n };
-  const sharesScopedInstance =
-    reactI18nInstance === modernI18n.i18nInstance ||
-    reactI18nInstance.__original === modernI18n.i18nInstance;
-
-  return (
-    <p data-testid="inventory-copy">
-      {modernI18n.t('inventory.widgetBody')}|
-      {reactI18n.t('inventory.widgetBody')}|{String(sharesScopedInstance)}
-    </p>
-  );
-}
-
-function Host({ hostI18n }: { hostI18n: i18n }) {
-  const [language, setLanguage] = useState('en');
-
-  return (
-    <ModernI18nProvider
-      i18nextProvider={I18nextProvider}
-      value={{
-        i18nInstance: hostI18n,
-        language,
-        languages: ['en', 'cs'],
-      }}
-    >
-      <button
-        onClick={async () => {
-          await hostI18n.changeLanguage('cs');
-          setLanguage('cs');
-        }}
-        type="button"
-      >
-        cs
-      </button>
-      <FederatedI18nBoundary
-        defaultNamespace="inventory"
-        fallbackLanguage="en"
-        resources={remoteResources}
-        supportedLanguages={['en', 'cs']}
-      >
-        <InventoryCopy />
-      </FederatedI18nBoundary>
-    </ModernI18nProvider>
-  );
-}
-
-async function createHostI18n() {
-  const instance = i18next.createInstance();
-  await instance.init({
-    defaultNS: 'inventory',
-    fallbackLng: 'en',
-    initImmediate: false,
-    lng: 'en',
-    resources: {
-      cs: {
-        inventory: {
-          'inventory.widgetBody': 'stale host Czech copy',
-        },
-      },
-      en: {
-        inventory: {
-          'inventory.widgetBody': 'stale host English copy',
-        },
-      },
-    },
-    supportedLngs: ['en', 'cs'],
-  });
-  return instance;
-}
-
-test('hydrates remote-owned copy and follows the host language', async () => {
-  const serverI18n = await createHostI18n();
-  const container = document.createElement('div');
-  container.innerHTML = renderToString(<Host hostI18n={serverI18n} />);
-  document.body.appendChild(container);
-
-  const clientI18n = await createHostI18n();
-  const hydrationErrors: unknown[] = [];
-  const root = hydrateRoot(container, <Host hostI18n={clientI18n} />, {
-    onRecoverableError: error => hydrationErrors.push(error),
-  });
-
-  await act(async () => undefined);
-  expect(
-    container.querySelector('[data-testid="inventory-copy"]')?.textContent,
-  ).toBe(
-    'C1 inventory surface owned by the MicroVertical.|C1 inventory surface owned by the MicroVertical.|true',
-  );
-
-  await act(async () => {
-    (container.querySelector('button') as HTMLButtonElement).click();
-  });
-  expect(
-    container.querySelector('[data-testid="inventory-copy"]')?.textContent,
-  ).toBe(
-    'C1 skladová plocha vlastněná MicroVerticalem.|C1 skladová plocha vlastněná MicroVerticalem.|true',
-  );
-  expect(clientI18n.t('inventory.widgetBody')).toBe('stale host Czech copy');
-  expect(hydrationErrors).toEqual([]);
-
-  await act(async () => root.unmount());
-  container.remove();
-});

package/tests/federatedI18nBoundary.test.tsx

@@ -1,132 +0,0 @@
-import { describe, expect, test } from '@rstest/core';
-import i18next, { type i18n } from 'i18next';
-import { renderToStaticMarkup } from 'react-dom/server';
-import { I18nextProvider, useTranslation } from 'react-i18next';
-import { ModernI18nProvider } from '../src/runtime/context';
-import { FederatedI18nBoundary, useModernI18n } from '../src/runtime/core';
-
-const C0_COPY = 'C0 copy bundled by the shell';
-const C1_COPY =
-  'C1 operational independence: inventory UI and localization moved together.';
-const HOST_ONLY_INVENTORY_COPY = 'inventory copy owned only by the shell';
-const HOST_ONLY_SHELL_COPY = 'private shell copy';
-
-function InventoryCopy() {
-  const modernI18n = useModernI18n<i18n>();
-  const reactI18n = useTranslation('inventory');
-  const reactI18nInstance = reactI18n.i18n as i18n & { __original?: i18n };
-  const sharesScopedInstance =
-    reactI18nInstance === modernI18n.i18nInstance ||
-    reactI18nInstance.__original === modernI18n.i18nInstance;
-
-  return (
-    <p>
-      {modernI18n.t('inventory.widgetBody')}|
-      {reactI18n.t('inventory.widgetBody')}|{String(sharesScopedInstance)}|
-      {modernI18n.t('inventory.hostOnly')}|{modernI18n.t('shell:private')}|
-      {reactI18n.t('inventory.hostOnly')}|{reactI18n.t('shell:private')}
-    </p>
-  );
-}
-
-describe('FederatedI18nBoundary', () => {
-  test('renders remote-owned resources instead of stale host resources', async () => {
-    const hostI18n = i18next.createInstance();
-    await hostI18n.init({
-      defaultNS: 'inventory',
-      fallbackLng: 'en',
-      initImmediate: false,
-      lng: 'en',
-      ns: ['inventory'],
-      resources: {
-        en: {
-          inventory: {
-            'inventory.hostOnly': HOST_ONLY_INVENTORY_COPY,
-            'inventory.widgetBody': C0_COPY,
-          },
-          shell: {
-            private: HOST_ONLY_SHELL_COPY,
-          },
-        },
-      },
-      supportedLngs: ['en', 'cs'],
-    });
-
-    const html = renderToStaticMarkup(
-      <ModernI18nProvider
-        i18nextProvider={I18nextProvider}
-        value={{
-          i18nInstance: hostI18n,
-          language: 'en',
-          languages: ['en', 'cs'],
-        }}
-      >
-        <FederatedI18nBoundary
-          defaultNamespace="inventory"
-          resources={{
-            en: {
-              inventory: {
-                'inventory.widgetBody': C1_COPY,
-              },
-            },
-          }}
-        >
-          <InventoryCopy />
-        </FederatedI18nBoundary>
-      </ModernI18nProvider>,
-    );
-
-    expect(html).toContain(C1_COPY);
-    expect(html).not.toContain(C0_COPY);
-    expect(html).toContain(`${C1_COPY}|${C1_COPY}|true`);
-    expect(html).not.toContain(HOST_ONLY_INVENTORY_COPY);
-    expect(html).not.toContain(HOST_ONLY_SHELL_COPY);
-    expect(hostI18n.t('inventory.widgetBody')).toBe(C0_COPY);
-    expect(hostI18n.t('inventory.hostOnly')).toBe(HOST_ONLY_INVENTORY_COPY);
-    expect(hostI18n.t('shell:private')).toBe(HOST_ONLY_SHELL_COPY);
-  });
-
-  test('fails before mutation when cloneInstance does not isolate the host store', async () => {
-    const hostI18n = i18next.createInstance();
-    await hostI18n.init({
-      defaultNS: 'inventory',
-      initImmediate: false,
-      lng: 'en',
-      resources: {
-        en: {
-          inventory: {
-            'inventory.widgetBody': C0_COPY,
-          },
-        },
-      },
-    });
-    hostI18n.cloneInstance = () => hostI18n;
-
-    expect(() =>
-      renderToStaticMarkup(
-        <ModernI18nProvider
-          i18nextProvider={I18nextProvider}
-          value={{
-            i18nInstance: hostI18n,
-            language: 'en',
-            languages: ['en'],
-          }}
-        >
-          <FederatedI18nBoundary
-            defaultNamespace="inventory"
-            resources={{
-              en: {
-                inventory: {
-                  'inventory.widgetBody': C1_COPY,
-                },
-              },
-            }}
-          >
-            <InventoryCopy />
-          </FederatedI18nBoundary>
-        </ModernI18nProvider>,
-      ),
-    ).toThrow(/did not isolate the host resource store/u);
-    expect(hostI18n.t('inventory.widgetBody')).toBe(C0_COPY);
-  });
-});

package/tests/linkTypes.test.ts

@@ -1,59 +0,0 @@
-import { execFileSync } from 'node:child_process';
-import path from 'node:path';
-
-const fixtureDir = path.resolve(__dirname, 'type-fixture');
-
-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();
-const useShell = process.platform === 'win32';
-const execOptions = { cwd: path.dirname(__dirname), shell: useShell };
-execFileSync('pnpm', ['build'], execOptions);
-
-describe('Link type-level tests', () => {
-  test('fixture type-checks correctly: valid uses compile, invalid uses are rejected', () => {
-    try {
-      execFileSync(
-        process.execPath,
-        [tsgoBin, '--noEmit', '-p', 'tsconfig.json'],
-        {
-          cwd: fixtureDir,
-          stdio: 'pipe',
-        },
-      );
-    } catch (e: any) {
-      const stdout = e?.stdout ? String(e.stdout) : '';
-      const stderr = e?.stderr ? String(e.stderr) : '';
-      throw new Error(`TypeScript type-check failed:\n${stdout}\n${stderr}`);
-    }
-  }, 60_000);
-
-  test('consumer declarations avoid toolchain internals', () => {
-    const output = execFileSync(process.execPath, [
-      tsgoBin,
-      '--ignoreConfig',
-      '--listFilesOnly',
-      '--module',
-      'preserve',
-      '--moduleResolution',
-      'bundler',
-      path.resolve(__dirname, '../dist/types/runtime/context.d.ts'),
-    ]);
-    const files = output.toString().replaceAll('\\', '/');
-    expect(files).not.toMatch(
-      /\/packages\/(cli|runtime\/plugin-runtime\/dist\/types|solutions\/app-tools|toolkit\/(types|utils))\//u,
-    );
-  }, 60_000);
-});

package/tests/localisedUrlRewriteMatrix.fork.test.ts

@@ -1,147 +0,0 @@
-import type { LocalisedUrlsMap } from '@modern-js/i18n-runtime-extensions';
-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';
-
-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/peerCohort.test.ts

@@ -1,25 +0,0 @@
-import { createRequire } from 'node:module';
-
-const require = createRequire(import.meta.url);
-const pluginManifest = require('../package.json') as {
-  peerDependencies: Record<string, string>;
-  peerDependenciesMeta: Record<string, { optional?: boolean }>;
-};
-const runtimeManifest = require('../../plugin-runtime/package.json') as {
-  peerDependencies: Record<string, string>;
-};
-
-describe('plugin-i18n peer cohort', () => {
-  test('matches the required runtime React cohort without overstating i18n floors', () => {
-    expect(pluginManifest.peerDependencies).toMatchObject({
-      i18next: '>=25.7.4',
-      react: runtimeManifest.peerDependencies.react,
-      'react-dom': runtimeManifest.peerDependencies['react-dom'],
-      'react-i18next': '>=15.7.4',
-    });
-    expect(pluginManifest.peerDependenciesMeta).toMatchObject({
-      i18next: { optional: true },
-      'react-i18next': { optional: true },
-    });
-  });
-});

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

@@ -1,11 +0,0 @@
-// 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/i18nInstanceTypes.fixture.ts

@@ -1,29 +0,0 @@
-import {
-  type I18nInstance,
-  useModernI18n,
-} from '@modern-js/plugin-i18n/runtime';
-import i18next, { type i18n } from 'i18next';
-
-// WRITE direction — this is what had zero coverage and was broken before the
-// top-level index signature was removed from `I18nInstance`. Eight integration
-// fixtures (tests/integration/i18n/*/src/modern.runtime.tsx) write exactly
-// this and none of them is ever typechecked; this file is the guard.
-export const w1: I18nInstance = i18next.createInstance();
-export const w2: I18nInstance = i18next;
-
-// READ direction.
-declare const inst: I18nInstance;
-export const s: string = inst.t('k');
-export const b: boolean = inst.exists!('k');
-export const langs: readonly string[] = inst.languages!;
-export const fixed: string = inst.getFixedT!('en')('k');
-
-// W2 generic, both with and without an explicit type argument.
-type StarlingLike = i18n & { setLang?: (l: string) => void | Promise<void> };
-export function useTyped() {
-  const r = useModernI18n<StarlingLike>();
-  return r.i18nInstance.t('k') satisfies string;
-}
-export function useDefault() {
-  return useModernI18n().i18nInstance.t('k') satisfies string;
-}