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

package/tests/redirectPolicy.test.ts

@@ -1,107 +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('never locale-redirects federation artifacts, with no URL strategy configured', () => {
-    // 3.9.0-ultramodern.9 regression: with `localisedUrls: {}` no strategy is
-    // derived, and the backend federation manifest was redirected to
-    // `/en/backend-mf-manifest.json` (an HTML page) — the Node backend
-    // federation proof then read a 404 instead of the manifest.
-    const languages = ['en', 'cs'];
-    for (const pathname of [
-      '/backend-mf-manifest.json',
-      '/backendRemoteEntry.cjs',
-      '/mf-manifest.json',
-      '/mf-stats.json',
-      '/remoteEntry.js',
-      '/remoteEntry.catalog.js',
-      '/backendRemoteEntry.catalog.cjs',
-      '/cs/backend-mf-manifest.json',
-    ]) {
-      expect(
-        shouldIgnoreServerRedirect(
-          pathname,
-          '/*',
-          undefined,
-          undefined,
-          languages,
-        ),
-      ).toBe(true);
-      expect(
-        shouldIgnoreServerRedirect(
-          `/app${pathname}`,
-          '/app/*',
-          undefined,
-          undefined,
-          languages,
-        ),
-      ).toBe(true);
-      expect(
-        shouldIgnoreRuntimeRedirect(pathname, languages, undefined, undefined),
-      ).toBe(true);
-    }
-    // A page is still redirected.
-    expect(
-      shouldIgnoreServerRedirect(
-        '/products',
-        '/*',
-        undefined,
-        undefined,
-        languages,
-      ),
-    ).toBe(false);
-    expect(
-      shouldIgnoreRuntimeRedirect('/products', languages, undefined, undefined),
-    ).toBe(false);
-  });
-
-  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/tests/urlStrategySerialization.test.ts

@@ -1,122 +0,0 @@
-import { describe, expect, test } from '@rstest/core';
-import { buildLocalizedUrl, shouldIgnoreRedirect } from '../src/runtime/utils';
-import { resolveMappedUrlStrategy } from '../src/server/mappedUrlStrategy';
-import {
-  buildLocalizedUrl as buildServerLocalizedUrl,
-  shouldIgnoreRedirect as shouldIgnoreServerRedirect,
-} from '../src/server/redirectPolicy';
-import {
-  asI18nUrlStrategy,
-  isUnusableI18nUrlStrategy,
-} from '../src/shared/urlStrategy';
-
-// What a configured `urlStrategy` looks like after the generated runtime
-// registration has carried it through JSON: an object with no methods left.
-const serializedStrategy = {} as any;
-
-const workingStrategy = {
-  localizePathname: (pathname: string, language: string) =>
-    `/${language}${pathname}`,
-  canonicalPathname: (pathname: string) => pathname,
-};
-
-const createRequest = (pathname: string) =>
-  ({ url: `https://example.test${pathname}` }) as any;
-
-describe('URL strategy that lost its methods in transit', () => {
-  test('is recognised as unusable rather than accepted', () => {
-    expect(asI18nUrlStrategy(serializedStrategy)).toBeUndefined();
-    expect(isUnusableI18nUrlStrategy(serializedStrategy)).toBe(true);
-    expect(isUnusableI18nUrlStrategy(undefined)).toBe(false);
-    expect(asI18nUrlStrategy(workingStrategy)).toBe(workingStrategy);
-    expect(isUnusableI18nUrlStrategy(workingStrategy)).toBe(false);
-  });
-
-  test('a partial strategy is unusable too', () => {
-    expect(asI18nUrlStrategy({ localizePathname: () => '/x' })).toBeUndefined();
-  });
-
-  test('the client link builder falls back instead of throwing', () => {
-    expect(() =>
-      buildLocalizedUrl('/about', 'cs', ['en', 'cs'], serializedStrategy),
-    ).not.toThrow();
-    expect(
-      buildLocalizedUrl('/about', 'cs', ['en', 'cs'], serializedStrategy),
-    ).toBe('/cs/about');
-    expect(
-      buildLocalizedUrl('/about', 'cs', ['en', 'cs'], workingStrategy),
-    ).toBe('/cs/about');
-  });
-
-  test('the client redirect check falls back instead of throwing', () => {
-    expect(() =>
-      shouldIgnoreRedirect(
-        '/about',
-        ['en', 'cs'],
-        undefined,
-        serializedStrategy,
-      ),
-    ).not.toThrow();
-    expect(
-      shouldIgnoreRedirect(
-        '/about',
-        ['en', 'cs'],
-        undefined,
-        serializedStrategy,
-      ),
-    ).toBe(false);
-  });
-
-  test('the server redirect builder falls back instead of throwing', () => {
-    expect(() =>
-      buildServerLocalizedUrl(
-        createRequest('/about'),
-        '/*',
-        'cs',
-        ['en', 'cs'],
-        serializedStrategy,
-      ),
-    ).not.toThrow();
-    expect(
-      buildServerLocalizedUrl(
-        createRequest('/about'),
-        '/*',
-        'cs',
-        ['en', 'cs'],
-        serializedStrategy,
-      ),
-    ).toBe('/cs/about');
-  });
-
-  test('the server redirect skip check falls back instead of throwing', () => {
-    expect(() =>
-      shouldIgnoreServerRedirect(
-        '/about',
-        '/*',
-        undefined,
-        serializedStrategy,
-        ['en', 'cs'],
-      ),
-    ).not.toThrow();
-  });
-});
-
-describe('serializable mapped locale URLs', () => {
-  test('produce a working strategy on the server', () => {
-    const strategy = resolveMappedUrlStrategy({
-      languages: ['en', 'cs'],
-      localisedUrls: { '/about': { en: '/about', cs: '/o-nas' } },
-    });
-
-    expect(strategy).toBeDefined();
-    expect(strategy?.localizePathname('/about', 'cs', ['en', 'cs'])).toBe(
-      '/cs/o-nas',
-    );
-  });
-
-  test('are absent when no map is configured', () => {
-    expect(resolveMappedUrlStrategy(undefined)).toBeUndefined();
-    expect(resolveMappedUrlStrategy({ languages: ['en'] })).toBeUndefined();
-    expect(resolveMappedUrlStrategy({ localisedUrls: {} })).toBeUndefined();
-  });
-});

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"]
-}