@bleedingdev/modern-js-plugin-i18n 3.5.0-ultramodern.5 → 3.5.0-ultramodern.75

package/dist/types/server/index.d.ts

@@ -1,14 +1,9 @@
 import type { ServerPlugin } from '@modern-js/server-runtime';
 import type { LocaleDetectionOptions } from '../shared/type';
+export { collectApiPrefixes, matchesApiPrefix } from './apiPrefix.js';
 export interface I18nPluginOptions {
     localeDetection: LocaleDetectionOptions;
     staticRoutePrefixes: string[];
 }
-type ApiPrefixInput = string | string[] | undefined;
-export declare const collectApiPrefixes: (routes: Array<{
-    isApi?: boolean;
-    urlPath?: string;
-}>, bffPrefix?: ApiPrefixInput) => string[];
-export declare const matchesApiPrefix: (pathname: string, apiPrefixes: string[]) => boolean;
 export declare const i18nServerPlugin: (options: I18nPluginOptions) => ServerPlugin;
 export default i18nServerPlugin;

package/dist/types/server/redirectPolicy.d.ts

@@ -0,0 +1,22 @@
+import type { LocaleDetectionOptions } from '../shared/type';
+interface LocaleRedirectRequest {
+    url: string;
+    header: () => {
+        host?: string;
+    };
+}
+/**
+ * Check if pathname should ignore automatic locale redirect.
+ */
+export declare const shouldIgnoreRedirect: (pathname: string, urlPath: string, ignoreRedirectRoutes?: string[] | ((pathname: string) => boolean)) => boolean;
+/**
+ * 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.
+ */
+export declare const isStaticResourceRequest: (pathname: string, staticRoutePrefixes: string[], languages?: string[]) => boolean;
+export declare const getLanguageFromPath: (req: LocaleRedirectRequest, urlPath: string, languages: string[]) => string | null;
+export declare const buildLocalizedUrl: (req: LocaleRedirectRequest, urlPath: string, language: string, languages: string[], localisedUrls?: LocaleDetectionOptions['localisedUrls']) => string;
+export declare const createLocaleRedirectResponse: (location: string) => Response;
+export {};

package/dist/types/shared/detection.d.ts

@@ -1,11 +1 @@
-import type { LanguageDetectorOptions } from '../runtime/i18n/instance';
-/**
- * Detect language from request using the same detection logic as i18next
- * This ensures consistency between server-side and client-side detection
- */
-export declare function detectLanguageFromRequest(req: {
-    url: string;
-    headers: {
-        get: (name: string) => string | null;
-    } | Headers;
-}, languages: string[], detectionOptions?: LanguageDetectorOptions): string | null;
+export {};

package/dist/types/shared/localisedUrls/config.d.ts

@@ -0,0 +1,9 @@
+import type { LocalisedUrlsOption, ResolvedLocalisedUrlsConfig } from './types';
+/**
+ * Localised URLs are strictly opt-in: only an explicit, non-empty map enables
+ * route expansion and validation. `true`, `false`, an empty map and absence
+ * all resolve to disabled, so upstream-style configs (`localePathRedirect` +
+ * `languages` without a map) keep plain locale-prefix behavior instead of
+ * failing the build for every route missing from a map they never wrote.
+ */
+export declare const resolveLocalisedUrlsConfig: (option: LocalisedUrlsOption | undefined) => ResolvedLocalisedUrlsConfig;

package/dist/types/shared/localisedUrls/index.d.ts

@@ -0,0 +1,9 @@
+export { resolveLocalisedUrlsConfig } from './config';
+export { normalisePathname, normalisePathPattern } from './normalise';
+export { canonicalTargetPathname, localiseTargetPathname, stripLanguagePrefix, } from './pathname';
+export { buildPathFromPattern, matchPathPattern } from './patterns';
+export type { LocaleRedirectSkipRule } from './redirect';
+export { DEFAULT_LOCALE_REDIRECT_SKIP_RULES, isDefaultLocaleRedirectSkipPath, matchesPathPrefix, shouldSkipLocaleRedirect, } from './redirect';
+export { resolveCanonicalLocalisedPath, resolveLocalisedPath } from './resolve';
+export { applyLocalisedUrlsToRoutes, validateLocalisedUrls } from './routes';
+export type { LocalisedRoute, LocalisedUrlPathMap, LocalisedUrlsMap, LocalisedUrlsOption, ResolvedLocalisedUrlsConfig, } from './types';

package/dist/types/shared/localisedUrls/normalise.d.ts

@@ -0,0 +1,10 @@
+export declare const normalisePathPattern: (path: string) => string;
+/**
+ * Normalise a concrete request pathname: slash cleanup only. Unlike
+ * {@link normalisePathPattern} it must not rewrite literal `[x]` segments to
+ * `:x` params — pathnames are values, not patterns.
+ */
+export declare const normalisePathname: (pathname: string) => string;
+export declare const normaliseRoutePath: (path: string) => string;
+export declare const stripLeadingLocaleParam: (path?: string) => string | undefined;
+export declare const getLeadingLocaleParam: (path?: string) => string | null;

package/dist/types/shared/localisedUrls/pathname.d.ts

@@ -0,0 +1,4 @@
+import type { LocalisedUrlsOption } from './types';
+export declare const stripLanguagePrefix: (pathname: string, languages: string[]) => string;
+export declare const localiseTargetPathname: (pathname: string, language: string, languages: string[], localisedUrls?: LocalisedUrlsOption) => string;
+export declare const canonicalTargetPathname: (pathname: string, languages: string[], localisedUrls?: LocalisedUrlsOption) => string;

package/dist/types/shared/localisedUrls/patterns.d.ts

@@ -0,0 +1,5 @@
+export declare const sortPatternsBySpecificity: <T extends {
+    pattern: string;
+}>(patterns: T[]) => T[];
+export declare const matchPathPattern: (pathname: string, pattern: string) => Record<string, string> | null;
+export declare const buildPathFromPattern: (pattern: string, params: Record<string, string>) => string;

package/dist/types/shared/localisedUrls/redirect.d.ts

@@ -0,0 +1,11 @@
+export type LocaleRedirectSkipRule = {
+    type: 'exact';
+    path: string;
+} | {
+    type: 'prefix';
+    path: string;
+};
+export declare const DEFAULT_LOCALE_REDIRECT_SKIP_RULES: readonly LocaleRedirectSkipRule[];
+export declare const matchesPathPrefix: (pathname: string, prefix: string) => boolean;
+export declare const isDefaultLocaleRedirectSkipPath: (pathname: string, languages?: string[]) => boolean;
+export declare const shouldSkipLocaleRedirect: (pathname: string, languages?: string[], ignoreRedirectRoutes?: string[] | ((pathname: string) => boolean)) => boolean;

package/dist/types/shared/localisedUrls/resolve.d.ts

@@ -0,0 +1,7 @@
+import type { LocalisedUrlsMap } from './types';
+export declare const resolveLocalisedPath: (pathname: string, targetLanguage: string, languages: string[], localisedUrls: LocalisedUrlsMap) => string;
+/**
+ * Reverse-map language-specific pathnames back to language-agnostic
+ * LocalisedUrlsMap keys.
+ */
+export declare const resolveCanonicalLocalisedPath: (pathname: string, languages: string[], localisedUrls: LocalisedUrlsMap) => string;

package/dist/types/shared/localisedUrls/routes.d.ts

@@ -0,0 +1,3 @@
+import type { LocalisedRoute, LocalisedUrlsMap } from './types';
+export declare const validateLocalisedUrls: (routes: LocalisedRoute[], languages: string[], localisedUrls: LocalisedUrlsMap) => void;
+export declare const applyLocalisedUrlsToRoutes: (routes: LocalisedRoute[], languages: string[], localisedUrls: LocalisedUrlsMap) => LocalisedRoute[];

package/dist/types/shared/localisedUrls/types.d.ts

@@ -0,0 +1,14 @@
+export type LocalisedRoute = {
+    type: 'nested' | 'page';
+    path?: string;
+    id?: string;
+    children?: LocalisedRoute[];
+    [key: string]: any;
+};
+export type LocalisedUrlPathMap = Record<string, string>;
+export type LocalisedUrlsMap = Record<string, LocalisedUrlPathMap>;
+export type LocalisedUrlsOption = boolean | LocalisedUrlsMap;
+export interface ResolvedLocalisedUrlsConfig {
+    enabled: boolean;
+    map: LocalisedUrlsMap;
+}

package/dist/types/shared/localisedUrls.d.ts

@@ -1,36 +1,2 @@
-import type { NestedRouteForCli, PageRoute } from '@modern-js/types';
-export type LocalisedUrlPathMap = Record<string, string>;
-export type LocalisedUrlsMap = Record<string, LocalisedUrlPathMap>;
-export type LocalisedUrlsOption = boolean | LocalisedUrlsMap;
-export interface ResolvedLocalisedUrlsConfig {
-    enabled: boolean;
-    map: LocalisedUrlsMap;
-}
-export declare const normalisePathPattern: (path: string) => string;
-/**
- * Normalise a concrete request pathname: slash cleanup only. Unlike
- * {@link normalisePathPattern} it must not rewrite literal `[x]` segments to
- * `:x` params — pathnames are values, not patterns.
- */
-export declare const normalisePathname: (pathname: string) => string;
-/**
- * Localised URLs are strictly opt-in: only an explicit, non-empty map enables
- * route expansion and validation. `true`, `false`, an empty map and absence
- * all resolve to disabled, so upstream-style configs (`localePathRedirect` +
- * `languages` without a map) keep plain locale-prefix behavior instead of
- * failing the build for every route missing from a map they never wrote.
- */
-export declare const resolveLocalisedUrlsConfig: (option: LocalisedUrlsOption | undefined) => ResolvedLocalisedUrlsConfig;
-export declare const validateLocalisedUrls: (routes: (NestedRouteForCli | PageRoute)[], languages: string[], localisedUrls: LocalisedUrlsMap) => void;
-export declare const applyLocalisedUrlsToRoutes: (routes: (NestedRouteForCli | PageRoute)[], languages: string[], localisedUrls: LocalisedUrlsMap) => (NestedRouteForCli | PageRoute)[];
-export declare const matchPathPattern: (pathname: string, pattern: string) => Record<string, string> | null;
-export declare const buildPathFromPattern: (pattern: string, params: Record<string, string>) => string;
-export declare const resolveLocalisedPath: (pathname: string, targetLanguage: string, languages: string[], localisedUrls: LocalisedUrlsMap) => string;
-/**
- * Reverse-map a language-specific pathname (without language prefix) back to
- * the canonical, language-agnostic path: localized slug patterns are matched
- * against every language variant and rebuilt from the canonical map key.
- */
-export declare const resolveCanonicalLocalisedPath: (pathname: string, languages: string[], localisedUrls: LocalisedUrlsMap) => string;
-export declare const localiseTargetPathname: (pathname: string, language: string, languages: string[], localisedUrls?: LocalisedUrlsOption) => string;
-export declare const canonicalTargetPathname: (pathname: string, languages: string[], localisedUrls?: LocalisedUrlsOption) => string;
+export type { LocaleRedirectSkipRule, LocalisedRoute, LocalisedUrlPathMap, LocalisedUrlsMap, LocalisedUrlsOption, ResolvedLocalisedUrlsConfig, } from './localisedUrls/index';
+export { applyLocalisedUrlsToRoutes, buildPathFromPattern, canonicalTargetPathname, DEFAULT_LOCALE_REDIRECT_SKIP_RULES, isDefaultLocaleRedirectSkipPath, localiseTargetPathname, matchesPathPrefix, matchPathPattern, normalisePathname, normalisePathPattern, resolveCanonicalLocalisedPath, resolveLocalisedPath, resolveLocalisedUrlsConfig, shouldSkipLocaleRedirect, stripLanguagePrefix, validateLocalisedUrls, } from './localisedUrls/index';

package/dist/types/shared/utils.d.ts

@@ -1,5 +1,3 @@
 import type { BaseBackendOptions, BaseLocaleDetectionOptions } from './type';
-export declare function getEntryConfig<T extends Record<string, any>>(entryName: string, config: T, entryKey: string): T | undefined;
-export declare function removeEntryConfigKey<T extends Record<string, any>>(config: T, entryKey: string): Omit<T, typeof entryKey>;
 export declare function getLocaleDetectionOptions(entryName: string, localeDetection: BaseLocaleDetectionOptions): BaseLocaleDetectionOptions;
 export declare function getBackendOptions(entryName: string, backend: BaseBackendOptions): BaseBackendOptions;

package/package.json

@@ -17,7 +17,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "3.5.0-ultramodern.5",
+  "version": "3.5.0-ultramodern.75",
   "engines": {
     "node": ">=20"
   },
@@ -91,25 +91,24 @@
     }
   },
   "dependencies": {
+    "@modern-js/plugin": "npm:@bleedingdev/modern-js-plugin@3.5.0-ultramodern.75",
+    "@modern-js/runtime-utils": "npm:@bleedingdev/modern-js-runtime-utils@3.5.0-ultramodern.75",
+    "@modern-js/server-core": "npm:@bleedingdev/modern-js-server-core@3.5.0-ultramodern.75",
+    "@modern-js/server-runtime": "npm:@bleedingdev/modern-js-server-runtime@3.5.0-ultramodern.75",
+    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.5.0-ultramodern.75",
     "@swc/helpers": "^0.5.23",
     "i18next-browser-languagedetector": "^8.2.1",
     "i18next-chained-backend": "^5.0.5",
     "i18next-fs-backend": "^2.6.6",
     "i18next-http-backend": "^4.0.0",
-    "i18next-http-middleware": "^3.9.7",
-    "@modern-js/server-core": "npm:@bleedingdev/modern-js-server-core@3.5.0-ultramodern.5",
-    "@modern-js/runtime-utils": "npm:@bleedingdev/modern-js-runtime-utils@3.5.0-ultramodern.5",
-    "@modern-js/plugin": "npm:@bleedingdev/modern-js-plugin@3.5.0-ultramodern.5",
-    "@modern-js/server-runtime": "npm:@bleedingdev/modern-js-server-runtime@3.5.0-ultramodern.5",
-    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.5.0-ultramodern.5",
-    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.5.0-ultramodern.5"
+    "i18next-http-middleware": "^3.9.7"
   },
   "peerDependencies": {
-    "@modern-js/runtime": "3.5.0-ultramodern.5",
+    "@modern-js/runtime": "3.5.0-ultramodern.75",
     "i18next": ">=26.3.1",
     "react": "^19.2.7",
     "react-dom": "^19.2.7",
-    "react-i18next": "^17.0.8"
+    "react-i18next": "^17.0.9"
   },
   "peerDependenciesMeta": {
     "i18next": {
@@ -120,21 +119,19 @@
     }
   },
   "devDependencies": {
-    "@rslib/core": "0.23.1",
-    "@types/node": "^26.0.1",
-    "@typescript/native-preview": "7.0.0-dev.20260628.1",
-    "i18next": "26.3.3",
+    "@modern-js/app-tools": "npm:@bleedingdev/modern-js-app-tools@3.5.0-ultramodern.75",
+    "@modern-js/runtime": "npm:@bleedingdev/modern-js-runtime@3.5.0-ultramodern.75",
+    "@rslib/core": "0.23.2",
+    "@types/node": "^26.1.1",
+    "@typescript/native-preview": "7.0.0-dev.20260707.2",
+    "i18next": "26.3.6",
     "react": "^19.2.7",
     "react-dom": "^19.2.7",
-    "react-i18next": "17.0.8",
-    "ts-node": "^10.9.2",
-    "typescript": "^6.0.3",
-    "@modern-js/app-tools": "npm:@bleedingdev/modern-js-app-tools@3.5.0-ultramodern.5",
-    "@modern-js/runtime": "npm:@bleedingdev/modern-js-runtime@3.5.0-ultramodern.5"
+    "react-i18next": "17.0.9",
+    "typescript": "^7.0.2"
   },
   "sideEffects": false,
   "publishConfig": {
-    "registry": "https://registry.npmjs.org/",
     "access": "public"
   },
   "scripts": {

package/rstest.config.mts

@@ -29,16 +29,23 @@ export default {
       include: [
         'tests/i18nUtils.test.ts',
         'tests/localisedUrls.test.ts',
+        'tests/localisedUrlRewriteMatrix.fork.test.ts',
         'tests/linkTypes.test.ts',
         'tests/backendDefaults.test.ts',
+        'tests/redirectPolicy.test.ts',
         'tests/reactI18nextRuntimeBoundary.test.ts',
+        'tests/federatedI18nBoundary.test.tsx',
       ],
       extends: commonConfig,
     }),
     withTestPreset({
       name: 'plugin-i18n-client',
       testEnvironment: 'happy-dom',
-      include: ['tests/routerAdapter.test.tsx', 'tests/link.test.tsx'],
+      include: [
+        'tests/routerAdapter.test.tsx',
+        'tests/link.test.tsx',
+        'tests/federatedI18nBoundary.client.test.tsx',
+      ],
       extends: commonConfig,
     }),
   ],

package/src/cli/index.ts

@@ -1,3 +1,5 @@
+import fs from 'node:fs';
+import path from 'node:path';
 import type { AppTools, CliPlugin } from '@modern-js/app-tools';
 import { getPublicDirRoutePrefixes } from '@modern-js/server-core';
 import type {
@@ -5,8 +7,6 @@ import type {
   NestedRouteForCli,
   PageRoute,
 } from '@modern-js/types';
-import fs from 'fs';
-import path from 'path';
 import {
   applyLocalisedUrlsToRoutes,
   resolveLocalisedUrlsConfig,
@@ -126,9 +126,10 @@ export const i18nPlugin = (
         backend: backendOptions,
         ...extendedConfig,
       };
+      const { reactI18next } = extendedConfig as { reactI18next?: boolean };
       const runtimePluginPath =
         customPlugin?.runtime?.path ||
-        (config.reactI18next === false
+        (reactI18next === false
           ? `@${metaName}/plugin-i18n/runtime/no-react-i18next`
           : `@${metaName}/plugin-i18n/runtime`);
 
@@ -173,7 +174,7 @@ export const i18nPlugin = (
           routes as (NestedRouteForCli | PageRoute)[],
           languages,
           localisedUrlsConfig.map,
-        ),
+        ) as (NestedRouteForCli | PageRoute)[],
       };
     });
 

package/src/cli/locales.ts

@@ -1,10 +1,10 @@
+import fs from 'node:fs';
+import path from 'node:path';
 import {
   getPublicDirRoutePrefixes,
   normalizePublicDir,
   normalizePublicDirPath,
 } from '@modern-js/server-core';
-import fs from 'fs';
-import path from 'path';
 import type { BackendOptions } from '../shared/type';
 
 interface NormalizedConfigForLocales {
@@ -13,7 +13,7 @@ interface NormalizedConfigForLocales {
   };
 }
 
-export interface DetectedLocalesDirectory {
+interface DetectedLocalesDirectory {
   loadPath: string;
   addPath: string;
   serverLoadPath: string;

package/src/runtime/Link.tsx

@@ -6,96 +6,22 @@ import type {
   ValidateLinkTo,
 } from './canonicalRoutes';
 import { useModernI18n } from './context';
+import {
+  interpolateRouteParams,
+  type LinkParams,
+  mergeClassNames,
+  normalizeSearch,
+  splitActiveProps,
+  warnOnce,
+} from './linkHelpers';
 import { canonicalPath, type LocalizedPathsConfig } from './localizedPaths';
 import { useI18nRouterAdapter } from './routerAdapter';
 import { buildLocalizedUrl, splitUrlTarget } from './utils';
 
-const EXTERNAL_TARGET_RE = /^(?:[a-z][a-z0-9+.-]*:|\/\/)/i;
-
-const warnedTargets = new Set<string>();
-
-const warnOnce = (key: string, message: string) => {
-  if (process.env.NODE_ENV !== 'development' || warnedTargets.has(key)) {
-    return;
-  }
-  warnedTargets.add(key);
-  console.warn(message);
-};
-
-export type LinkParams = Record<string, string | number | undefined>;
-
-/**
- * Interpolate `$param`, `:param`, optional (`{-$param}` / `:param?`) and splat
- * (`$` / `*`) segments with concrete values before localization, so
- * pattern-mapped slugs localize correctly.
- */
-export const interpolateRouteParams = (
-  pathname: string,
-  params?: LinkParams,
-): string => {
-  if (!/[$:*{]/.test(pathname)) {
-    return pathname;
-  }
-
-  const resolveParam = (name: string): string | undefined => {
-    const value = params?.[name];
-    return value === undefined ? undefined : String(value);
-  };
-
-  const segments = pathname
-    .split('/')
-    .map(segment => {
-      if (!segment) {
-        return segment;
-      }
-
-      if (segment.startsWith('{-$') && segment.endsWith('}')) {
-        const value = resolveParam(segment.slice(3, -1));
-        return value === undefined ? null : encodeURIComponent(value);
-      }
-
-      if (segment === '$' || segment === '*') {
-        const value = resolveParam('_splat') ?? resolveParam('*');
-        return value === undefined
-          ? null
-          : value.split('/').map(encodeURIComponent).join('/');
-      }
-
-      if (segment.startsWith('$')) {
-        const value = resolveParam(segment.slice(1));
-        if (value === undefined) {
-          warnOnce(
-            `missing-param:${pathname}:${segment}`,
-            `[plugin-i18n] <Link to="${pathname}"> is missing required param "${segment.slice(1)}".`,
-          );
-          return segment;
-        }
-        return encodeURIComponent(value);
-      }
-
-      if (segment.startsWith(':')) {
-        const optional = segment.endsWith('?');
-        const name = segment.slice(1, optional ? -1 : undefined);
-        const value = resolveParam(name);
-        if (value === undefined) {
-          if (optional) {
-            return null;
-          }
-          warnOnce(
-            `missing-param:${pathname}:${segment}`,
-            `[plugin-i18n] <Link to="${pathname}"> is missing required param "${name}".`,
-          );
-          return segment;
-        }
-        return encodeURIComponent(value);
-      }
+export type { LinkParams };
+export { interpolateRouteParams };
 
-      return segment;
-    })
-    .filter(segment => segment !== null);
-
-  return segments.join('/') || '/';
-};
+const EXTERNAL_TARGET_RE = /^(?:[a-z][a-z0-9+.-]*:|\/\/)/i;
 
 export interface LinkActiveOptions {
   /**
@@ -142,59 +68,6 @@ export type LinkProps<TTo extends string = string> = LinkBaseProps & {
 } & ValidateLinkTo<TTo> &
   LinkParamsProp<LinkTargetPathname<TTo>>;
 
-const normalizeSearch = (
-  search: string | Record<string, unknown> | undefined,
-  searchFromTo: string,
-): {
-  searchString: string;
-  searchObject: Record<string, string> | undefined;
-} => {
-  if (search && typeof search === 'object') {
-    const entries = Object.entries(search).filter(
-      ([, value]) => value !== undefined && value !== null,
-    );
-    const searchObject = Object.fromEntries(
-      entries.map(([key, value]) => [key, String(value)]),
-    );
-    const params = new URLSearchParams(searchObject);
-    const serialized = params.toString();
-    return {
-      searchString: serialized ? `?${serialized}` : '',
-      searchObject,
-    };
-  }
-
-  const raw = typeof search === 'string' && search ? search : searchFromTo;
-  if (!raw) {
-    return { searchString: '', searchObject: undefined };
-  }
-
-  const searchString = raw.startsWith('?') ? raw : `?${raw}`;
-  const searchObject: Record<string, string> = {};
-  new URLSearchParams(searchString).forEach((value, key) => {
-    searchObject[key] = value;
-  });
-
-  return { searchString, searchObject };
-};
-
-const splitActiveProps = (
-  active: boolean,
-  activeProps?: LinkBaseProps['activeProps'],
-) => {
-  if (!active || !activeProps) {
-    return {};
-  }
-  return activeProps;
-};
-
-const mergeClassNames = (...values: Array<unknown>): string | undefined => {
-  const classNames = values.filter(
-    (value): value is string => typeof value === 'string' && value.length > 0,
-  );
-  return classNames.length > 0 ? classNames.join(' ') : undefined;
-};
-
 /**
  * The standard UltraModern link: a vanilla link in every respect except that
  * it localizes canonical, language-agnostic paths automatically.