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

package/src/server/redirectPolicy.ts

@@ -1,76 +1,77 @@
-import {
-  isDefaultLocaleRedirectSkipPath,
-  localiseTargetPathname,
-  matchesPathPrefix,
-  shouldSkipLocaleRedirect,
-  stripLanguagePrefix,
-} from '@modern-js/i18n-runtime-extensions';
-import type { LocaleDetectionOptions } from '../shared/type';
+import type { I18nUrlStrategy } from '../shared/urlStrategy';
 
 interface LocaleRedirectRequest {
   url: string;
-  header: () => {
-    host?: string;
-  };
+  header?: () => { host?: string };
 }
 
 const stripUrlPathPrefix = (pathname: string, urlPath: string): string => {
   const basePath = urlPath.replace('/*', '');
-
   if (!basePath || basePath === '/') {
     return pathname;
   }
-
-  const remainingPath = pathname.startsWith(basePath)
-    ? pathname.slice(basePath.length)
+  return pathname === basePath || pathname.startsWith(`${basePath}/`)
+    ? pathname.slice(basePath.length) || '/'
     : pathname;
-
-  return remainingPath || '/';
 };
 
-/**
- * Check if pathname should ignore automatic locale redirect.
- */
 export const shouldIgnoreRedirect = (
   pathname: string,
   urlPath: string,
   ignoreRedirectRoutes?: string[] | ((pathname: string) => boolean),
+  urlStrategy?: I18nUrlStrategy,
+  languages: string[] = [],
 ): boolean => {
   const remainingPath = stripUrlPathPrefix(pathname, urlPath);
-
-  return shouldSkipLocaleRedirect(remainingPath, [], ignoreRedirectRoutes);
+  if (urlStrategy?.shouldSkipRedirect?.(remainingPath, languages)) {
+    return true;
+  }
+  if (!ignoreRedirectRoutes) {
+    return false;
+  }
+  const segments = remainingPath.split('/').filter(Boolean);
+  if (
+    segments[0] &&
+    languages.some(
+      language => language.toLowerCase() === segments[0].toLowerCase(),
+    )
+  ) {
+    segments.shift();
+  }
+  const normalizedPath = `/${segments.join('/')}`;
+  return typeof ignoreRedirectRoutes === 'function'
+    ? ignoreRedirectRoutes(normalizedPath)
+    : ignoreRedirectRoutes.some(
+        pattern =>
+          normalizedPath === pattern ||
+          normalizedPath.startsWith(`${pattern}/`),
+      );
 };
 
-/**
- * Check if pathname is a static or federation resource request.
- *
- * This includes configured staticRoutePrefixes, the shared default skip policy
- * from ADR-0002, and language-prefixed variants such as /en/static/app.js.
- */
+/** Native configured/static exclusions remain in effect for every strategy. */
 export const isStaticResourceRequest = (
   pathname: string,
   staticRoutePrefixes: string[],
   languages: string[] = [],
 ): boolean => {
-  if (isDefaultLocaleRedirectSkipPath(pathname, languages)) {
-    return true;
-  }
-
-  const matchesStaticRoutePrefix = (targetPathname: string): boolean =>
-    staticRoutePrefixes.some(prefix =>
-      matchesPathPrefix(targetPathname, prefix),
+  const prefixes = [...staticRoutePrefixes, '/static', '/upload'];
+  const matches = (target: string) =>
+    prefixes.some(
+      prefix => target === prefix || target.startsWith(`${prefix}/`),
     );
-
-  if (matchesStaticRoutePrefix(pathname)) {
+  if (matches(pathname)) {
     return true;
   }
-
-  const pathWithoutLanguage = stripLanguagePrefix(pathname, languages);
-
-  return (
-    pathWithoutLanguage !== pathname &&
-    matchesStaticRoutePrefix(pathWithoutLanguage)
-  );
+  const segments = pathname.split('/').filter(Boolean);
+  if (
+    segments[0] &&
+    languages.some(
+      language => language.toLowerCase() === segments[0].toLowerCase(),
+    )
+  ) {
+    return matches(`/${segments.slice(1).join('/')}`);
+  }
+  return false;
 };
 
 export const getLanguageFromPath = (
@@ -78,17 +79,16 @@ export const getLanguageFromPath = (
   urlPath: string,
   languages: string[],
 ): string | null => {
-  const url = new URL(req.url, `http://${req.header().host}`);
-  const pathname = url.pathname;
-  const remainingPath = stripUrlPathPrefix(pathname, urlPath);
-  const segments = remainingPath.split('/').filter(Boolean);
-  const firstSegment = segments[0];
-
-  if (languages.includes(firstSegment)) {
-    return firstSegment;
-  }
-
-  return null;
+  const host = req.header?.().host;
+  const url = new URL(req.url, host ? `http://${host}` : undefined);
+  const firstSegment = stripUrlPathPrefix(url.pathname, urlPath)
+    .split('/')
+    .filter(Boolean)[0];
+  return (
+    languages.find(
+      language => language.toLowerCase() === firstSegment?.toLowerCase(),
+    ) ?? null
+  );
 };
 
 export const buildLocalizedUrl = (
@@ -96,24 +96,24 @@ export const buildLocalizedUrl = (
   urlPath: string,
   language: string,
   languages: string[],
-  localisedUrls?: LocaleDetectionOptions['localisedUrls'],
+  urlStrategy?: I18nUrlStrategy,
 ): string => {
   const url = new URL(req.url);
-  const pathname = url.pathname;
   const basePath = urlPath.replace('/*', '');
-  const remainingPath = stripUrlPathPrefix(pathname, urlPath);
-
-  const newPathname = localiseTargetPathname(
-    remainingPath,
-    language,
-    languages,
-    localisedUrls,
-  );
-  const suffix = `${url.search}${url.hash}`;
-  const localizedUrl =
-    basePath === '/' ? newPathname + suffix : basePath + newPathname + suffix;
-
-  return localizedUrl;
+  const remainingPath = stripUrlPathPrefix(url.pathname, urlPath);
+  const segments = remainingPath.split('/').filter(Boolean);
+  if (
+    segments[0] &&
+    languages.some(item => item.toLowerCase() === segments[0].toLowerCase())
+  ) {
+    segments[0] = language;
+  } else {
+    segments.unshift(language);
+  }
+  const pathname = urlStrategy
+    ? urlStrategy.localizePathname(remainingPath, language, languages)
+    : `/${segments.join('/')}`;
+  return `${basePath === '/' ? '' : basePath}${pathname}${url.search}${url.hash}`;
 };
 
 export const createLocaleRedirectResponse = (location: string): Response =>

package/src/shared/type.ts

@@ -1,4 +1,3 @@
-import type { LocalisedUrlsOption } from '@modern-js/i18n-runtime-extensions';
 import type {
   LanguageDetectorOptions,
   Resources,
@@ -11,19 +10,6 @@ export interface BaseLocaleDetectionOptions {
   fallbackLanguage?: string;
   detection?: LanguageDetectorOptions;
   ignoreRedirectRoutes?: string[] | ((pathname: string) => boolean);
-  /**
-   * Enables localised pathnames in addition to the locale prefix.
-   *
-   * - non-empty object: map canonical route paths to every configured
-   *   language; route generation then validates that every localisable route
-   *   path has entries for all configured languages.
-   * - absent / `false` / `true` / empty object: keep only locale-prefix
-   *   behavior (`/en/about`).
-   *
-   * Strictly opt-in: without a map, `localePathRedirect` + `languages` behave
-   * exactly like upstream Modern.js.
-   */
-  localisedUrls?: LocalisedUrlsOption;
 }
 
 export interface LocaleDetectionOptions extends BaseLocaleDetectionOptions {

package/src/shared/urlStrategy.ts

@@ -0,0 +1,11 @@
+/** Per-plugin URL policy. Search and hash remain owned by native URL handling. */
+export interface I18nUrlStrategy {
+  localizePathname(
+    pathname: string,
+    language: string,
+    languages: readonly string[],
+  ): string;
+  canonicalPathname(pathname: string, languages: readonly string[]): string;
+  /** Adds exclusions; it cannot enable redirects excluded by native rules. */
+  shouldSkipRedirect?(pathname: string, languages: readonly string[]): boolean;
+}

package/tests/federatedI18nBoundaryResolver.test.tsx

@@ -0,0 +1,71 @@
+import { RuntimeComponentResolverContext } from '@modern-js/runtime/context';
+import { describe, expect, test } from '@rstest/core';
+import { useState } from 'react';
+import { renderToStaticMarkup } from 'react-dom/server';
+import {
+  FederatedI18nBoundary,
+  type FederatedI18nBoundaryProps,
+} from '../src/runtime/context';
+
+const props: FederatedI18nBoundaryProps = {
+  defaultNamespace: 'inventory',
+  resources: {},
+  children: <span>child content</span>,
+};
+
+describe('native federation resolver wrapper', () => {
+  test('reports missing integration when no resolver is installed', () => {
+    expect(() =>
+      renderToStaticMarkup(<FederatedI18nBoundary {...props} />),
+    ).toThrow(/requires the @modern-js\/i18n-integration runtime plugin/);
+  });
+
+  test('retains the actionable fallback when a resolver does not handle i18n', () => {
+    expect(() =>
+      renderToStaticMarkup(
+        <RuntimeComponentResolverContext.Provider
+          value={component => component}
+        >
+          <FederatedI18nBoundary {...props} />
+        </RuntimeComponentResolverContext.Provider>,
+      ),
+    ).toThrow(/requires the @modern-js\/i18n-integration runtime plugin/);
+  });
+
+  test('rejects resolution back to the native wrapper', () => {
+    expect(() =>
+      renderToStaticMarkup(
+        <RuntimeComponentResolverContext.Provider
+          value={() => FederatedI18nBoundary}
+        >
+          <FederatedI18nBoundary {...props} />
+        </RuntimeComponentResolverContext.Provider>,
+      ),
+    ).toThrow(/resolver returned its own wrapper/);
+  });
+
+  test('renders the resolved hook-bearing component with unchanged props', () => {
+    let receivedProps: FederatedI18nBoundaryProps | undefined;
+    function ResolvedBoundary(value: FederatedI18nBoundaryProps) {
+      receivedProps = value;
+      const [label] = useState('resolved');
+      return (
+        <section>
+          {label}:{value.children}
+        </section>
+      );
+    }
+    const html = renderToStaticMarkup(
+      <RuntimeComponentResolverContext.Provider
+        value={(component, { name }) =>
+          name === 'i18n.FederatedI18nBoundary' ? ResolvedBoundary : component
+        }
+      >
+        <FederatedI18nBoundary {...props} />
+      </RuntimeComponentResolverContext.Provider>,
+    );
+    expect(html).toBe('<section>resolved:<span>child content</span></section>');
+    expect(receivedProps?.resources).toBe(props.resources);
+    expect(receivedProps?.defaultNamespace).toBe('inventory');
+  });
+});

package/tests/i18nUtils.test.ts

@@ -1,28 +1,11 @@
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
 import { describe, expect, test } from '@rstest/core';
-import type { I18nInstance } from '../src/runtime/i18n';
-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 {
-  return {
-    language: 'en',
-    isInitialized: false,
-    init: async () => undefined,
-    use: () => {},
-    t: (key: string | string[]) => (Array.isArray(key) ? key[0] : key),
-    options: {},
-    store: {
-      data: {},
-    },
-  };
-}
 
 describe('i18n runtime utils', () => {
   test('normalizes node fs backend CJS and ESM namespace shapes', () => {
@@ -45,50 +28,33 @@ describe('i18n runtime utils', () => {
     ).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
-    // plugin's detectLocalesDirectory. Detailed precedence cases live in
-    // tests/backendDefaults.test.ts.
-    expect(NODE_DEFAULT_I18NEXT_BACKEND_OPTIONS.loadPath).toBe(
-      `${resolveDefaultLocalesDir()}/{{lng}}/{{ns}}.json`,
-    );
-  });
-
-  test('does not poll for backend resources after init', async () => {
-    const i18nInstance = createBackendI18nInstance();
-    const init = rstest.fn(async () => {
-      i18nInstance.isInitialized = true;
-    });
-    i18nInstance.init = init as I18nInstance['init'];
-    const setTimeoutSpy = rstest.spyOn(globalThis, 'setTimeout');
-
-    await initializeI18nInstance(
-      i18nInstance,
-      'cs',
-      'en',
-      ['en', 'cs'],
-      {},
-      {
-        enabled: true,
-        loadPath: '/locales/{{lng}}/{{ns}}.json',
-      },
-      {},
-    );
-
-    expect(init).toHaveBeenCalledTimes(1);
-    expect(setTimeoutSpy).not.toHaveBeenCalled();
-
-    setTimeoutSpy.mockRestore();
+  test('loads translation resources through the node fs backend', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'i18n-backend-'));
+
+    try {
+      await mkdir(join(root, 'cs'), { recursive: true });
+      await writeFile(
+        join(root, 'cs', 'common.json'),
+        JSON.stringify({ title: 'Ahoj' }),
+      );
+      const backend = new FsBackendWithSave(
+        {},
+        { loadPath: join(root, '{{lng}}', '{{ns}}.json') },
+        {},
+      );
+      const resources = await new Promise<unknown>((resolve, reject) => {
+        backend.read('cs', 'common', (error: Error | null, data: unknown) => {
+          if (error) {
+            reject(error);
+          } else {
+            resolve(data);
+          }
+        });
+      });
+
+      expect(resources).toEqual({ title: 'Ahoj' });
+    } finally {
+      await rm(root, { force: true, recursive: true });
+    }
   });
 });