@bleedingdev/modern-js-plugin-i18n 3.9.0-ultramodern.4 → 3.9.0-ultramodern.5

package/tests/localisedUrls.test.ts

@@ -1,4 +1,3 @@
-import type { NestedRouteForCli } from '@modern-js/types';
 import { describe, expect, test } from '@rstest/core';
 import { i18nPlugin as i18nCliPlugin } from '../src/cli';
 import {
@@ -7,19 +6,6 @@ import {
   matchesApiPrefix,
 } from '../src/server';
 
-const createRoute = (
-  path: string,
-  children?: NestedRouteForCli[],
-): NestedRouteForCli => ({
-  id: path,
-  path,
-  type: 'nested',
-  origin: 'file-system',
-  routeType: children ? 'layout' : 'page',
-  _component: `${path}.tsx`,
-  children,
-});
-
 const createRequestContext = (pathname: string) =>
   ({
     req: {
@@ -63,149 +49,16 @@ describe('cli modifyFileSystemRoutes', () => {
     expect(runtimePlugin?.config.reactI18next).toBe(false);
   });
 
-  const setupModifyRoutes = (localeDetection: Record<string, unknown>) => {
-    let modifyRoutes:
-      | ((args: { entrypoint: any; routes: any[] }) => {
-          entrypoint: any;
-          routes: any[];
-        })
-      | undefined;
-
-    i18nCliPlugin({ localeDetection }).setup({
+  test('upstream-style configs without a map keep routes untouched', () => {
+    const modifyRoutes = rstest.fn();
+    i18nCliPlugin({
+      localeDetection: { localePathRedirect: true, languages: ['en', 'cs'] },
+    }).setup({
       _internalRuntimePlugins: () => {},
-      modifyFileSystemRoutes: (fn: any) => {
-        modifyRoutes = fn;
-      },
       _internalServerPlugins: () => {},
+      modifyFileSystemRoutes: modifyRoutes,
     } as any);
-
-    expect(modifyRoutes).toBeDefined();
-    return modifyRoutes!;
-  };
-
-  const generateLocalisedRoutes = () => {
-    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 result.routes;
-  };
-
-  test('creates deterministic localized aliases with canonical route identity', () => {
-    const localisedRoutes = generateLocalisedRoutes();
-    expect(generateLocalisedRoutes()).toEqual(localisedRoutes);
-
-    const [localeLayout] = localisedRoutes;
-    expect(localeLayout.children?.map(route => route.path)).toEqual([
-      'about',
-      'o-nas',
-      'ueber-uns',
-      'products',
-      'produkty',
-      'produkte',
-      'docs',
-      'dokumenty',
-      'dokumente',
-    ]);
-    expect(localeLayout.children?.slice(0, 3)).toMatchObject([
-      {
-        _component: 'about.tsx',
-        modernCanonicalPath: '/about',
-        path: 'about',
-      },
-      {
-        _component: 'about.tsx',
-        modernCanonicalPath: '/about',
-        path: 'o-nas',
-      },
-      {
-        _component: 'about.tsx',
-        modernCanonicalPath: '/about',
-        path: 'ueber-uns',
-      },
-    ]);
-    for (const productRoute of localeLayout.children?.slice(3, 6) ?? []) {
-      expect(productRoute).toMatchObject({
-        _component: 'products.tsx',
-        modernCanonicalPath: '/products',
-      });
-      expect(productRoute.children?.[0]).toMatchObject({
-        _component: ':slug.tsx',
-        modernCanonicalPath: '/products/:slug',
-        path: ':slug',
-      });
-    }
-  });
-
-  test('upstream-style configs without a map keep routes untouched', () => {
-    const modifyRoutes = setupModifyRoutes({
-      localePathRedirect: true,
-      languages: ['en', 'cs'],
-    });
-    const routes = [createRoute(':lang', [createRoute('about')])];
-
-    const result = modifyRoutes({ entrypoint: { entryName: 'main' }, routes });
-
-    expect(result.routes).toBe(routes);
-  });
-
-  test('a configured map still expands localised route aliases', () => {
-    const modifyRoutes = setupModifyRoutes({
-      localePathRedirect: true,
-      languages: ['en', 'cs'],
-      localisedUrls: {
-        '/about': { en: '/about', cs: '/o-nas' },
-      },
-    });
-    const routes = [createRoute(':lang', [createRoute('about')])];
-
-    const result = modifyRoutes({ entrypoint: { entryName: 'main' }, routes });
-
-    const localeRoute = result.routes[0] as NestedRouteForCli;
-    expect(localeRoute.children?.map(route => route.path)).toEqual([
-      'about',
-      'o-nas',
-    ]);
+    expect(modifyRoutes).not.toHaveBeenCalled();
   });
 });
 
@@ -283,68 +136,6 @@ describe('i18n server API prefix skips', () => {
     }
   });
 
-  test('canonical redirect survives malformed percent-encoding', async () => {
-    const middlewares: any[] = [];
-    const routes = [{ entryName: 'main', entryPath: '', urlPath: '/' }];
-    let prepare: (() => void) | undefined;
-
-    i18nServerPlugin({
-      localeDetection: {
-        fallbackLanguage: 'en',
-        languages: ['en', 'cs'],
-        localePathRedirect: true,
-        localisedUrls: {
-          '/products/:slug': {
-            en: '/products/:slug',
-            cs: '/produkty/:slug',
-          },
-        },
-      },
-      staticRoutePrefixes: [],
-    }).setup({
-      getServerConfig: () => ({}),
-      getServerContext: () => ({ middlewares, routes }),
-      onPrepare: fn => {
-        prepare = fn;
-      },
-    } as any);
-
-    prepare?.();
-
-    const redirectMiddleware = middlewares.find(
-      middleware => middleware.name === 'i18n-server-middleware',
-    );
-    const createContext = (pathname: string) =>
-      ({
-        req: {
-          url: `http://localhost${pathname}`,
-          header: () => ({ host: 'localhost' }),
-        },
-        get: () => null,
-      }) as any;
-
-    // Sanity: well-formed non-canonical slugs still redirect.
-    const redirected = await redirectMiddleware.handler(
-      createContext('/cs/products/bota'),
-      async () => {},
-    );
-    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;
-    const response = await redirectMiddleware.handler(
-      createContext('/cs/produkty/%E0%A4%A'),
-      async () => {
-        nextCalls++;
-      },
-    );
-    expect(response).toBeUndefined();
-    expect(nextCalls).toBe(1);
-  });
-
   test('uses /api as the BFF prefix when BFF config is present without prefix', async () => {
     const middlewares: any[] = [];
     const routes = [{ entryName: 'main', entryPath: '', urlPath: '/' }];

package/tests/reactI18nextRuntimeBoundary.test.ts

@@ -1,13 +1,12 @@
 import { mkdtemp, rm } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
-import { basename, resolve } from 'node:path';
+import { resolve } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { describe, expect, test } from '@rstest/core';
 import { build } from 'esbuild';
 import i18next from 'i18next';
 import { createElement } from 'react';
 import { renderToStaticMarkup } from 'react-dom/server';
-import { i18nPlugin as noReactI18nextPlugin } from '../src/runtime/no-react-i18next';
 
 const runtimeRoot = resolve(__dirname, '../src/runtime');
 
@@ -37,31 +36,6 @@ describe('react-i18next runtime boundary', () => {
     ).resolves.toBeDefined();
   });
 
-  test('bundles the default runtime entry with the react-i18next adapter', async () => {
-    let adapterResolutions = 0;
-    await build({
-      bundle: true,
-      entryPoints: [resolve(runtimeRoot, 'index.tsx')],
-      format: 'esm',
-      packages: 'external',
-      platform: 'node',
-      plugins: [
-        {
-          name: 'observe-react-i18next',
-          setup(buildApi) {
-            buildApi.onResolve({ filter: /^react-i18next$/ }, args => {
-              adapterResolutions += 1;
-              return { external: true, path: args.path };
-            });
-          },
-        },
-      ],
-      write: false,
-    });
-
-    expect(adapterResolutions).toBeGreaterThan(0);
-  });
-
   test('gets router capabilities from the selected runtime provider', async () => {
     await expect(
       build({
@@ -90,61 +64,6 @@ describe('react-i18next runtime boundary', () => {
     ).resolves.toBeDefined();
   });
 
-  test('keeps expensive lifecycle helpers behind asynchronous bundle edges', async () => {
-    const result = await build({
-      bundle: true,
-      entryPoints: [resolve(runtimeRoot, 'pluginSetup.ts')],
-      format: 'esm',
-      metafile: true,
-      outdir: 'out',
-      packages: 'external',
-      platform: 'node',
-      splitting: true,
-      write: false,
-    });
-
-    const entryOutput = Object.values(result.metafile.outputs).find(output =>
-      output.entryPoint?.endsWith('/pluginSetup.ts'),
-    );
-    if (!entryOutput) {
-      throw new Error('pluginSetup entry output was not generated');
-    }
-    const dynamicOutputNames = entryOutput.imports
-      .filter(moduleImport => moduleImport.kind === 'dynamic-import')
-      .map(moduleImport => basename(moduleImport.path));
-    const dynamicOutputs = Object.entries(result.metafile.outputs)
-      .filter(([outputPath]) =>
-        dynamicOutputNames.includes(basename(outputPath)),
-      )
-      .map(([, output]) => output);
-    const dynamicEntries = dynamicOutputs.map(output =>
-      basename(output.entryPoint ?? ''),
-    );
-
-    expect(dynamicEntries).toEqual(
-      expect.arrayContaining(['middleware.ts', 'utils.ts']),
-    );
-  });
-
-  test('registers plugin lifecycle hooks synchronously', () => {
-    let beforeRender: unknown;
-    let rootWrapper: unknown;
-    const plugin = noReactI18nextPlugin({ reactI18next: false });
-    const setupResult = plugin.setup?.({
-      getRuntimeConfig: () => ({}),
-      onBeforeRender: hook => {
-        beforeRender = hook;
-      },
-      wrapRoot: wrapper => {
-        rootWrapper = wrapper;
-      },
-    } as any);
-
-    expect(setupResult).toBeUndefined();
-    expect(typeof beforeRender).toBe('function');
-    expect(typeof rootWrapper).toBe('function');
-  });
-
   test('shares Modern i18n context across independently bundled runtime copies', async () => {
     const tempDir = await mkdtemp(
       resolve(__dirname, '.modern-i18n-runtime-boundary-'),

package/tests/redirectPolicy.test.ts

@@ -5,41 +5,50 @@ import {
   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,
-    );
+describe('native locale redirect safeguards', () => {
+  test('retains configured ignores across runtime and server entry prefixes', () => {
+    const rules = ['/private'];
     expect(
-      isStaticResourceRequest('/en/upload/avatar.png', [], languages),
+      shouldIgnoreRuntimeRedirect('/cs/private/data', ['en', 'cs'], rules),
     ).toBe(true);
+    expect(
+      shouldIgnoreRuntimeRedirect('/cs/private-data', ['en', 'cs'], rules),
+    ).toBe(false);
+    expect(
+      shouldIgnoreServerRedirect(
+        '/app/cs/private/data',
+        '/app/*',
+        rules,
+        undefined,
+        ['en', 'cs'],
+      ),
+    ).toBe(true);
+    expect(
+      shouldIgnoreServerRedirect(
+        '/app/cs/private-data',
+        '/app/*',
+        rules,
+        undefined,
+        ['en', 'cs'],
+      ),
+    ).toBe(false);
   });
-
-  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(
+  test('retains configured and native static paths without fork policy', () => {
+    for (const pathname of [
+      '/static/app.js',
+      '/upload/a.png',
+      '/cs/assets/main.js',
+    ]) {
+      expect(isStaticResourceRequest(pathname, ['/assets'], ['en', 'cs'])).toBe(
         true,
       );
     }
+    expect(
+      isStaticResourceRequest(
+        '/assets-other/main.js',
+        ['/assets'],
+        ['en', 'cs'],
+      ),
+    ).toBe(false);
   });
 });