@bleedingdev/modern-js-plugin-i18n 3.5.0-ultramodern.9 → 3.5.0-ultramodern.91

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,
@@ -141,6 +216,25 @@ describe('cli modifyFileSystemRoutes', () => {
 });
 
 describe('localisedUrls', () => {
+  test('leaves framework-internal Module Federation routes unlocalised', () => {
+    const internalRoute = createRoute('_mf', [
+      createRoute('fragment', [createRoute('product-card')]),
+    ]);
+    const publicRoute = createRoute(':lang', [createRoute('products')]);
+    const routes = [internalRoute, publicRoute];
+
+    expect(() =>
+      validateLocalisedUrls(routes, ['en', 'cs'], {
+        '/products': { en: '/products', cs: '/produkty' },
+      }),
+    ).not.toThrow();
+    expect(
+      applyLocalisedUrlsToRoutes(routes, ['en', 'cs'], {
+        '/products': { en: '/products', cs: '/produkty' },
+      })[0],
+    ).toEqual(internalRoute);
+  });
+
   test('requires every localisable route path to define every language', () => {
     const routes = [createRoute(':lang', [createRoute('terms-of-service')])];
 
@@ -272,6 +366,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 +440,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 +653,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 +660,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/redirectPolicy.test.ts

@@ -0,0 +1,45 @@
+import { describe, expect, test } from '@rstest/core';
+import { shouldIgnoreRedirect as shouldIgnoreRuntimeRedirect } from '../src/runtime/utils';
+import {
+  isStaticResourceRequest,
+  shouldIgnoreRedirect as shouldIgnoreServerRedirect,
+} from '../src/server/redirectPolicy';
+
+const languages = ['en', 'cs'];
+
+const defaultSkippedPaths = [
+  '/backend-mf-manifest.json',
+  '/backendRemoteEntry.cjs',
+  '/mf-manifest.json',
+  '/mf-stats.json',
+  '/remoteEntry.js',
+  '/static/app.js',
+  '/upload/avatar.png',
+];
+
+describe('locale redirect default skip policy', () => {
+  test('skips ADR-0002 Module Federation and static endpoints on the server', () => {
+    for (const pathname of defaultSkippedPaths) {
+      expect(isStaticResourceRequest(pathname, [], languages)).toBe(true);
+      expect(shouldIgnoreServerRedirect(pathname, '/', undefined)).toBe(true);
+    }
+  });
+
+  test('skips language-prefixed static and upload endpoints', () => {
+    expect(isStaticResourceRequest('/cs/static/app.js', [], languages)).toBe(
+      true,
+    );
+    expect(
+      isStaticResourceRequest('/en/upload/avatar.png', [], languages),
+    ).toBe(true);
+  });
+
+  test('uses the same default skip policy in runtime redirects', () => {
+    for (const pathname of defaultSkippedPaths) {
+      expect(shouldIgnoreRuntimeRedirect(pathname, languages)).toBe(true);
+      expect(shouldIgnoreRuntimeRedirect(`/cs${pathname}`, languages)).toBe(
+        true,
+      );
+    }
+  });
+});