@bleedingdev/modern-js-plugin-i18n 3.4.0-ultramodern.1 → 3.4.0-ultramodern.3

package/tests/i18nUtils.test.ts

@@ -4,6 +4,10 @@ import {
   DEFAULT_I18NEXT_BACKEND_OPTIONS as NODE_DEFAULT_I18NEXT_BACKEND_OPTIONS,
   resolveDefaultLocalesDir,
 } from '../src/runtime/i18n/backend/defaults.node';
+import {
+  FsBackendWithSave,
+  resolveFsBackendConstructor,
+} from '../src/runtime/i18n/backend/middleware.node';
 import { initializeI18nInstance } from '../src/runtime/i18n/utils';
 
 function createBackendI18nInstance(): I18nInstance {
@@ -20,6 +24,36 @@ function createBackendI18nInstance(): I18nInstance {
 }
 
 describe('i18n runtime utils', () => {
+  test('normalizes node fs backend CJS and ESM namespace shapes', () => {
+    class FakeBackend {}
+
+    expect(resolveFsBackendConstructor(FakeBackend)).toBe(FakeBackend);
+    expect(resolveFsBackendConstructor({ default: FakeBackend })).toBe(
+      FakeBackend,
+    );
+    expect(resolveFsBackendConstructor({ 'module.exports': FakeBackend })).toBe(
+      FakeBackend,
+    );
+    expect(
+      resolveFsBackendConstructor({ default: { default: FakeBackend } }),
+    ).toBe(FakeBackend);
+    expect(
+      resolveFsBackendConstructor({
+        default: { 'module.exports': FakeBackend },
+      }),
+    ).toBe(FakeBackend);
+  });
+
+  test('node fs backend wrapper extends a resolved constructor', () => {
+    const backend = new FsBackendWithSave({}, {}, {}) as {
+      type?: string;
+      save: (language: string, namespace: string, data: unknown) => void;
+    };
+
+    expect(backend.type).toBe('backend');
+    expect(() => backend.save('en', 'translation', {})).not.toThrow();
+  });
+
   test('node fs backend defaults follow the detected locales directory', () => {
     // The default must match whichever conventional root exists at runtime
     // (./locales first, then ./config/public/locales), mirroring the CLI

package/tests/localisedUrls.test.ts

@@ -53,6 +53,41 @@ describe('resolveLocalisedUrlsConfig', () => {
 });
 
 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);
+  });
+
   const setupModifyRoutes = (localeDetection: Record<string, unknown>) => {
     let modifyRoutes:
       | ((args: { entrypoint: any; routes: any[] }) => {

package/tests/reactI18nextRuntimeBoundary.test.ts

@@ -0,0 +1,27 @@
+import { readFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { describe, expect, test } from '@rstest/core';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const runtimeRoot = resolve(__dirname, '../src/runtime');
+
+const readRuntimeSource = (file: string) =>
+  readFileSync(resolve(runtimeRoot, file), 'utf8');
+
+describe('react-i18next runtime boundary', () => {
+  test('keeps the disabled runtime entry free of the optional adapter edge', () => {
+    const noReactEntry = readRuntimeSource('no-react-i18next.tsx');
+    const core = readRuntimeSource('core.tsx');
+
+    expect(noReactEntry).not.toContain('./i18n/react-i18next');
+    expect(core).not.toContain('./i18n/react-i18next');
+    expect(core).not.toContain("import('react-i18next')");
+  });
+
+  test('keeps the default runtime entry wired to react-i18next integration', () => {
+    const defaultEntry = readRuntimeSource('index.tsx');
+
+    expect(defaultEntry).toContain('./i18n/react-i18next');
+  });
+});

package/tests/routerAdapter.test.tsx

@@ -5,7 +5,7 @@ import {
 } from '@modern-js/runtime/context';
 import type React from 'react';
 import type { ComponentType, PropsWithChildren } from 'react';
-import { act } from 'react';
+import { act, useState } from 'react';
 import { createRoot, type Root } from 'react-dom/client';
 import { i18nPlugin } from '../src/runtime';
 import { ModernI18nProvider, useModernI18n } from '../src/runtime/context';
@@ -453,4 +453,61 @@ describe('i18n router adapter', () => {
       replace: true,
     });
   });
+
+  test('exposes a language-scoped t function for rendered copy', async () => {
+    const i18nInstance = createI18nInstance('en');
+    i18nInstance.t = (key: string) => `${i18nInstance.language}:${key}`;
+    const renderTranslations: Array<(key: string) => string> = [];
+    let setProviderLanguage: ((language: string) => void) | undefined;
+
+    const StatefulI18nProvider = ({ children }: PropsWithChildren) => {
+      const [language, setLanguage] = useState('en');
+      setProviderLanguage = setLanguage;
+
+      return (
+        <ModernI18nProvider
+          value={{
+            language,
+            i18nInstance,
+            languages: ['en', 'cs'],
+            localePathRedirect: true,
+            localisedUrls,
+            updateLanguage: setLanguage,
+          }}
+        >
+          {children}
+        </ModernI18nProvider>
+      );
+    };
+
+    const Harness = () => {
+      const { t } = useModernI18n();
+      renderTranslations.push(t);
+      return <span data-testid="translation">{t('key')}</span>;
+    };
+
+    rendered = await renderWithRuntime(
+      <StatefulI18nProvider>
+        <Harness />
+      </StatefulI18nProvider>,
+      createReactRouterRuntimeContext({ navigate: rstest.fn() }),
+    );
+
+    expect(
+      rendered.container.querySelector('[data-testid="translation"]')
+        ?.textContent,
+    ).toBe('en:key');
+    const initialT = renderTranslations.at(-1);
+
+    await act(async () => {
+      i18nInstance.language = 'cs';
+      setProviderLanguage?.('cs');
+    });
+
+    expect(
+      rendered.container.querySelector('[data-testid="translation"]')
+        ?.textContent,
+    ).toBe('cs:key');
+    expect(renderTranslations.at(-1)).not.toBe(initialT);
+  });
 });