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

package/tests/link.test.tsx

@@ -1,139 +0,0 @@
-import type { I18nInstance } from '../src/runtime/i18n';
-import { detectLanguageWithPriority } from '../src/runtime/i18n/detection';
-import { interpolateRouteParams } from '../src/runtime/Link';
-import { canonicalPath, localizePath } from '../src/runtime/localizedPaths';
-import { buildLocalizedUrl, splitUrlTarget } from '../src/runtime/utils';
-
-const languages = ['en', 'cs'];
-
-function createI18nInstance(language = 'en'): I18nInstance {
-  return {
-    language,
-    isInitialized: true,
-    init: () => Promise.resolve(undefined),
-    use: () => {},
-    t: (key: string | string[]) => (Array.isArray(key) ? key[0] : key),
-    createInstance: () => createI18nInstance(language),
-    services: {},
-    options: {},
-  };
-}
-
-describe('splitUrlTarget public compatibility export', () => {
-  test('retains the shared suffix splitter', () => {
-    expect(splitUrlTarget('/a?q=1#x')).toEqual({
-      pathname: '/a',
-      search: '?q=1',
-      hash: '#x',
-    });
-  });
-});
-
-describe('buildLocalizedUrl suffix handling', () => {
-  test('hash-only target keeps the hash and drops the trailing slash', () => {
-    expect(buildLocalizedUrl('/#work-with-me', 'en', languages)).toBe(
-      '/en#work-with-me',
-    );
-  });
-
-  test('query-only target keeps the query', () => {
-    expect(buildLocalizedUrl('/products?tag=x', 'en', languages)).toBe(
-      '/en/products?tag=x',
-    );
-  });
-
-  test('root path', () => {
-    expect(buildLocalizedUrl('/', 'cs', languages)).toBe('/cs');
-  });
-});
-
-describe('interpolateRouteParams', () => {
-  test('interpolates $param and :param segments', () => {
-    expect(interpolateRouteParams('/talks/$slug', { slug: 'ai slop' })).toBe(
-      '/talks/ai%20slop',
-    );
-    expect(interpolateRouteParams('/talks/:slug', { slug: 'x' })).toBe(
-      '/talks/x',
-    );
-  });
-
-  test('drops missing optional segments', () => {
-    expect(interpolateRouteParams('/opt/{-$slug}', {})).toBe('/opt');
-    expect(interpolateRouteParams('/opt/:slug?', {})).toBe('/opt');
-    expect(interpolateRouteParams('/opt/{-$slug}', { slug: 'v' })).toBe(
-      '/opt/v',
-    );
-  });
-
-  test('expands splat params', () => {
-    expect(interpolateRouteParams('/files/$', { _splat: 'a/b' })).toBe(
-      '/files/a/b',
-    );
-    expect(interpolateRouteParams('/files/*', { '*': 'a' })).toBe('/files/a');
-  });
-});
-
-describe('native URL strategy helpers', () => {
-  test('preserves suffixes when adding or stripping only a language prefix', () => {
-    expect(localizePath('/products?q=1#x', 'cs', { languages })).toBe(
-      '/cs/products?q=1#x',
-    );
-    expect(canonicalPath('/CS/products?q=1#x', { languages })).toBe(
-      '/products?q=1#x',
-    );
-  });
-});
-
-describe('language detection priority', () => {
-  test('path locale overrides stale SSR data', async () => {
-    const previousSsrData = (window as any)._SSR_DATA;
-    (window as any)._SSR_DATA = { data: { i18nData: { lng: 'en' } } };
-
-    try {
-      await expect(
-        detectLanguageWithPriority(createI18nInstance('en'), {
-          languages,
-          fallbackLanguage: 'en',
-          localePathRedirect: true,
-          i18nextDetector: false,
-          detection: {},
-          userInitOptions: {},
-          pathname: '/cs/produkty',
-          ssrContext: undefined,
-        }),
-      ).resolves.toEqual({ detectedLanguage: 'cs', finalLanguage: 'cs' });
-    } finally {
-      if (previousSsrData === undefined) {
-        delete (window as any)._SSR_DATA;
-      } else {
-        (window as any)._SSR_DATA = previousSsrData;
-      }
-    }
-  });
-
-  test('regional SSR language resolves to supported base language', async () => {
-    const previousSsrData = (window as any)._SSR_DATA;
-    (window as any)._SSR_DATA = { data: { i18nData: { lng: 'en-US' } } };
-
-    try {
-      await expect(
-        detectLanguageWithPriority(createI18nInstance('cs'), {
-          languages,
-          fallbackLanguage: 'cs',
-          localePathRedirect: true,
-          i18nextDetector: false,
-          detection: {},
-          userInitOptions: {},
-          pathname: '/products',
-          ssrContext: undefined,
-        }),
-      ).resolves.toEqual({ detectedLanguage: 'en', finalLanguage: 'en' });
-    } finally {
-      if (previousSsrData === undefined) {
-        delete (window as any)._SSR_DATA;
-      } else {
-        (window as any)._SSR_DATA = previousSsrData;
-      }
-    }
-  });
-});

package/tests/localisedRouteGeneration.test.ts

@@ -1,159 +0,0 @@
-import type { AppTools, CliPlugin } from '@modern-js/app-tools';
-import { createAsyncHook, createPluginManager } from '@modern-js/plugin';
-import {
-  createContext,
-  initAppContext,
-  initPluginAPI,
-} from '@modern-js/plugin/cli';
-import type { NestedRouteForCli } from '@modern-js/types';
-import { describe, expect, test } from '@rstest/core';
-import { type I18nPluginOptions, i18nPlugin } from '../src/cli';
-
-/**
- * Localised route generation must reach a bare `appTools()` consumer.
- *
- * The fork used to register it only from `@modern-js/i18n-integration`, which
- * `ultramodernAppTools()` composes but plain `appTools()` does not — so an app
- * declaring `localeDetection.localisedUrls` got a 404 on every mapped path
- * under SSR. These cases deliberately register *only* the native plugin, with
- * no integration plugin in the manager, so a regression back to the opt-in
- * wiring fails here.
- */
-
-const createRoute = (
-  path: string,
-  children?: NestedRouteForCli[],
-): NestedRouteForCli => ({
-  id: path,
-  path,
-  type: 'nested',
-  origin: 'file-system',
-  routeType: children ? 'layout' : 'page',
-  _component: `${path}.tsx`,
-  children,
-});
-
-async function createNativeOnlyHarness(options: I18nPluginOptions = {}) {
-  const manager = createPluginManager();
-  const routeHost: CliPlugin<AppTools> = {
-    name: 'test-route-host',
-    registryHooks: { modifyFileSystemRoutes: createAsyncHook<any>() },
-    setup() {
-      // Only supplies the hook registry the app-tools router owns.
-    },
-  };
-
-  manager.addPlugins([i18nPlugin(options), routeHost]);
-  const plugins = manager.getPlugins() as CliPlugin<AppTools>[];
-  const context = await createContext<AppTools>({
-    appContext: initAppContext({
-      packageName: 'plugin-i18n-native-only-test',
-      configFile: false,
-      command: 'build',
-      appDirectory: process.cwd(),
-      metaName: 'modern-js',
-      plugins,
-    }),
-    config: {},
-    normalizedConfig: {} as any,
-  });
-  const api = initPluginAPI<AppTools>({ context, pluginManager: manager });
-  for (const plugin of plugins) {
-    await plugin.setup?.(api);
-  }
-  return api.getHooks().modifyFileSystemRoutes.call;
-}
-
-const entrypoint = { entryName: 'main' } as any;
-
-const localisedUrls = {
-  '/about': { en: '/about', cs: '/o-nas' },
-  '/products/:slug': { en: '/products/:slug', cs: '/produkty/:slug' },
-};
-
-describe('native localised route generation', () => {
-  test('expands mapped locale paths without the integration plugin', async () => {
-    const modifyRoutes = await createNativeOnlyHarness({
-      localeDetection: {
-        localePathRedirect: true,
-        languages: ['en', 'cs'],
-        localisedUrls,
-      },
-    });
-
-    const result = await modifyRoutes({
-      entrypoint,
-      routes: [
-        createRoute(':lang', [
-          createRoute('about'),
-          createRoute('products/:slug'),
-        ]),
-      ],
-    });
-
-    const paths = result.routes[0].children?.map(
-      (route: NestedRouteForCli) => route.path,
-    );
-    expect(paths).toContain('about');
-    expect(paths).toContain('o-nas');
-    expect(paths).toContain('products/:slug');
-    expect(paths).toContain('produkty/:slug');
-  });
-
-  test('leaves routes untouched when no map is declared', async () => {
-    const modifyRoutes = await createNativeOnlyHarness({
-      localeDetection: {
-        localePathRedirect: true,
-        languages: ['en', 'cs'],
-      },
-    });
-
-    const input = [createRoute(':lang', [createRoute('about')])];
-    const result = await modifyRoutes({ entrypoint, routes: input });
-
-    expect(
-      result.routes[0].children?.map((r: NestedRouteForCli) => r.path),
-    ).toEqual(['about']);
-  });
-
-  test('leaves routes untouched without localePathRedirect', async () => {
-    const modifyRoutes = await createNativeOnlyHarness({
-      localeDetection: {
-        languages: ['en', 'cs'],
-        localisedUrls,
-      },
-    });
-
-    const input = [createRoute(':lang', [createRoute('about')])];
-    const result = await modifyRoutes({ entrypoint, routes: input });
-
-    expect(
-      result.routes[0].children?.map((r: NestedRouteForCli) => r.path),
-    ).toEqual(['about']);
-  });
-
-  test('resolves the map from a per-entry locale detection override', async () => {
-    const modifyRoutes = await createNativeOnlyHarness({
-      localeDetection: {
-        localePathRedirect: true,
-        languages: ['en'],
-        localeDetectionByEntry: {
-          main: {
-            localePathRedirect: true,
-            languages: ['en', 'cs'],
-            localisedUrls,
-          },
-        },
-      },
-    });
-
-    const result = await modifyRoutes({
-      entrypoint,
-      routes: [createRoute(':lang', [createRoute('about')])],
-    });
-
-    expect(
-      result.routes[0].children?.map((r: NestedRouteForCli) => r.path),
-    ).toContain('o-nas');
-  });
-});

package/tests/localisedUrls.test.ts

@@ -1,193 +0,0 @@
-import { describe, expect, test } from '@rstest/core';
-import { i18nPlugin as i18nCliPlugin } from '../src/cli';
-import {
-  collectApiPrefixes,
-  i18nServerPlugin,
-  matchesApiPrefix,
-} from '../src/server';
-
-const createRequestContext = (pathname: string) =>
-  ({
-    req: {
-      url: `http://localhost${pathname}`,
-    },
-  }) as any;
-
-describe('cli modifyFileSystemRoutes', () => {
-  test('uses the no-react runtime entry when reactI18next is disabled', () => {
-    let runtimePlugin:
-      | {
-          path: string;
-          config: Record<string, unknown>;
-        }
-      | undefined;
-
-    i18nCliPlugin({ reactI18next: false }).setup({
-      _internalRuntimePlugins: (fn: any) => {
-        const plugins: Array<{
-          path: string;
-          config: Record<string, unknown>;
-        }> = [];
-        fn({
-          entrypoint: { entryName: 'main' },
-          plugins,
-        });
-        runtimePlugin = plugins[0];
-      },
-      modifyFileSystemRoutes: () => {},
-      _internalServerPlugins: () => {},
-      getAppContext: () => ({
-        appDirectory: process.cwd(),
-        metaName: 'modern-js',
-      }),
-      getNormalizedConfig: () => ({}),
-    } as any);
-
-    expect(runtimePlugin?.path).toBe(
-      '@modern-js/plugin-i18n/runtime/no-react-i18next',
-    );
-    expect(runtimePlugin?.config.reactI18next).toBe(false);
-  });
-
-  test('upstream-style configs without a map keep routes untouched', async () => {
-    // The hook is registered unconditionally now that route expansion is a
-    // native feature; what matters is that a config with no `localisedUrls`
-    // map gets its routes back byte-for-byte instead of a locale-expanded tree.
-    let handler:
-      | ((args: { entrypoint: unknown; routes: unknown[] }) => Promise<{
-          routes: unknown[];
-        }>)
-      | undefined;
-
-    i18nCliPlugin({
-      localeDetection: { localePathRedirect: true, languages: ['en', 'cs'] },
-    }).setup({
-      _internalRuntimePlugins: () => {},
-      _internalServerPlugins: () => {},
-      modifyFileSystemRoutes: (fn: any) => {
-        handler = fn;
-      },
-    } as any);
-
-    const routes = [{ id: 'about', path: 'about', type: 'nested' }];
-    const result = await handler?.({
-      entrypoint: { entryName: 'main' },
-      routes,
-    });
-
-    expect(result?.routes).toEqual(routes);
-  });
-});
-
-describe('i18n server API prefix skips', () => {
-  test('collects API route prefixes and normalized BFF config prefixes', () => {
-    expect(
-      collectApiPrefixes(
-        [
-          { entryName: 'main', isApi: false, urlPath: '/' },
-          { isApi: true, urlPath: '/bff-api' },
-          { isApi: true, urlPath: '/rpc/*' },
-          { isApi: true, urlPath: '/' },
-          { isApi: true },
-        ],
-        ['bff-api/', '/internal-api'],
-      ),
-    ).toEqual(['/bff-api', '/rpc', '/internal-api']);
-  });
-
-  test('matches API prefixes by exact path or slash-delimited segment', () => {
-    const prefixes = ['/bff-api'];
-
-    expect(matchesApiPrefix('/bff-api', prefixes)).toBe(true);
-    expect(matchesApiPrefix('/bff-api/ping', prefixes)).toBe(true);
-    expect(matchesApiPrefix('/bff-api-v2', prefixes)).toBe(false);
-    expect(matchesApiPrefix('/bff-api-v2/ping', prefixes)).toBe(false);
-  });
-
-  test('skips language detector and redirect middleware for API routes', async () => {
-    const middlewares: any[] = [];
-    const routes = [
-      { entryName: 'main', entryPath: '', urlPath: '/' },
-      { entryPath: '', isApi: true, urlPath: '/bff-api' },
-    ];
-    let prepare: (() => void) | undefined;
-
-    i18nServerPlugin({
-      localeDetection: {
-        fallbackLanguage: 'en',
-        languages: ['en', 'cs'],
-        localePathRedirect: true,
-      },
-      staticRoutePrefixes: [],
-    }).setup({
-      getServerConfig: () => ({}),
-      getServerContext: () => ({ middlewares, routes }),
-      onPrepare: fn => {
-        prepare = fn;
-      },
-    } as any);
-
-    prepare?.();
-
-    const detectorMiddleware = middlewares.find(
-      middleware => middleware.name === 'i18n-language-detector',
-    );
-    const redirectMiddleware = middlewares.find(
-      middleware => middleware.name === 'i18n-server-middleware',
-    );
-
-    expect(detectorMiddleware).toBeDefined();
-    expect(redirectMiddleware).toBeDefined();
-
-    for (const middleware of [detectorMiddleware, redirectMiddleware]) {
-      let nextCalls = 0;
-      const response = await middleware.handler(
-        createRequestContext('/bff-api/ping'),
-        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: '/' }];
-    let prepare: (() => void) | undefined;
-
-    i18nServerPlugin({
-      localeDetection: {
-        fallbackLanguage: 'en',
-        languages: ['en', 'cs'],
-        localePathRedirect: true,
-      },
-      staticRoutePrefixes: [],
-    }).setup({
-      getServerConfig: () => ({ bff: {} }),
-      getServerContext: () => ({ middlewares, routes }),
-      onPrepare: fn => {
-        prepare = fn;
-      },
-    } as any);
-
-    prepare?.();
-
-    const redirectMiddleware = middlewares.find(
-      middleware => middleware.name === 'i18n-server-middleware',
-    );
-
-    let nextCalls = 0;
-    const response = await redirectMiddleware.handler(
-      createRequestContext('/api/ping'),
-      async () => {
-        nextCalls++;
-      },
-    );
-
-    expect(response).toBeUndefined();
-    expect(nextCalls).toBe(1);
-  });
-});

package/tests/mappedUrlStrategyDerivation.test.ts

@@ -1,62 +0,0 @@
-import { describe, expect, test } from '@rstest/core';
-import { resolveMappedUrlStrategy } from '../src/shared/mappedUrlStrategy';
-
-/**
- * Mapped locale URLs must work for a bare `appTools()` consumer that only
- * declares `localeDetection.localisedUrls`. The map is plain data, so it
- * survives the JSON boundary a `urlStrategy` object does not; the runtime
- * derives its policy from it, and the server derives the same policy from the
- * same shared module.
- */
-
-const localisedUrls = {
-  '/terms-of-service': { en: '/terms-of-service', cs: '/obchodni-podminky' },
-  '/products/:slug': { en: '/products/:slug', cs: '/produkty/:slug' },
-};
-const languages = ['en', 'cs'];
-
-describe('mapped url strategy derivation', () => {
-  test('derives a localizing strategy from localisedUrls', () => {
-    const strategy = resolveMappedUrlStrategy({ localisedUrls });
-
-    expect(strategy).toBeDefined();
-    expect(
-      strategy?.localizePathname?.('/terms-of-service', 'cs', languages),
-    ).toBe('/cs/obchodni-podminky');
-    expect(
-      strategy?.localizePathname?.('/terms-of-service', 'en', languages),
-    ).toBe('/en/terms-of-service');
-    expect(
-      strategy?.canonicalPathname?.('/cs/obchodni-podminky', languages),
-    ).toBe('/terms-of-service');
-  });
-
-  test('round-trips a parameterised mapped route', () => {
-    const strategy = resolveMappedUrlStrategy({ localisedUrls });
-    const localized = strategy?.localizePathname?.(
-      '/products/widget',
-      'cs',
-      languages,
-    );
-
-    expect(localized).toBe('/cs/produkty/widget');
-    expect(strategy?.canonicalPathname?.(localized!, languages)).toBe(
-      '/products/widget',
-    );
-  });
-
-  test('leaves unmapped paths on the plain language prefix', () => {
-    const strategy = resolveMappedUrlStrategy({ localisedUrls });
-
-    expect(strategy?.localizePathname?.('/unmapped', 'cs', languages)).toBe(
-      '/cs/unmapped',
-    );
-  });
-
-  test('derives nothing without a usable map', () => {
-    expect(resolveMappedUrlStrategy(undefined)).toBeUndefined();
-    expect(resolveMappedUrlStrategy({})).toBeUndefined();
-    expect(resolveMappedUrlStrategy({ localisedUrls: {} })).toBeUndefined();
-    expect(resolveMappedUrlStrategy({ localisedUrls: true })).toBeUndefined();
-  });
-});

package/tests/reactI18nextRuntimeBoundary.test.ts

@@ -1,117 +0,0 @@
-import { mkdtemp, rm } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-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';
-
-const runtimeRoot = resolve(__dirname, '../src/runtime');
-
-describe('react-i18next runtime boundary', () => {
-  test('bundles the disabled runtime entry when react-i18next is unavailable', async () => {
-    await expect(
-      build({
-        bundle: true,
-        entryPoints: [resolve(runtimeRoot, 'no-react-i18next.tsx')],
-        format: 'esm',
-        packages: 'external',
-        platform: 'node',
-        plugins: [
-          {
-            name: 'reject-react-i18next',
-            setup(buildApi) {
-              buildApi.onResolve({ filter: /^react-i18next$/ }, () => {
-                throw new Error(
-                  'disabled runtime entry reached optional react-i18next',
-                );
-              });
-            },
-          },
-        ],
-        write: false,
-      }),
-    ).resolves.toBeDefined();
-  });
-
-  test('gets router capabilities from the selected runtime provider', async () => {
-    await expect(
-      build({
-        bundle: true,
-        entryPoints: [resolve(runtimeRoot, 'routerAdapter.tsx')],
-        format: 'esm',
-        packages: 'external',
-        platform: 'neutral',
-        plugins: [
-          {
-            name: 'reject-direct-router-provider',
-            setup(buildApi) {
-              buildApi.onResolve(
-                { filter: /^@modern-js\/runtime\/router$/ },
-                () => {
-                  throw new Error(
-                    'The i18n adapter loaded the React Router provider directly.',
-                  );
-                },
-              );
-            },
-          },
-        ],
-        write: false,
-      }),
-    ).resolves.toBeDefined();
-  });
-
-  test('shares Modern i18n context across independently bundled runtime copies', async () => {
-    const tempDir = await mkdtemp(
-      resolve(__dirname, '.modern-i18n-runtime-boundary-'),
-    );
-    try {
-      const contextEntry = resolve(runtimeRoot, 'context.tsx');
-      const copies = await Promise.all(
-        ['copy-a.mjs', 'copy-b.mjs'].map(async filename => {
-          const outfile = resolve(tempDir, filename);
-          await build({
-            bundle: true,
-            entryPoints: [contextEntry],
-            format: 'esm',
-            jsx: 'automatic',
-            outfile,
-            packages: 'external',
-            platform: 'node',
-          });
-          return import(pathToFileURL(outfile).href);
-        }),
-      );
-      const [copyA, copyB] = copies;
-      const instance = i18next.createInstance();
-      await instance.init({
-        initImmediate: false,
-        lng: 'cs',
-        resources: { cs: { translation: { language: 'Jazyk' } } },
-      });
-      const Consumer = () =>
-        createElement('span', null, copyB.useModernI18n().language);
-
-      const html = renderToStaticMarkup(
-        createElement(
-          copyA.ModernI18nProvider,
-          {
-            value: {
-              i18nInstance: instance,
-              language: 'cs',
-              languages: ['en', 'cs'],
-            },
-          },
-          createElement(Consumer),
-        ),
-      );
-
-      expect(html).toBe('<span>cs</span>');
-    } finally {
-      await rm(tempDir, { force: true, recursive: true });
-    }
-  });
-});