@bleedingdev/modern-js-i18n-runtime-extensions 3.9.0-ultramodern.1 → 3.9.0-ultramodern.11

package/tests/languageSyncController.test.ts

@@ -80,7 +80,6 @@ describe('latest language synchronization coordinator', () => {
 
     binding.request('cs');
     binding.request('de');
-    expect(pending.map(change => change.language)).toEqual(['cs', 'de']);
 
     pending[1].resolve();
     await pending[1].promise;
@@ -91,7 +90,6 @@ describe('latest language synchronization coordinator', () => {
     await pending[0].promise;
     await flush();
     expect(target.language).toBe('cs');
-    expect(pending.map(change => change.language)).toEqual(['cs', 'de', 'de']);
 
     pending[2].resolve();
     await pending[2].promise;
@@ -100,81 +98,6 @@ describe('latest language synchronization coordinator', () => {
     expect(commits.at(-1)).toBe('de');
   });
 
-  test('repairs a shared singleton after the starting mount leaves', async () => {
-    const target = { language: 'en' };
-    const { changeLanguage, pending } = deferredChanger(target);
-    const commits: string[] = [];
-    const first = createLatestLanguageSyncBinding<Target>();
-    const second = createLatestLanguageSyncBinding<Target>();
-    for (const binding of [first, second]) {
-      binding.updateCallbacks({
-        changeLanguage,
-        commitLanguage: (_target, language) => commits.push(language),
-        readLanguage: current => current.language,
-      });
-    }
-
-    first.activate(target);
-    first.request('cs');
-    first.deactivate();
-    second.activate(target);
-    second.request('de');
-
-    pending[1].resolve();
-    await pending[1].promise;
-    await flush();
-    pending[0].resolve();
-    await pending[0].promise;
-    await flush();
-
-    expect(pending.map(change => change.language)).toEqual(['cs', 'de', 'de']);
-    pending[2].resolve();
-    await pending[2].promise;
-    await flush();
-    expect(target.language).toBe('de');
-    expect(commits.at(-1)).toBe('de');
-  });
-
-  test('supersedes a hung same-language attempt and repairs it after a later route', async () => {
-    rstest.useFakeTimers();
-    const target = { language: 'en' };
-    const { changeLanguage, pending } = deferredChanger(target);
-    const commits: string[] = [];
-    const binding = createLatestLanguageSyncBinding<Target>({
-      attemptTimeoutMs: 100,
-      retryDelayMs: () => 10,
-    });
-    binding.updateCallbacks({
-      changeLanguage,
-      commitLanguage: (_target, language) => commits.push(language),
-      readLanguage: current => current.language,
-    });
-    binding.activate(target);
-    binding.request('cs');
-
-    await rstest.advanceTimersByTimeAsync(110);
-    expect(pending.map(change => change.language)).toEqual(['cs', 'cs']);
-    pending[1].resolve();
-    await pending[1].promise;
-    await flush();
-    expect(commits.at(-1)).toBe('cs');
-
-    binding.request('de');
-    pending[2].resolve();
-    await pending[2].promise;
-    await flush();
-    expect(target.language).toBe('de');
-
-    pending[0].resolve();
-    await pending[0].promise;
-    await flush();
-    expect(pending.at(-1)?.language).toBe('de');
-    pending.at(-1)?.resolve();
-    await pending.at(-1)?.promise;
-    await flush();
-    expect(target.language).toBe('de');
-  });
-
   test('bounds permanent failures and reports the final consequence once', async () => {
     rstest.useFakeTimers();
     const target = { language: 'en' };

package/tests/localeRedirectPolicy.test.ts

@@ -0,0 +1,173 @@
+import { describe, expect, test } from '@rstest/core';
+import {
+  buildLocalizedUrl,
+  createLocaleRedirectResponse,
+  getLanguageFromPath,
+  isStaticResourceRequest,
+  shouldIgnoreRedirect,
+} from '../src/localeRedirectPolicy';
+
+const languages = ['en', 'cs'];
+const request = (url: string) => ({
+  url,
+  header: () => ({ host: 'example.com' }),
+});
+
+describe('locale redirect resource policy', () => {
+  test('exempts default static and federation routes, including locale prefixes', () => {
+    const paths = [
+      '/backend-mf-manifest.json',
+      '/backendRemoteEntry.cjs',
+      '/mf-manifest.json',
+      '/mf-stats.json',
+      '/remoteEntry.js',
+      // A manifest may name a root entry; the federation layer serves these.
+      '/remoteEntry.catalog.js',
+      '/backendRemoteEntry.catalog-v2.cjs',
+      '/static/app.js',
+      '/upload/avatar.png',
+    ];
+
+    for (const pathname of paths) {
+      expect(isStaticResourceRequest(pathname, [], languages)).toBe(true);
+      expect(isStaticResourceRequest(`/cs${pathname}`, [], languages)).toBe(
+        true,
+      );
+      expect(shouldIgnoreRedirect(`/store${pathname}`, '/store/*')).toBe(true);
+    }
+    // Only the entry itself, not a page or asset that merely starts like one.
+    for (const pathname of [
+      '/remoteEntry.catalog.js.map',
+      '/remoteEntry.catalog/js',
+      '/products/remoteEntry.js',
+    ]) {
+      expect(isStaticResourceRequest(pathname, [], languages)).toBe(false);
+    }
+  });
+
+  test('configured static prefixes match complete path segments with or without a locale', () => {
+    for (const pathname of ['/assets', '/assets/app.js', '/en/assets/app.js']) {
+      expect(isStaticResourceRequest(pathname, ['/assets/'], languages)).toBe(
+        true,
+      );
+    }
+    for (const pathname of [
+      '/assets-extra/app.js',
+      '/cs/assets-extra/app.js',
+    ]) {
+      expect(isStaticResourceRequest(pathname, ['/assets'], languages)).toBe(
+        false,
+      );
+    }
+    expect(
+      isStaticResourceRequest('/fr/assets/app.js', ['/assets'], languages),
+    ).toBe(false);
+    expect(
+      isStaticResourceRequest('/remoteEntry.js/product', [], languages),
+    ).toBe(false);
+    expect(isStaticResourceRequest('/static-product', [])).toBe(false);
+  });
+
+  test('custom ignore lists operate after stripping the mount path', () => {
+    expect(
+      shouldIgnoreRedirect('/store/health/live', '/store/*', ['/health']),
+    ).toBe(true);
+    expect(
+      shouldIgnoreRedirect('/store/healthy', '/store/*', ['/health']),
+    ).toBe(false);
+    expect(shouldIgnoreRedirect('/store/products', '/store/*')).toBe(false);
+  });
+
+  test('custom callbacks receive the remaining pathname and default exemptions take priority', () => {
+    const seen: string[] = [];
+    const ignore = (pathname: string) => {
+      seen.push(pathname);
+      return pathname === '/health';
+    };
+
+    expect(shouldIgnoreRedirect('/store/health', '/store/*', ignore)).toBe(
+      true,
+    );
+    expect(shouldIgnoreRedirect('/store/products', '/store/*', ignore)).toBe(
+      false,
+    );
+    expect(
+      shouldIgnoreRedirect('/store/static/app.js', '/store/*', ignore),
+    ).toBe(true);
+  });
+});
+
+describe('locale redirect URL policy', () => {
+  test('detects a configured first language segment for relative or absolute URLs', () => {
+    expect(
+      getLanguageFromPath(
+        request('/store/cs/products?x=1'),
+        '/store/*',
+        languages,
+      ),
+    ).toBe('cs');
+    expect(
+      getLanguageFromPath(
+        request('https://example.com/en/products'),
+        '/',
+        languages,
+      ),
+    ).toBe('en');
+    expect(getLanguageFromPath(request('/cs/products'), '', languages)).toBe(
+      'cs',
+    );
+    expect(
+      getLanguageFromPath(request('/storecs/products'), '/store/*', languages),
+    ).toBe('cs');
+  });
+
+  test('switches localized dynamic paths while preserving mount, query and hash', () => {
+    expect(
+      buildLocalizedUrl(
+        request(
+          'https://example.com/store/en/products/red%20tractor?q=a%2Fb&sort=price#details',
+        ),
+        '/store/*',
+        'cs',
+        languages,
+        { '/products/:slug': { en: '/products/:slug', cs: '/produkty/:slug' } },
+      ),
+    ).toBe('/store/cs/produkty/red%20tractor?q=a%2Fb&sort=price#details');
+  });
+
+  test('supports root and empty mounts and missing locale mapping', () => {
+    for (const mount of ['/', '', '/*']) {
+      expect(
+        buildLocalizedUrl(
+          request('https://example.com/products?x=1#top'),
+          mount,
+          'cs',
+          languages,
+        ),
+      ).toBe('/cs/products?x=1#top');
+    }
+    expect(
+      buildLocalizedUrl(
+        request('https://example.com/store'),
+        '/store/*',
+        'cs',
+        languages,
+        false,
+      ),
+    ).toBe('/store/cs');
+  });
+
+  test('returns a non-cacheable temporary redirect with language negotiation headers', async () => {
+    const response = createLocaleRedirectResponse(
+      '/cs/produkty?sort=price#details',
+    );
+
+    expect(response.status).toBe(302);
+    expect(response.headers.get('Location')).toBe(
+      '/cs/produkty?sort=price#details',
+    );
+    expect(response.headers.get('Cache-Control')).toBe('private, no-store');
+    expect(response.headers.get('Vary')).toBe('Accept-Language, Cookie');
+    expect(await response.text()).toBe('');
+  });
+});

package/tests/localisedUrls.test.ts

@@ -7,7 +7,6 @@ import {
   matchPathPattern,
   resolveCanonicalLocalisedPath,
   resolveLocalisedPath,
-  resolveLocalisedUrlsConfig,
   validateLocalisedUrls,
 } from '../src/localisedUrls/index';
 
@@ -24,21 +23,6 @@ const createRoute = (
   children,
 });
 
-describe('resolveLocalisedUrlsConfig', () => {
-  test('is opt-in: only a non-empty map enables the feature', () => {
-    const map = { '/about': { en: '/about', cs: '/o-nas' } };
-    expect(resolveLocalisedUrlsConfig(map)).toEqual({ enabled: true, map });
-  });
-
-  test('absent, boolean and empty-map options resolve to disabled', () => {
-    const disabled = { enabled: false, map: {} };
-    expect(resolveLocalisedUrlsConfig(undefined)).toEqual(disabled);
-    expect(resolveLocalisedUrlsConfig(false)).toEqual(disabled);
-    expect(resolveLocalisedUrlsConfig(true)).toEqual(disabled);
-    expect(resolveLocalisedUrlsConfig({})).toEqual(disabled);
-  });
-});
-
 describe('localisedUrls', () => {
   test('leaves framework-internal Module Federation routes unlocalised', () => {
     const internalRoute = createRoute('_mf', [
@@ -207,9 +191,6 @@ describe('localisedUrls', () => {
       localisedUrls,
     );
 
-    expect(
-      applyLocalisedUrlsToRoutes(routes, ['en', 'cs', 'de'], localisedUrls),
-    ).toEqual(localisedRoutes);
     expect(localisedRoutes.map(route => route.path)).toEqual([
       ':lang/about',
       ':lang/o.nas',
@@ -304,62 +285,6 @@ describe('localisedUrls', () => {
     ]);
   });
 
-  test('expands flat locale-prefixed route paths with canonical keys', () => {
-    const routes = [
-      createRoute('/:lang/about'),
-      createRoute('/:lang/products/:slug'),
-    ];
-
-    const localisedRoutes = applyLocalisedUrlsToRoutes(routes, ['en', 'cs'], {
-      '/about': {
-        en: '/about',
-        cs: '/o-nas',
-      },
-      '/products/:slug': {
-        en: '/products/:slug',
-        cs: '/produkty/:slug',
-      },
-    });
-
-    expect(localisedRoutes.map(route => route.path)).toEqual([
-      ':lang/about',
-      ':lang/o-nas',
-      ':lang/products/:slug',
-      ':lang/produkty/:slug',
-    ]);
-  });
-
-  test('resolves current localized path to the target language', () => {
-    const localisedUrls = {
-      '/terms-of-service': {
-        en: '/terms-of-service',
-        cs: '/podminky-pouzivani',
-      },
-      '/products/:slug': {
-        en: '/products/:slug',
-        cs: '/produkty/:slug',
-      },
-    };
-
-    expect(
-      resolveLocalisedPath(
-        '/terms-of-service',
-        'cs',
-        ['en', 'cs'],
-        localisedUrls,
-      ),
-    ).toBe('/podminky-pouzivani');
-    expect(
-      resolveLocalisedPath('/produkty/cervena-bota', 'en', ['en', 'cs'], {
-        ...localisedUrls,
-        '/products/:slug': {
-          en: '/products/:slug',
-          cs: '/produkty/:slug',
-        },
-      }),
-    ).toBe('/products/cervena-bota');
-  });
-
   test('resolves optional route params', () => {
     const localisedUrls = {
       '/products/:slug?': {
@@ -455,30 +380,6 @@ describe('localisedUrls', () => {
     ).toBe('/products/new');
   });
 
-  test('reverse resolution is deterministic for equally specific matches', () => {
-    const firstOrder = {
-      '/z/:slug': {
-        en: '/x/:slug',
-        cs: '/z/:slug',
-      },
-      '/a/:section': {
-        en: '/:section/y',
-        cs: '/a/:section',
-      },
-    };
-    const reverseOrder = {
-      '/a/:section': firstOrder['/a/:section'],
-      '/z/:slug': firstOrder['/z/:slug'],
-    };
-
-    expect(
-      resolveCanonicalLocalisedPath('/x/y', ['en', 'cs'], firstOrder),
-    ).toBe('/a/x');
-    expect(
-      resolveCanonicalLocalisedPath('/x/y', ['en', 'cs'], reverseOrder),
-    ).toBe('/a/x');
-  });
-
   test('reverse resolution prefers the most specific localised source pattern', () => {
     const localisedUrls = {
       '/catalog/:section/:item/:detail': {
@@ -500,23 +401,6 @@ describe('localisedUrls', () => {
     ).toBe('/shoes/red');
   });
 
-  test('a specific localised source outranks a broad canonical source', () => {
-    const localisedUrls = {
-      '/:section/:slug': {
-        en: '/generic/:section/:slug',
-        cs: '/obecne/:section/:slug',
-      },
-      '/products/:id': {
-        en: '/fixed/:id',
-        cs: '/produkty/:id',
-      },
-    };
-
-    expect(
-      resolveCanonicalLocalisedPath('/fixed/red', ['en', 'cs'], localisedUrls),
-    ).toBe('/products/red');
-  });
-
   test('missing required target params never collapse into empty segments', () => {
     expect(() =>
       resolveLocalisedPath('/products/red-shoe', 'cs', ['en', 'cs'], {
@@ -537,31 +421,6 @@ describe('localisedUrls', () => {
     ).toThrow('Missing required path parameter "toString"');
   });
 
-  test('localises and canonicalises full target pathnames through one helper', () => {
-    const localisedUrls = {
-      '/products/:slug': {
-        en: '/products/:slug',
-        cs: '/produkty/:slug',
-      },
-    };
-
-    expect(
-      localiseTargetPathname(
-        '/en/products/cervena-bota',
-        'cs',
-        ['en', 'cs'],
-        localisedUrls,
-      ),
-    ).toBe('/cs/produkty/cervena-bota');
-    expect(
-      canonicalTargetPathname(
-        '/cs/produkty/cervena-bota',
-        ['en', 'cs'],
-        localisedUrls,
-      ),
-    ).toBe('/products/cervena-bota');
-  });
-
   test('strips case-insensitive locale prefixes before relocalising full pathnames', () => {
     const localisedUrls = {
       '/products/:slug': {

package/tests/paths.test.ts

@@ -0,0 +1,24 @@
+import { describe, expect, test } from '@rstest/core';
+import { canonicalPath, localizePath } from '../src/paths';
+
+const config = {
+  languages: ['en', 'cs'],
+  localisedUrls: {
+    '/products/:slug': { en: '/products/:slug', cs: '/produkty/:slug' },
+  },
+};
+
+describe('@modern-js/i18n-runtime-extensions/paths', () => {
+  test('localises the pathname while leaving query and hash verbatim', () => {
+    expect(
+      localizePath(
+        '/products/red-shoe?tag=boots&tag=sale#details',
+        'cs',
+        config,
+      ),
+    ).toBe('/cs/produkty/red-shoe?tag=boots&tag=sale#details');
+    expect(
+      canonicalPath('/CS/produkty/red-shoe?tag=boots#details', config),
+    ).toBe('/products/red-shoe?tag=boots#details');
+  });
+});

package/tests/reactLanguageSync.test.tsx

@@ -7,6 +7,14 @@ interface Target {
   language: string;
 }
 
+beforeEach(() => {
+  rstest.stubGlobal('IS_REACT_ACT_ENVIRONMENT', true);
+});
+
+afterEach(() => {
+  rstest.unstubAllGlobals();
+});
+
 test('an abandoned suspended render cannot publish an uncommitted target', async () => {
   let resolveFirst!: () => void;
   const firstChange = new Promise<void>(resolve => {
@@ -14,6 +22,7 @@ test('an abandoned suspended render cannot publish an uncommitted target', async
   });
   const changes: string[] = [];
   const commits: string[] = [];
+  let suspended = false;
   const neverSettles = new Promise<never>(() => undefined);
   const first = { id: 'first', language: 'en' };
   const speculative = { id: 'speculative', language: 'en' };
@@ -41,6 +50,7 @@ test('an abandoned suspended render cannot publish an uncommitted target', async
       },
     });
     if (suspend) {
+      suspended = true;
       throw neverSettles;
     }
     return <main>{target.id}</main>;
@@ -49,7 +59,11 @@ test('an abandoned suspended render cannot publish an uncommitted target', async
   const container = document.createElement('div');
   const root = createRoot(container);
   await act(async () => {
-    root.render(<Harness target={first} />);
+    root.render(
+      <Suspense fallback={<p>loading</p>}>
+        <Harness target={first} />
+      </Suspense>,
+    );
   });
   expect(changes).toEqual(['first']);
 
@@ -64,6 +78,11 @@ test('an abandoned suspended render cannot publish an uncommitted target', async
     await Promise.resolve();
   });
 
+  expect(suspended).toBe(true);
+  expect(container.textContent).toBe('first');
+  expect(changes).toEqual(['first']);
+  expect(commits).toEqual([]);
+
   await act(async () => {
     resolveFirst();
     await firstChange;

package/tests/clientRedirectIntegration.test.tsx

@@ -1,74 +0,0 @@
-import React, { act } from 'react';
-import { createRoot } from 'react-dom/client';
-import { useClientSideRedirect } from '../../plugin-i18n/src/runtime/hooks';
-
-const navigate = rstest.fn(async () => undefined);
-let location = {
-  pathname: '/cs/about',
-  search: '?from=test',
-  hash: '#section',
-};
-
-rstest.mock('../../plugin-i18n/src/runtime/routerAdapter', () => ({
-  useI18nRouterAdapter: () => ({
-    hasRouter: true,
-    location,
-    navigate,
-  }),
-}));
-
-test('canonicalizes successive prefixed routes in one mounted provider', async () => {
-  const previousTarget = process.env.MODERN_TARGET;
-  process.env.MODERN_TARGET = 'browser';
-  const instance = {
-    language: 'cs',
-    isInitialized: true,
-  } as Parameters<typeof useClientSideRedirect>[0];
-  const localisedUrls = {
-    '/about': { en: '/about', cs: '/o-nas' },
-    '/terms-of-service': {
-      en: '/terms-of-service',
-      cs: '/podminky-pouzivani',
-    },
-  };
-  const Harness = () => {
-    useClientSideRedirect(
-      instance,
-      true,
-      ['en', 'cs'],
-      'en',
-      undefined,
-      localisedUrls,
-    );
-    return null;
-  };
-  const container = document.createElement('div');
-  const root = createRoot(container);
-
-  try {
-    window.history.replaceState(null, '', '/cs/about?from=test#section');
-    await act(async () => root.render(<Harness />));
-    expect(navigate).toHaveBeenLastCalledWith('/cs/o-nas?from=test#section', {
-      replace: true,
-    });
-
-    location = {
-      pathname: '/cs/terms-of-service',
-      search: '',
-      hash: '',
-    };
-    window.history.replaceState(null, '', '/cs/terms-of-service');
-    await act(async () => root.render(<Harness />));
-    expect(navigate).toHaveBeenLastCalledWith('/cs/podminky-pouzivani', {
-      replace: true,
-    });
-    expect(navigate).toHaveBeenCalledTimes(2);
-  } finally {
-    await act(async () => root.unmount());
-    if (previousTarget === undefined) {
-      delete process.env.MODERN_TARGET;
-    } else {
-      process.env.MODERN_TARGET = previousTarget;
-    }
-  }
-});