@bleedingdev/modern-js-plugin-i18n 3.5.0-ultramodern.30 → 3.5.0-ultramodern.31

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,16 @@
+import type { LocaleDetectionOptions } from '../shared/type';
+/**
+ * Check if the given pathname should ignore automatic locale redirect
+ */
+export declare const shouldIgnoreRedirect: (pathname: string, urlPath: string, ignoreRedirectRoutes?: string[] | ((pathname: string) => boolean)) => boolean;
+/**
+ * Check if the given pathname is a static resource request
+ * This includes:
+ * 1. Paths matching staticRoutePrefixes (from public directories)
+ * 2. Standard static resource paths like /static/, /upload/
+ * 3. Paths with language prefix like /en/static/, /zh/static/
+ */
+export declare const isStaticResourceRequest: (pathname: string, staticRoutePrefixes: string[], languages?: string[]) => boolean;
+export declare const getLanguageFromPath: (req: any, urlPath: string, languages: string[]) => string | null;
+export declare const buildLocalizedUrl: (req: any, urlPath: string, language: string, languages: string[], localisedUrls?: LocaleDetectionOptions['localisedUrls']) => string;
+export declare const createLocaleRedirectResponse: (location: string) => Response;

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,7 @@
+export { resolveLocalisedUrlsConfig } from './config';
+export { normalisePathname, normalisePathPattern } from './normalise';
+export { canonicalTargetPathname, localiseTargetPathname } from './pathname';
+export { buildPathFromPattern, matchPathPattern } from './patterns';
+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,3 @@
+import type { LocalisedUrlsOption } from './types';
+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/resolve.d.ts

@@ -0,0 +1,8 @@
+import type { LocalisedUrlsMap } from './types';
+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;

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,42 +1,2 @@
-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;
-}
-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: LocalisedRoute[], languages: string[], localisedUrls: LocalisedUrlsMap) => void;
-export declare const applyLocalisedUrlsToRoutes: (routes: LocalisedRoute[], languages: string[], localisedUrls: LocalisedUrlsMap) => LocalisedRoute[];
-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 { LocalisedRoute, LocalisedUrlPathMap, LocalisedUrlsMap, LocalisedUrlsOption, ResolvedLocalisedUrlsConfig, } from './localisedUrls/index';
+export { applyLocalisedUrlsToRoutes, buildPathFromPattern, canonicalTargetPathname, localiseTargetPathname, matchPathPattern, normalisePathname, normalisePathPattern, resolveCanonicalLocalisedPath, resolveLocalisedPath, resolveLocalisedUrlsConfig, validateLocalisedUrls, } from './localisedUrls/index';

package/package.json

@@ -17,7 +17,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "3.5.0-ultramodern.30",
+  "version": "3.5.0-ultramodern.31",
   "engines": {
     "node": ">=20"
   },
@@ -97,15 +97,15 @@
     "i18next-fs-backend": "^2.6.6",
     "i18next-http-backend": "^4.0.0",
     "i18next-http-middleware": "^3.9.7",
-    "@modern-js/plugin": "npm:@bleedingdev/modern-js-plugin@3.5.0-ultramodern.30",
-    "@modern-js/server-core": "npm:@bleedingdev/modern-js-server-core@3.5.0-ultramodern.30",
-    "@modern-js/server-runtime": "npm:@bleedingdev/modern-js-server-runtime@3.5.0-ultramodern.30",
-    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.5.0-ultramodern.30",
-    "@modern-js/runtime-utils": "npm:@bleedingdev/modern-js-runtime-utils@3.5.0-ultramodern.30",
-    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.5.0-ultramodern.30"
+    "@modern-js/runtime-utils": "npm:@bleedingdev/modern-js-runtime-utils@3.5.0-ultramodern.31",
+    "@modern-js/server-runtime": "npm:@bleedingdev/modern-js-server-runtime@3.5.0-ultramodern.31",
+    "@modern-js/server-core": "npm:@bleedingdev/modern-js-server-core@3.5.0-ultramodern.31",
+    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.5.0-ultramodern.31",
+    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.5.0-ultramodern.31",
+    "@modern-js/plugin": "npm:@bleedingdev/modern-js-plugin@3.5.0-ultramodern.31"
   },
   "peerDependencies": {
-    "@modern-js/runtime": "3.5.0-ultramodern.30",
+    "@modern-js/runtime": "3.5.0-ultramodern.31",
     "i18next": ">=26.3.1",
     "react": "^19.2.7",
     "react-dom": "^19.2.7",
@@ -129,8 +129,8 @@
     "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.30",
-    "@modern-js/runtime": "npm:@bleedingdev/modern-js-runtime@3.5.0-ultramodern.30"
+    "@modern-js/app-tools": "npm:@bleedingdev/modern-js-app-tools@3.5.0-ultramodern.31",
+    "@modern-js/runtime": "npm:@bleedingdev/modern-js-runtime@3.5.0-ultramodern.31"
   },
   "sideEffects": false,
   "publishConfig": {

package/src/cli/index.ts

@@ -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/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.