@bleedingdev/modern-js-plugin-i18n 3.9.0-ultramodern.8 → 3.9.3-ultramodern.1

package/tests/localisedUrls.test.ts

@@ -1,176 +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', () => {
-    const modifyRoutes = rstest.fn();
-    i18nCliPlugin({
-      localeDetection: { localePathRedirect: true, languages: ['en', 'cs'] },
-    }).setup({
-      _internalRuntimePlugins: () => {},
-      _internalServerPlugins: () => {},
-      modifyFileSystemRoutes: modifyRoutes,
-    } as any);
-    expect(modifyRoutes).not.toHaveBeenCalled();
-  });
-});
-
-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/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 });
-    }
-  });
-});

package/tests/redirectPolicy.test.ts

@@ -1,54 +0,0 @@
-import { describe, expect, test } from '@rstest/core';
-import { shouldIgnoreRedirect as shouldIgnoreRuntimeRedirect } from '../src/runtime/utils';
-import {
-  isStaticResourceRequest,
-  shouldIgnoreRedirect as shouldIgnoreServerRedirect,
-} from '../src/server/redirectPolicy';
-
-describe('native locale redirect safeguards', () => {
-  test('retains configured ignores across runtime and server entry prefixes', () => {
-    const rules = ['/private'];
-    expect(
-      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('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);
-  });
-});

package/tests/routerAdapter.test.tsx

@@ -1,221 +0,0 @@
-import {
-  InternalRuntimeContext,
-  RuntimeContext,
-} from '@modern-js/runtime/context';
-import type React from 'react';
-import type { PropsWithChildren } from 'react';
-import { act, useEffect } from 'react';
-import { createRoot, type Root } from 'react-dom/client';
-import { ModernI18nProvider, useModernI18n } from '../src/runtime/context';
-import type { I18nInstance } from '../src/runtime/i18n';
-import { Link } from '../src/runtime/Link';
-import {
-  createI18nRootWrapper,
-  type I18nLanguageSynchronizationProps,
-} from '../src/runtime/providerComposition';
-import {
-  I18nNavigationProvider,
-  useI18nRouterAdapter,
-} from '../src/runtime/routerAdapter';
-
-(
-  globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }
-).IS_REACT_ACT_ENVIRONMENT = true;
-
-const requestContext = {
-  request: {},
-  response: {},
-};
-
-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),
-    setLang: rstest.fn(async () => undefined),
-    changeLanguage: rstest.fn(async () => undefined),
-    services: {},
-    options: {},
-  };
-}
-
-async function renderI18nRoot(node: React.ReactNode) {
-  const container = document.createElement('div');
-  document.body.appendChild(container);
-  const root = createRoot(container);
-
-  await act(async () => {
-    root.render(
-      <RuntimeContext.Provider
-        value={{
-          isBrowser: true,
-          requestContext,
-          context: requestContext,
-        }}
-      >
-        {node}
-      </RuntimeContext.Provider>,
-    );
-  });
-
-  return {
-    container,
-    root,
-  };
-}
-
-function cleanup(rendered?: { container: HTMLElement; root: Root }) {
-  if (!rendered) {
-    return;
-  }
-  act(() => {
-    rendered.root.unmount();
-  });
-  rendered.container.remove();
-}
-
-describe('i18n runtime wrapRoot', () => {
-  let rendered: { container: HTMLElement; root: Root } | undefined;
-
-  afterEach(() => {
-    cleanup(rendered);
-    rendered = undefined;
-    rstest.useRealTimers();
-    rstest.restoreAllMocks();
-    window.history.replaceState(null, '', '/');
-  });
-
-  test('keeps the optional i18next provider inside Modern i18n context', async () => {
-    const i18nInstance = createI18nInstance('cs');
-    const observedLanguages: string[] = [];
-    const I18nextProvider = ({
-      children,
-      i18n,
-    }: PropsWithChildren<{ i18n: I18nInstance }>) => {
-      const { language } = useModernI18n();
-      observedLanguages.push(`${language}:${i18n.language}`);
-
-      return <section data-testid="i18next-provider">{children}</section>;
-    };
-    const App = () => <main>router content</main>;
-    const I18nRoot = createI18nRootWrapper({
-      htmlLangAttr: false,
-      localePathRedirect: false,
-      languages: ['en', 'cs'],
-      fallbackLanguage: 'en',
-      getLatestI18nInstance: () => i18nInstance,
-      getI18nextProvider: () => I18nextProvider,
-    })(App);
-
-    rendered = await renderI18nRoot(<I18nRoot />);
-
-    expect(observedLanguages).toEqual(['cs:cs']);
-    expect(rendered.container.textContent).toContain('router content');
-  });
-});
-
-describe('native navigation extension contract', () => {
-  test('renders the supplied router primitive and exposes provider-scoped navigation', async () => {
-    const navigate = rstest.fn();
-    const RouterLink = ({ to, children }: any) => (
-      <a href={to} data-native="yes">
-        {children}
-      </a>
-    );
-    function Consumer() {
-      const adapter = useI18nRouterAdapter();
-      expect(adapter.navigate).toBe(navigate);
-      expect(adapter.params).toEqual({ lang: 'cs' });
-      return <Link to="/products?tag=x#detail">Products</Link>;
-    }
-    const rendered = await renderI18nRoot(
-      <I18nNavigationProvider
-        value={{
-          hasRouter: true,
-          navigate,
-          params: { lang: 'cs' },
-          location: { pathname: '/cs/products', search: '', hash: '' },
-          Link: RouterLink,
-        }}
-      >
-        <ModernI18nProvider
-          value={{
-            language: 'cs',
-            i18nInstance: createI18nInstance('cs'),
-            languages: ['en', 'cs'],
-            localePathRedirect: true,
-          }}
-        >
-          <Consumer />
-        </ModernI18nProvider>
-      </I18nNavigationProvider>,
-    );
-    try {
-      expect(rendered.container.querySelector('a')?.getAttribute('href')).toBe(
-        '/cs/products?tag=x#detail',
-      );
-      expect(
-        rendered.container.querySelector('a')?.getAttribute('data-native'),
-      ).toBe('yes');
-      expect(navigate).not.toHaveBeenCalled();
-    } finally {
-      cleanup(rendered);
-    }
-  });
-});
-
-describe('native synchronization extension contract', () => {
-  test('uses the supplied component callback and preserves its state across parent renders', async () => {
-    const instance = createI18nInstance('en');
-    const synchronize = rstest.fn();
-    const mounts = rstest.fn();
-    const observed: I18nLanguageSynchronizationProps[] = [];
-    const Synchronization = (props: I18nLanguageSynchronizationProps) => {
-      observed.push(props);
-      useEffect(() => {
-        mounts();
-        props.setLang('cs');
-      }, []);
-      return props.children(synchronize);
-    };
-    const Root = createI18nRootWrapper({
-      htmlLangAttr: false,
-      localePathRedirect: true,
-      languages: ['en', 'cs'],
-      fallbackLanguage: 'en',
-      getLatestI18nInstance: () => instance,
-      getI18nextProvider: () => null,
-      LanguageSynchronization: Synchronization,
-    })(() => {
-      const { language } = useModernI18n();
-      return <main>{language}</main>;
-    });
-    window.history.replaceState(null, '', '/cs/products');
-    const rendered = await renderI18nRoot(<Root />);
-    try {
-      expect(rendered.container.textContent).toBe('cs');
-      expect(synchronize).toHaveBeenCalledWith('cs');
-      expect(observed.at(-1)?.i18nInstance).toBe(instance);
-      expect(observed.at(-1)?.pathname).toBe('/cs/products');
-      expect(observed.at(-1)?.prevLangRef.current).toBe('cs');
-      await act(async () => {
-        rendered.root.render(
-          <RuntimeContext.Provider
-            value={{ isBrowser: true, requestContext, context: requestContext }}
-          >
-            <Root unrelated="updated" />
-          </RuntimeContext.Provider>,
-        );
-      });
-      expect(mounts).toHaveBeenCalledTimes(1);
-      expect(rendered.container.textContent).toBe('cs');
-      expect(instance.changeLanguage).not.toHaveBeenCalled();
-    } finally {
-      cleanup(rendered);
-      window.history.replaceState(null, '', '/');
-    }
-  });
-});

package/tsconfig.json

@@ -1,15 +0,0 @@
-{
-  "extends": "@modern-js/tsconfig/base",
-  "compilerOptions": {
-    "declaration": false,
-    "lib": ["DOM", "ESNext", "dom.iterable"],
-    "jsx": "preserve",
-    // FORK: `baseUrl` removed. TypeScript 7 / tsgo reject it outright (TS5102),
-    // so this package's own tsconfig could not be typechecked at all. `paths`
-    // is empty here, so nothing resolved through baseUrl.
-    "isolatedModules": true,
-    "paths": {},
-    "rootDir": "./src"
-  },
-  "include": ["src", "types"]
-}