@bleedingdev/modern-js-plugin-i18n 3.2.0-ultramodern.2 → 3.2.0-ultramodern.23

package/src/runtime/utils.ts

@@ -3,6 +3,11 @@ import {
   getGlobalBasename,
   type TInternalRuntimeContext,
 } from '@modern-js/runtime/context';
+import type { LocalisedUrlsMap } from '../shared/localisedUrls';
+import {
+  resolveLocalisedPath,
+  resolveLocalisedUrlsConfig,
+} from '../shared/localisedUrls';
 
 export const getPathname = (context: TInternalRuntimeContext): string => {
   if (isBrowser()) {
@@ -51,18 +56,25 @@ export const buildLocalizedUrl = (
   pathname: string,
   language: string,
   languages: string[],
+  localisedUrls?: boolean | LocalisedUrlsMap,
 ): string => {
   const segments = pathname.split('/').filter(Boolean);
-
-  if (segments.length > 0 && languages.includes(segments[0])) {
-    // Replace existing language prefix
-    segments[0] = language;
-  } else {
-    // Add language prefix
-    segments.unshift(language);
-  }
-
-  return `/${segments.join('/')}`;
+  const localisedUrlsConfig = resolveLocalisedUrlsConfig(localisedUrls);
+  const pathWithoutLanguage =
+    segments.length > 0 && languages.includes(segments[0])
+      ? `/${segments.slice(1).join('/')}`
+      : pathname;
+  const resolvedPath = localisedUrlsConfig.enabled
+    ? resolveLocalisedPath(
+        pathWithoutLanguage,
+        language,
+        languages,
+        localisedUrlsConfig.map,
+      )
+    : pathWithoutLanguage;
+  const resolvedSegments = resolvedPath.split('/').filter(Boolean);
+
+  return `/${[language, ...resolvedSegments].join('/')}`;
 };
 
 export const detectLanguageFromPath = (
@@ -137,27 +149,3 @@ export const shouldIgnoreRedirect = (
     );
   });
 };
-
-// Safe hook wrapper to handle cases where router context is not available
-export const useRouterHooks = () => {
-  try {
-    const {
-      useLocation,
-      useNavigate,
-      useParams,
-    } = require('@modern-js/runtime/router');
-    return {
-      navigate: useNavigate(),
-      location: useLocation(),
-      params: useParams(),
-      hasRouter: true,
-    };
-  } catch (error) {
-    return {
-      navigate: null,
-      location: null,
-      params: {},
-      hasRouter: false,
-    };
-  }
-};

package/src/server/index.ts

@@ -8,6 +8,10 @@ import {
   mergeDetectionOptions,
 } from '../runtime/i18n/detection/config.js';
 import type { LanguageDetectorOptions } from '../runtime/i18n/instance';
+import {
+  resolveLocalisedPath,
+  resolveLocalisedUrlsConfig,
+} from '../shared/localisedUrls.js';
 import type { LocaleDetectionOptions } from '../shared/type';
 import { getLocaleDetectionOptions } from '../shared/utils.js';
 
@@ -16,6 +20,74 @@ export interface I18nPluginOptions {
   staticRoutePrefixes: string[];
 }
 
+type ApiPrefixInput = string | string[] | undefined;
+
+const normalizeApiPrefix = (prefix: string): string | null => {
+  const trimmedPrefix = prefix.trim();
+  if (!trimmedPrefix) {
+    return null;
+  }
+
+  const prefixedPath = trimmedPrefix.startsWith('/')
+    ? trimmedPrefix
+    : `/${trimmedPrefix}`;
+  const withoutWildcard = prefixedPath.replace(/\/\*$/, '');
+  const normalizedPrefix =
+    withoutWildcard.length > 1
+      ? withoutWildcard.replace(/\/+$/, '')
+      : withoutWildcard;
+
+  return normalizedPrefix === '/' ? null : normalizedPrefix;
+};
+
+export const collectApiPrefixes = (
+  routes: Array<{ isApi?: boolean; urlPath?: string }>,
+  bffPrefix?: ApiPrefixInput,
+): string[] => {
+  const prefixes = new Set<string>();
+
+  for (const route of routes) {
+    if (!route.isApi || !route.urlPath) {
+      continue;
+    }
+
+    const normalizedPrefix = normalizeApiPrefix(route.urlPath);
+    if (normalizedPrefix) {
+      prefixes.add(normalizedPrefix);
+    }
+  }
+
+  const bffPrefixes = Array.isArray(bffPrefix)
+    ? bffPrefix
+    : bffPrefix
+      ? [bffPrefix]
+      : [];
+
+  for (const prefix of bffPrefixes) {
+    const normalizedPrefix = normalizeApiPrefix(prefix);
+    if (normalizedPrefix) {
+      prefixes.add(normalizedPrefix);
+    }
+  }
+
+  return [...prefixes];
+};
+
+export const matchesApiPrefix = (
+  pathname: string,
+  apiPrefixes: string[],
+): boolean => {
+  const normalizedPathname = pathname.startsWith('/')
+    ? pathname
+    : `/${pathname}`;
+
+  return apiPrefixes.some(
+    prefix =>
+      normalizedPathname === prefix ||
+      normalizedPathname.startsWith(`${prefix}/`),
+  );
+};
+
 /**
  * Convert i18next detection options to hono languageDetector options
  */
@@ -231,6 +303,7 @@ const buildLocalizedUrl = (
   urlPath: string,
   language: string,
   languages: string[],
+  localisedUrls?: LocaleDetectionOptions['localisedUrls'],
 ): string => {
   const url = new URL(req.url);
   const pathname = url.pathname;
@@ -242,16 +315,21 @@ const buildLocalizedUrl = (
     : pathname;
 
   const segments = remainingPath.split('/').filter(Boolean);
-
-  if (segments.length > 0 && languages.includes(segments[0])) {
-    // Replace existing language prefix
-    segments[0] = language;
-  } else {
-    // If path doesn't start with language, add language prefix
-    segments.unshift(language);
-  }
-
-  const newPathname = `/${segments.join('/')}`;
+  const localisedUrlsConfig = resolveLocalisedUrlsConfig(localisedUrls);
+  const pathWithoutLanguage =
+    segments.length > 0 && languages.includes(segments[0])
+      ? `/${segments.slice(1).join('/')}`
+      : remainingPath;
+  const resolvedPath = localisedUrlsConfig.enabled
+    ? resolveLocalisedPath(
+        pathWithoutLanguage,
+        language,
+        languages,
+        localisedUrlsConfig.map,
+      )
+    : pathWithoutLanguage;
+  const resolvedSegments = resolvedPath.split('/').filter(Boolean);
+  const newPathname = `/${[language, ...resolvedSegments].join('/')}`;
   // Handle root path case to avoid double slashes like //en
   const suffix = `${url.search}${url.hash}`;
   const localizedUrl =
@@ -265,6 +343,11 @@ export const i18nServerPlugin = (options: I18nPluginOptions): ServerPlugin => ({
   setup: api => {
     api.onPrepare(() => {
       const { middlewares, routes } = api.getServerContext();
+      const serverConfig = api.getServerConfig();
+      const bffPrefix = serverConfig?.bff
+        ? (serverConfig.bff.prefix ?? '/api')
+        : undefined;
+      const apiPrefixes = collectApiPrefixes(routes, bffPrefix);
 
       // Collect all non-root entry paths for cross-entry path detection
       const entryPaths = new Set<string>();
@@ -292,6 +375,7 @@ export const i18nServerPlugin = (options: I18nPluginOptions): ServerPlugin => ({
           fallbackLanguage = 'en',
           detection,
           ignoreRedirectRoutes,
+          localisedUrls,
         } = getLocaleDetectionOptions(entryName, options.localeDetection);
         const staticRoutePrefixes = options.staticRoutePrefixes;
         const originUrlPath = route.urlPath;
@@ -314,6 +398,10 @@ export const i18nServerPlugin = (options: I18nPluginOptions): ServerPlugin => ({
                 const url = new URL(c.req.url);
                 const pathname = url.pathname;
 
+                if (matchesApiPrefix(pathname, apiPrefixes)) {
+                  return await next();
+                }
+
                 // For static resource requests, skip language detection
                 if (
                   isStaticResourceRequest(
@@ -348,6 +436,10 @@ export const i18nServerPlugin = (options: I18nPluginOptions): ServerPlugin => ({
               const url = new URL(c.req.url);
               const pathname = url.pathname;
 
+              if (matchesApiPrefix(pathname, apiPrefixes)) {
+                return await next();
+              }
+
               // For static resource requests, skip i18n processing
               if (
                 isStaticResourceRequest(
@@ -391,9 +483,42 @@ export const i18nServerPlugin = (options: I18nPluginOptions): ServerPlugin => ({
                   originUrlPath,
                   targetLanguage,
                   languages,
+                  localisedUrls,
                 );
                 return c.redirect(localizedUrl);
               }
+              const localisedUrlsConfig =
+                resolveLocalisedUrlsConfig(localisedUrls);
+              if (localisedUrlsConfig.enabled) {
+                const basePath = originUrlPath.replace('/*', '');
+                const remainingPath = pathname.startsWith(basePath)
+                  ? pathname.slice(basePath.length)
+                  : pathname;
+                const pathWithoutLanguage = remainingPath
+                  .split('/')
+                  .filter(Boolean)
+                  .slice(1)
+                  .join('/');
+                const canonicalLocalizedPath = resolveLocalisedPath(
+                  `/${pathWithoutLanguage}`,
+                  language,
+                  languages,
+                  localisedUrlsConfig.map,
+                );
+                const expectedPathname =
+                  basePath === '/'
+                    ? `/${language}${canonicalLocalizedPath === '/' ? '' : canonicalLocalizedPath}`
+                    : `${basePath}/${language}${
+                        canonicalLocalizedPath === '/'
+                          ? ''
+                          : canonicalLocalizedPath
+                      }`;
+                if (expectedPathname !== pathname) {
+                  return c.redirect(
+                    `${expectedPathname}${url.search}${url.hash}`,
+                  );
+                }
+              }
               await next();
             },
           });

package/src/shared/localisedUrls.ts

@@ -0,0 +1,393 @@
+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;
+}
+
+const LOCALE_PARAM_NAMES = new Set(['lang', 'locale', 'language']);
+
+export const normalisePathPattern = (path: string): string => {
+  const withoutDuplicateSlashes = path.replace(/\/+/g, '/');
+  const withLeadingSlash = withoutDuplicateSlashes.startsWith('/')
+    ? withoutDuplicateSlashes
+    : `/${withoutDuplicateSlashes}`;
+  const withoutTrailingSlash =
+    withLeadingSlash.length > 1
+      ? withLeadingSlash.replace(/\/+$/, '')
+      : withLeadingSlash;
+
+  return withoutTrailingSlash.replace(/\[(.+?)\]/g, ':$1');
+};
+
+const normaliseRoutePath = (path: string): string => {
+  const normalized = normalisePathPattern(path);
+  return normalized === '/' ? '' : normalized.slice(1);
+};
+
+const getLocaleParamSegment = (segment: string): string | null => {
+  if (!segment.startsWith(':')) {
+    return null;
+  }
+
+  const paramName = segment.slice(1).replace(/\?$/, '');
+  return LOCALE_PARAM_NAMES.has(paramName) ? segment : null;
+};
+
+const splitPathSegments = (path?: string): string[] => {
+  if (!path) {
+    return [];
+  }
+
+  return normalisePathPattern(path).split('/').filter(Boolean);
+};
+
+const stripLeadingLocaleParam = (path?: string): string | undefined => {
+  const segments = splitPathSegments(path);
+  const leadingLocaleParam = getLocaleParamSegment(segments[0] || '');
+
+  if (!leadingLocaleParam) {
+    return path;
+  }
+
+  const remainingPath = segments.slice(1).join('/');
+  return remainingPath ? `/${remainingPath}` : undefined;
+};
+
+const getLeadingLocaleParam = (path?: string): string | null => {
+  const segments = splitPathSegments(path);
+  return getLocaleParamSegment(segments[0] || '');
+};
+
+export const resolveLocalisedUrlsConfig = (
+  option: LocalisedUrlsOption | undefined,
+): ResolvedLocalisedUrlsConfig => {
+  if (option === false) {
+    return { enabled: false, map: {} };
+  }
+
+  if (option && typeof option === 'object') {
+    return { enabled: true, map: option };
+  }
+
+  return { enabled: true, map: {} };
+};
+
+const isLocaleParamPath = (path?: string): boolean => {
+  const segments = splitPathSegments(path);
+  return segments.length === 1 && Boolean(getLocaleParamSegment(segments[0]));
+};
+
+const isLocalisableRoutePath = (path?: string): path is string => {
+  const pathWithoutLocale = stripLeadingLocaleParam(path);
+
+  if (
+    !pathWithoutLocale ||
+    pathWithoutLocale === '/' ||
+    pathWithoutLocale === '*'
+  ) {
+    return false;
+  }
+
+  return true;
+};
+
+const joinPath = (parentPath: string, routePath?: string): string => {
+  if (!isLocalisableRoutePath(routePath)) {
+    return parentPath;
+  }
+
+  const segment = normaliseRoutePath(stripLeadingLocaleParam(routePath) || '');
+  return normalisePathPattern(`${parentPath}/${segment}`);
+};
+
+const ensureLocalisedUrlsForPath = (
+  canonicalPath: string,
+  languages: string[],
+  localisedUrls: LocalisedUrlsMap,
+): LocalisedUrlPathMap => {
+  const entry = localisedUrls[canonicalPath];
+  if (!entry) {
+    throw new Error(
+      `localisedUrls is enabled, but route "${canonicalPath}" does not define localised URLs for languages: ${languages.join(
+        ', ',
+      )}. Add localisedUrls["${canonicalPath}"] or set localeDetection.localisedUrls to false.`,
+    );
+  }
+
+  const missingLanguages = languages.filter(language => !entry[language]);
+  if (missingLanguages.length > 0) {
+    throw new Error(
+      `localisedUrls["${canonicalPath}"] is missing languages: ${missingLanguages.join(
+        ', ',
+      )}. Every configured language must have a localised URL.`,
+    );
+  }
+
+  return entry;
+};
+
+export const validateLocalisedUrls = (
+  routes: (NestedRouteForCli | PageRoute)[],
+  languages: string[],
+  localisedUrls: LocalisedUrlsMap,
+) => {
+  const visit = (route: NestedRouteForCli | PageRoute, parentPath: string) => {
+    const canonicalPath = joinPath(parentPath, route.path);
+    if (isLocalisableRoutePath(route.path)) {
+      ensureLocalisedUrlsForPath(canonicalPath, languages, localisedUrls);
+    }
+
+    if ('children' in route && route.children) {
+      route.children.forEach(child => visit(child, canonicalPath));
+    }
+  };
+
+  routes.forEach(route => visit(route, ''));
+};
+
+const getLocalisedRoutePaths = (
+  canonicalPath: string,
+  parentLocalisedPaths: Record<string, string>,
+  languages: string[],
+  entry: LocalisedUrlPathMap,
+): string[] => {
+  const paths = languages.map(language => {
+    const fullPath = normalisePathPattern(entry[language]);
+    const parentPath = normalisePathPattern(
+      parentLocalisedPaths[language] || '/',
+    );
+    if (parentPath === '/') {
+      return normaliseRoutePath(fullPath) || undefined;
+    }
+
+    const parentPrefix = `${parentPath}/`;
+    if (!fullPath.startsWith(parentPrefix)) {
+      throw new Error(
+        `localisedUrls["${canonicalPath}"].${language} must be nested under "${parentPath}" because its parent route is localised there.`,
+      );
+    }
+
+    return normaliseRoutePath(fullPath.slice(parentPath.length));
+  });
+
+  return Array.from(new Set(paths.filter(Boolean) as string[]));
+};
+
+const transformLocalisedRoute = (
+  route: NestedRouteForCli | PageRoute,
+  parentCanonicalPath: string,
+  parentLocalisedPaths: Record<string, string>,
+  languages: string[],
+  localisedUrls: LocalisedUrlsMap,
+): (NestedRouteForCli | PageRoute)[] => {
+  const canonicalPath = joinPath(parentCanonicalPath, route.path);
+  const localisedUrlEntry = isLocalisableRoutePath(route.path)
+    ? ensureLocalisedUrlsForPath(canonicalPath, languages, localisedUrls)
+    : undefined;
+  const routeLocalisedPaths = localisedUrlEntry
+    ? languages.reduce<Record<string, string>>((acc, language) => {
+        acc[language] = normalisePathPattern(localisedUrlEntry[language]);
+        return acc;
+      }, {})
+    : parentLocalisedPaths;
+
+  const children =
+    'children' in route && route.children
+      ? route.children.flatMap(child =>
+          transformLocalisedRoute(
+            child,
+            canonicalPath,
+            routeLocalisedPaths,
+            languages,
+            localisedUrls,
+          ),
+        )
+      : undefined;
+
+  const baseRoute = {
+    ...route,
+    ...(children ? { children } : {}),
+  } as NestedRouteForCli | PageRoute;
+
+  if (!localisedUrlEntry) {
+    return [baseRoute];
+  }
+
+  return getLocalisedRoutePaths(
+    canonicalPath,
+    parentLocalisedPaths,
+    languages,
+    localisedUrlEntry,
+  ).map((localisedPath, index) =>
+    cloneRouteWithLocalisedPath(baseRoute, localisedPath, index),
+  );
+};
+
+const legalRouteIdPart = (value: string): string =>
+  value.replace(/[^a-zA-Z0-9_$-]+/g, '_').replace(/^_+|_+$/g, '') || 'index';
+
+const suffixRouteIds = <T extends NestedRouteForCli | PageRoute>(
+  route: T,
+  suffix: string,
+): T => {
+  const children =
+    'children' in route && route.children
+      ? route.children.map(child => suffixRouteIds(child, suffix))
+      : undefined;
+
+  return {
+    ...route,
+    ...(route.id ? { id: `${route.id}__localised_${suffix}` } : {}),
+    ...(children ? { children } : {}),
+  };
+};
+
+const cloneRouteWithLocalisedPath = (
+  route: NestedRouteForCli | PageRoute,
+  path: string,
+  index: number,
+): NestedRouteForCli | PageRoute => {
+  const leadingLocaleParam = getLeadingLocaleParam(route.path);
+  const localisedPath = leadingLocaleParam
+    ? normaliseRoutePath(`${leadingLocaleParam}/${path}`)
+    : path;
+  const routeWithPath = {
+    ...route,
+    path: localisedPath,
+  } as NestedRouteForCli | PageRoute;
+
+  return index === 0
+    ? routeWithPath
+    : suffixRouteIds(routeWithPath, legalRouteIdPart(localisedPath));
+};
+
+export const applyLocalisedUrlsToRoutes = (
+  routes: (NestedRouteForCli | PageRoute)[],
+  languages: string[],
+  localisedUrls: LocalisedUrlsMap,
+): (NestedRouteForCli | PageRoute)[] => {
+  const rootLocalisedPaths = languages.reduce<Record<string, string>>(
+    (acc, language) => {
+      acc[language] = '/';
+      return acc;
+    },
+    {},
+  );
+
+  validateLocalisedUrls(routes, languages, localisedUrls);
+
+  return routes.flatMap(route =>
+    transformLocalisedRoute(
+      route,
+      '',
+      rootLocalisedPaths,
+      languages,
+      localisedUrls,
+    ),
+  );
+};
+
+const escapeRegExp = (value: string): string =>
+  value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+
+const getParamName = (segment: string): string =>
+  segment.slice(1).replace(/\?$/, '');
+
+const compilePathPattern = (pattern: string) => {
+  const names: string[] = [];
+  const segments = normalisePathPattern(pattern).split('/').filter(Boolean);
+  const source = segments
+    .map(segment => {
+      if (segment.startsWith(':')) {
+        names.push(getParamName(segment));
+        const paramPattern = '([^/]+)';
+        return segment.endsWith('?')
+          ? `(?:/${paramPattern})?`
+          : `/${paramPattern}`;
+      }
+      if (segment === '*') {
+        names.push('*');
+        return '/(.*)';
+      }
+      return `/${escapeRegExp(segment)}`;
+    })
+    .join('');
+
+  return {
+    names,
+    regexp: new RegExp(`^${source || '/'}$`),
+  };
+};
+
+const matchPathPattern = (
+  pathname: string,
+  pattern: string,
+): Record<string, string> | null => {
+  const { names, regexp } = compilePathPattern(pattern);
+  const match = regexp.exec(normalisePathPattern(pathname));
+  if (!match) {
+    return null;
+  }
+
+  return names.reduce<Record<string, string>>((params, name, index) => {
+    params[name] = decodeURIComponent(match[index + 1] || '');
+    return params;
+  }, {});
+};
+
+const buildPathFromPattern = (
+  pattern: string,
+  params: Record<string, string>,
+): string => {
+  const segments = normalisePathPattern(pattern).split('/').filter(Boolean);
+  const path = segments
+    .map(segment => {
+      if (segment.startsWith(':')) {
+        const param = params[getParamName(segment)];
+        return param ? encodeURIComponent(param) : '';
+      }
+      if (segment === '*') {
+        return params['*'] || '';
+      }
+      return segment;
+    })
+    .filter(Boolean)
+    .join('/');
+
+  return `/${path}`;
+};
+
+export const resolveLocalisedPath = (
+  pathname: string,
+  targetLanguage: string,
+  languages: string[],
+  localisedUrls: LocalisedUrlsMap,
+): string => {
+  const normalizedPathname = normalisePathPattern(pathname);
+
+  for (const localisedUrlEntry of Object.values(localisedUrls)) {
+    const targetPattern = localisedUrlEntry[targetLanguage];
+    if (!targetPattern) {
+      continue;
+    }
+
+    for (const language of languages) {
+      const sourcePattern = localisedUrlEntry[language];
+      if (!sourcePattern) {
+        continue;
+      }
+
+      const params = matchPathPattern(normalizedPathname, sourcePattern);
+      if (params) {
+        return buildPathFromPattern(targetPattern, params);
+      }
+    }
+  }
+
+  return normalizedPathname;
+};

package/src/shared/type.ts

@@ -2,6 +2,7 @@ import type {
   LanguageDetectorOptions,
   Resources,
 } from '../runtime/i18n/instance';
+import type { LocalisedUrlsOption } from './localisedUrls';
 
 export interface BaseLocaleDetectionOptions {
   localePathRedirect?: boolean;
@@ -10,6 +11,17 @@ export interface BaseLocaleDetectionOptions {
   fallbackLanguage?: string;
   detection?: LanguageDetectorOptions;
   ignoreRedirectRoutes?: string[] | ((pathname: string) => boolean);
+  /**
+   * Enables localised pathnames in addition to the locale prefix.
+   *
+   * - `false`: keep only locale-prefix behavior (`/en/about`).
+   * - object: map canonical route paths to every configured language.
+   *
+   * Defaults to `true` when `localePathRedirect` is enabled, so route
+   * generation validates that every localisable route path has entries for all
+   * configured languages.
+   */
+  localisedUrls?: LocalisedUrlsOption;
 }
 
 export interface LocaleDetectionOptions extends BaseLocaleDetectionOptions {