@bleedingdev/modern-js-i18n-runtime-extensions 3.9.0-ultramodern.3 → 3.9.0-ultramodern.5

package/tests/localisedUrls.test.ts

@@ -25,13 +25,11 @@ const createRoute = (
 });
 
 describe('resolveLocalisedUrlsConfig', () => {
-  test('is opt-in: only a non-empty map enables the feature', () => {
+  test('enables the feature only for a non-empty map', () => {
     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(map)).toEqual({ enabled: true, map });
     expect(resolveLocalisedUrlsConfig(undefined)).toEqual(disabled);
     expect(resolveLocalisedUrlsConfig(false)).toEqual(disabled);
     expect(resolveLocalisedUrlsConfig(true)).toEqual(disabled);
@@ -207,9 +205,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 +299,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 +394,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': {
@@ -537,31 +452,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,189 @@
+import { describe, expect, test } from '@rstest/core';
+import type { LocalisedUrlsMap } from '../src/localisedUrls';
+import { buildLocalizedUrl, canonicalPath, localizePath } from '../src/paths';
+
+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', () => {
+    expect(
+      buildLocalizedUrl(
+        '/files/resume%20drafts/Q1%20deck.pdf',
+        'cs',
+        languages,
+        localisedUrls,
+      ),
+    ).toBe('/cs/soubory/resume%20drafts/Q1%20deck.pdf');
+  });
+  test('explicit maps work without plugin registration and keep suffixes verbatim', () => {
+    const config = {
+      languages,
+      localisedUrls: {
+        '/docs/:slug?': { en: '/docs/:slug?', cs: '/dokumenty/:slug?' },
+      },
+    };
+    expect(localizePath('/docs?x=%2f&x=2#literal?query', 'cs', config)).toBe(
+      '/cs/dokumenty?x=%2f&x=2#literal?query',
+    );
+    expect(canonicalPath('/cs/dokumenty/%E0%A4%A', config)).toBe(
+      '/dokumenty/%E0%A4%A',
+    );
+    expect(localizePath('/[literal]?x=1#x', 'cs', { languages })).toBe(
+      '/cs/[literal]?x=1#x',
+    );
+  });
+});
+
+describe('migrated public mapped helper contract', () => {
+  const localisedUrls = {
+    '/terms-of-service': {
+      en: '/terms-of-service',
+      cs: '/podminky-pouzivani',
+    },
+    '/products': {
+      en: '/products',
+      cs: '/produkty',
+    },
+    '/products/:slug': {
+      en: '/products/:slug',
+      cs: '/produkty/:slug',
+    },
+    // Canonical key that matches no language pattern.
+    '/talks/:slug': {
+      en: '/lectures/:slug',
+      cs: '/prednasky/:slug',
+    },
+  };
+
+  const languages = ['en', 'cs'];
+  const pathsConfig = { languages, localisedUrls };
+
+  test('query and hash survive localized slug mapping', () => {
+    expect(
+      buildLocalizedUrl(
+        '/products/bota?tag=x#detail',
+        'cs',
+        languages,
+        localisedUrls,
+      ),
+    ).toBe('/cs/produkty/bota?tag=x#detail');
+  });
+
+  test('localizes canonical keys that match no language pattern', () => {
+    expect(
+      buildLocalizedUrl(
+        '/talks/ai-slop#abstract',
+        'cs',
+        languages,
+        localisedUrls,
+      ),
+    ).toBe('/cs/prednasky/ai-slop#abstract');
+    expect(
+      buildLocalizedUrl('/talks/ai-slop', 'en', languages, localisedUrls),
+    ).toBe('/en/lectures/ai-slop');
+  });
+
+  test('re-localizes already-localized paths', () => {
+    expect(
+      buildLocalizedUrl('/cs/produkty/bota#x', 'en', languages, localisedUrls),
+    ).toBe('/en/products/bota#x');
+  });
+  test('localizePath maps canonical paths per language', () => {
+    expect(localizePath('/products/bota', 'cs', pathsConfig)).toBe(
+      '/cs/produkty/bota',
+    );
+    expect(localizePath('/talks/x', 'en', pathsConfig)).toBe('/en/lectures/x');
+  });
+
+  test('canonicalPath strips language and reverse-maps localized slugs', () => {
+    expect(canonicalPath('/cs/produkty/bota', pathsConfig)).toBe(
+      '/products/bota',
+    );
+    expect(canonicalPath('/en/lectures/x?q=1#h', pathsConfig)).toBe(
+      '/talks/x?q=1#h',
+    );
+    expect(canonicalPath('/cs', pathsConfig)).toBe('/');
+    expect(canonicalPath('/en/products', pathsConfig)).toBe('/products');
+  });
+});

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