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

package/dist/esm-node/shared/localisedUrls.mjs

@@ -1,284 +1,2 @@
 import "node:module";
-const LOCALE_PARAM_NAMES = new Set([
-    'lang',
-    'locale',
-    'language'
-]);
-const normaliseSlashes = (path)=>{
-    const withoutDuplicateSlashes = path.replace(/\/+/g, '/');
-    const withLeadingSlash = withoutDuplicateSlashes.startsWith('/') ? withoutDuplicateSlashes : `/${withoutDuplicateSlashes}`;
-    return withLeadingSlash.length > 1 ? withLeadingSlash.replace(/\/+$/, '') : withLeadingSlash;
-};
-const normalisePathPattern = (path)=>normaliseSlashes(path).replace(/\[(.+?)\]/g, ':$1');
-const normalisePathname = (pathname)=>normaliseSlashes(pathname);
-const normaliseRoutePath = (path)=>{
-    const normalized = normalisePathPattern(path);
-    return '/' === normalized ? '' : normalized.slice(1);
-};
-const getLocaleParamSegment = (segment)=>{
-    if (!segment.startsWith(':')) return null;
-    const paramName = segment.slice(1).replace(/\?$/, '');
-    return LOCALE_PARAM_NAMES.has(paramName) ? segment : null;
-};
-const splitPathSegments = (path)=>{
-    if (!path) return [];
-    return normalisePathPattern(path).split('/').filter(Boolean);
-};
-const stripLeadingLocaleParam = (path)=>{
-    const segments = splitPathSegments(path);
-    const leadingLocaleParam = getLocaleParamSegment(segments[0] || '');
-    if (!leadingLocaleParam) return path;
-    const remainingPath = segments.slice(1).join('/');
-    return remainingPath ? `/${remainingPath}` : void 0;
-};
-const getLeadingLocaleParam = (path)=>{
-    const segments = splitPathSegments(path);
-    return getLocaleParamSegment(segments[0] || '');
-};
-const resolveLocalisedUrlsConfig = (option)=>{
-    if (option && 'object' == typeof option && Object.keys(option).length > 0) return {
-        enabled: true,
-        map: option
-    };
-    return {
-        enabled: false,
-        map: {}
-    };
-};
-const isLocalisableRoutePath = (path)=>{
-    const pathWithoutLocale = stripLeadingLocaleParam(path);
-    if (!pathWithoutLocale || '/' === pathWithoutLocale || '*' === pathWithoutLocale) return false;
-    return true;
-};
-const joinPath = (parentPath, routePath)=>{
-    if (!isLocalisableRoutePath(routePath)) return parentPath;
-    const segment = normaliseRoutePath(stripLeadingLocaleParam(routePath) || '');
-    return normalisePathPattern(`${parentPath}/${segment}`);
-};
-const ensureLocalisedUrlsForPath = (canonicalPath, languages, localisedUrls)=>{
-    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;
-};
-const validateLocalisedUrls = (routes, languages, localisedUrls)=>{
-    const visit = (route, parentPath)=>{
-        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, parentLocalisedPaths, languages, entry)=>{
-    const paths = languages.map((language)=>{
-        const fullPath = normalisePathPattern(entry[language]);
-        const parentPath = normalisePathPattern(parentLocalisedPaths[language] || '/');
-        if ('/' === parentPath) return normaliseRoutePath(fullPath) || void 0;
-        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)));
-};
-const transformLocalisedRoute = (route, parentCanonicalPath, parentLocalisedPaths, languages, localisedUrls)=>{
-    const canonicalPath = joinPath(parentCanonicalPath, route.path);
-    const localisedUrlEntry = isLocalisableRoutePath(route.path) ? ensureLocalisedUrlsForPath(canonicalPath, languages, localisedUrls) : void 0;
-    const routeLocalisedPaths = localisedUrlEntry ? languages.reduce((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)) : void 0;
-    const baseRoute = {
-        ...route,
-        ...children ? {
-            children
-        } : {}
-    };
-    if (!localisedUrlEntry) return [
-        baseRoute
-    ];
-    return getLocalisedRoutePaths(canonicalPath, parentLocalisedPaths, languages, localisedUrlEntry).map((localisedPath, index)=>cloneRouteWithLocalisedPath(baseRoute, localisedPath, index, canonicalPath));
-};
-const legalRouteIdPart = (value)=>value.replace(/[^a-zA-Z0-9_$-]+/g, '_').replace(/^_+|_+$/g, '') || 'index';
-const suffixRouteIds = (route, suffix)=>{
-    const children = 'children' in route && route.children ? route.children.map((child)=>suffixRouteIds(child, suffix)) : void 0;
-    return {
-        ...route,
-        ...route.id ? {
-            id: `${route.id}__localised_${suffix}`
-        } : {},
-        ...children ? {
-            children
-        } : {}
-    };
-};
-const cloneRouteWithLocalisedPath = (route, path, index, canonicalPath)=>{
-    const leadingLocaleParam = getLeadingLocaleParam(route.path);
-    const localisedPath = leadingLocaleParam ? normaliseRoutePath(`${leadingLocaleParam}/${path}`) : path;
-    const routeWithPath = {
-        ...route,
-        path: localisedPath
-    };
-    routeWithPath.modernCanonicalPath = canonicalPath;
-    return 0 === index ? routeWithPath : suffixRouteIds(routeWithPath, legalRouteIdPart(localisedPath));
-};
-const applyLocalisedUrlsToRoutes = (routes, languages, localisedUrls)=>{
-    const rootLocalisedPaths = languages.reduce((acc, language)=>{
-        acc[language] = '/';
-        return acc;
-    }, {});
-    validateLocalisedUrls(routes, languages, localisedUrls);
-    return routes.flatMap((route)=>transformLocalisedRoute(route, '', rootLocalisedPaths, languages, localisedUrls));
-};
-const escapeRegExp = (value)=>value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-const getParamName = (segment)=>segment.slice(1).replace(/\?$/, '');
-const compiledPathPatternCache = new Map();
-const compilePathPattern = (pattern)=>{
-    const normalizedPattern = normalisePathPattern(pattern);
-    const cached = compiledPathPatternCache.get(normalizedPattern);
-    if (cached) return cached;
-    const names = [];
-    const segments = normalizedPattern.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('');
-    const compiled = {
-        names,
-        regexp: new RegExp(`^${source || '/'}$`)
-    };
-    compiledPathPatternCache.set(normalizedPattern, compiled);
-    return compiled;
-};
-const getPatternSpecificity = (pattern)=>{
-    const segments = normalisePathPattern(pattern).split('/').filter(Boolean);
-    let staticSegments = 0;
-    let dynamicSegments = 0;
-    let splatSegments = 0;
-    for (const segment of segments)if ('*' === segment) splatSegments++;
-    else if (segment.startsWith(':')) dynamicSegments++;
-    else staticSegments++;
-    return {
-        staticSegments,
-        dynamicSegments,
-        splatSegments,
-        totalSegments: segments.length
-    };
-};
-const comparePatternSpecificity = (left, right)=>{
-    const a = getPatternSpecificity(left);
-    const b = getPatternSpecificity(right);
-    return b.staticSegments - a.staticSegments || b.totalSegments - a.totalSegments || a.splatSegments - b.splatSegments || a.dynamicSegments - b.dynamicSegments;
-};
-const sortPatternsBySpecificity = (patterns)=>patterns.map((pattern, index)=>({
-            pattern,
-            index
-        })).sort((left, right)=>comparePatternSpecificity(left.pattern.pattern, right.pattern.pattern) || left.index - right.index).map(({ pattern })=>pattern);
-const decodePathParam = (value)=>{
-    try {
-        return decodeURIComponent(value);
-    } catch  {
-        return null;
-    }
-};
-const matchPathPattern = (pathname, pattern)=>{
-    const { names, regexp } = compilePathPattern(pattern);
-    const match = regexp.exec(normalisePathname(pathname));
-    if (!match) return null;
-    const params = {};
-    for(let index = 0; index < names.length; index++){
-        const decoded = decodePathParam(match[index + 1] || '');
-        if (null === decoded) return null;
-        params[names[index]] = decoded;
-    }
-    return params;
-};
-const buildPathFromPattern = (pattern, params)=>{
-    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}`;
-};
-const resolveLocalisedPath = (pathname, targetLanguage, languages, localisedUrls)=>{
-    const normalizedPathname = normalisePathname(pathname);
-    const canonicalCandidates = sortPatternsBySpecificity(Object.entries(localisedUrls).map(([canonicalPattern, localisedUrlEntry])=>({
-            pattern: canonicalPattern,
-            canonicalPattern,
-            localisedUrlEntry
-        })));
-    for (const { canonicalPattern, localisedUrlEntry } of canonicalCandidates){
-        const targetPattern = localisedUrlEntry[targetLanguage];
-        if (!targetPattern) continue;
-        const params = matchPathPattern(normalizedPathname, canonicalPattern);
-        if (params) return buildPathFromPattern(targetPattern, params);
-    }
-    const localisedCandidates = sortPatternsBySpecificity(Object.values(localisedUrls).flatMap((localisedUrlEntry)=>{
-        const targetPattern = localisedUrlEntry[targetLanguage];
-        if (!targetPattern) return [];
-        return languages.map((language)=>localisedUrlEntry[language]).filter((sourcePattern)=>Boolean(sourcePattern)).map((sourcePattern)=>({
-                pattern: sourcePattern,
-                sourcePattern,
-                targetPattern
-            }));
-    }));
-    for (const { sourcePattern, targetPattern } of localisedCandidates){
-        const params = matchPathPattern(normalizedPathname, sourcePattern);
-        if (params) return buildPathFromPattern(targetPattern, params);
-    }
-    return normalizedPathname;
-};
-const resolveCanonicalLocalisedPath = (pathname, languages, localisedUrls)=>{
-    const normalizedPathname = normalisePathname(pathname);
-    const canonicalCandidates = sortPatternsBySpecificity(Object.entries(localisedUrls).map(([canonicalPattern, localisedUrlEntry])=>({
-            pattern: canonicalPattern,
-            canonicalPattern,
-            localisedUrlEntry
-        })));
-    for (const { canonicalPattern, localisedUrlEntry } of canonicalCandidates){
-        const canonicalParams = matchPathPattern(normalizedPathname, canonicalPattern);
-        if (canonicalParams) return buildPathFromPattern(canonicalPattern, canonicalParams);
-        for (const language of languages){
-            const sourcePattern = localisedUrlEntry[language];
-            if (!sourcePattern) continue;
-            const params = matchPathPattern(normalizedPathname, sourcePattern);
-            if (params) return buildPathFromPattern(canonicalPattern, params);
-        }
-    }
-    return normalizedPathname;
-};
-const stripLanguagePrefix = (pathname, languages)=>{
-    const segments = pathname.split('/').filter(Boolean);
-    if (segments.length > 0 && languages.includes(segments[0])) return `/${segments.slice(1).join('/')}`;
-    return pathname || '/';
-};
-const localiseTargetPathname = (pathname, language, languages, localisedUrls)=>{
-    const pathWithoutLanguage = stripLanguagePrefix(pathname, languages);
-    const localisedUrlsConfig = resolveLocalisedUrlsConfig(localisedUrls);
-    const resolvedPath = localisedUrlsConfig.enabled ? resolveLocalisedPath(pathWithoutLanguage, language, languages, localisedUrlsConfig.map) : pathWithoutLanguage;
-    const resolvedSegments = resolvedPath.split('/').filter(Boolean);
-    return `/${[
-        language,
-        ...resolvedSegments
-    ].join('/')}`;
-};
-const canonicalTargetPathname = (pathname, languages, localisedUrls)=>{
-    const pathWithoutLanguage = stripLanguagePrefix(pathname, languages);
-    const localisedUrlsConfig = resolveLocalisedUrlsConfig(localisedUrls);
-    return localisedUrlsConfig.enabled ? resolveCanonicalLocalisedPath(pathWithoutLanguage, languages, localisedUrlsConfig.map) : pathWithoutLanguage;
-};
-export { applyLocalisedUrlsToRoutes, buildPathFromPattern, canonicalTargetPathname, localiseTargetPathname, matchPathPattern, normalisePathPattern, normalisePathname, resolveCanonicalLocalisedPath, resolveLocalisedPath, resolveLocalisedUrlsConfig, validateLocalisedUrls };
+export { applyLocalisedUrlsToRoutes, buildPathFromPattern, canonicalTargetPathname, localiseTargetPathname, matchPathPattern, normalisePathPattern, normalisePathname, resolveCanonicalLocalisedPath, resolveLocalisedPath, resolveLocalisedUrlsConfig, validateLocalisedUrls } from "./localisedUrls/index.mjs";

package/dist/types/runtime/Link.d.ts

@@ -1,12 +1,8 @@
 import type React from 'react';
 import type { LinkParamsProp, LinkTargetPathname, ValidateLinkTo } from './canonicalRoutes';
-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 declare const interpolateRouteParams: (pathname: string, params?: LinkParams) => string;
+import { interpolateRouteParams, type LinkParams } from './linkHelpers';
+export type { LinkParams };
+export { interpolateRouteParams };
 export interface LinkActiveOptions {
     /**
      * `true`: active only when the location matches the target exactly.

package/dist/types/runtime/context.d.ts

@@ -32,9 +32,9 @@ export interface UseModernI18nReturn {
  * This hook provides:
  * - Current language from URL params or i18n context
  * - changeLanguage function that updates both i18n instance and URL
- * - Direct access to the i18n instance
+ * - Direct access to i18n instance
  * - List of supported languages
- * - Helper function to check if a language is supported
+ * - Helper function to check if language is supported
  *
  * @param options - Optional configuration to override context settings
  * @returns Object containing i18n functionality and utilities

package/dist/types/runtime/contextHelpers.d.ts

@@ -0,0 +1,28 @@
+import type { LocalisedUrlsOption } from '../shared/localisedUrls';
+import type { I18nInstance } from './i18n';
+type Navigate = (url: string, options?: {
+    replace?: boolean;
+}) => Promise<void> | void;
+type LocationLike = {
+    pathname: string;
+    search: string;
+    hash: string;
+};
+export declare function getPathLanguage(pathname: string | undefined, languages: string[] | undefined, localePathRedirect: boolean | undefined): string | undefined;
+export declare function cacheI18nLanguage(i18nInstance: I18nInstance, language: string): void;
+export interface ChangeModernI18nLanguageOptions {
+    i18nInstance: I18nInstance;
+    updateLanguage?: (newLang: string) => void;
+    localePathRedirect?: boolean;
+    ignoreRedirectRoutes?: string[] | ((pathname: string) => boolean);
+    localisedUrls?: LocalisedUrlsOption;
+    languages?: string[];
+    hasRouter: boolean;
+    navigate?: Navigate | null;
+    location?: LocationLike | null;
+}
+export declare function changeModernI18nLanguage(newLang: string, options: ChangeModernI18nLanguageOptions): Promise<void>;
+export declare function translateI18n(i18nInstance: I18nInstance, key: string | string[], ...args: any[]): string;
+export declare function isI18nLanguageSupported(languages: string[] | undefined, lang: string): boolean;
+export declare function isI18nResourcesReady(i18nInstance: I18nInstance, currentLanguage: string): boolean;
+export {};

package/dist/types/runtime/core.d.ts

@@ -1,10 +1,11 @@
-import { type RuntimePlugin } from '@modern-js/runtime';
-import type React from 'react';
+import type { RuntimePlugin } from '@modern-js/runtime';
 import type { BaseBackendOptions, BaseLocaleDetectionOptions } from '../shared/type';
 import type { I18nInitOptions, I18nInstance } from './i18n';
+import { type LoadReactI18nextIntegration } from './reactI18next';
 import './types';
 export type { I18nSdkLoader, I18nSdkLoadOptions } from '../shared/type';
 export type { Resources } from './i18n/instance';
+export type { LoadReactI18nextIntegration, ReactI18nextIntegration, } from './reactI18next';
 export interface I18nPluginOptions {
     entryName?: string;
     localeDetection?: BaseLocaleDetectionOptions;
@@ -16,11 +17,6 @@ export interface I18nPluginOptions {
     reactI18next?: boolean;
     [key: string]: any;
 }
-export interface ReactI18nextIntegration {
-    I18nextProvider: React.ComponentType<any> | null;
-    initReactI18next: any | null;
-}
-export type LoadReactI18nextIntegration = () => Promise<ReactI18nextIntegration | null>;
 export declare const createI18nPlugin: (loadReactI18nextIntegration?: LoadReactI18nextIntegration) => ((options: I18nPluginOptions) => RuntimePlugin);
 export type { AllowedLinkTarget, CanonicalRoutePath, UltramodernCanonicalRoutes, } from './canonicalRoutes';
 export { useModernI18n } from './context';

package/dist/types/runtime/i18n/detection/cache.d.ts

@@ -0,0 +1,14 @@
+import type { I18nInitOptions, I18nInstance, LanguageDetectorOptions } from '../instance';
+interface DetectorCacheEntry {
+    instance: I18nInstance;
+    isTemporary: boolean;
+    configKey: string;
+}
+export declare const detectorInstanceCache: WeakMap<I18nInstance, DetectorCacheEntry>;
+export declare const buildDetectorConfigKey: (languages: string[], fallbackLanguage: string, mergedDetection: LanguageDetectorOptions) => string;
+export declare const pickSafeDetectionOptions: (userInitOptions?: I18nInitOptions) => Partial<I18nInitOptions> & Record<string, any>;
+export declare const createDetectorInstance: (baseInstance: I18nInstance, configKey: string) => {
+    instance: I18nInstance;
+    isTemporary: boolean;
+};
+export {};

package/dist/types/runtime/i18n/detection/detector.d.ts

@@ -0,0 +1,8 @@
+import type { I18nInstance } from '../instance';
+import type { BaseLanguageDetectionOptions } from './types';
+/**
+ * Priority 3: Detect language using i18next detector
+ */
+export declare const detectLanguageFromI18nextDetector: (i18nInstance: I18nInstance, options: BaseLanguageDetectionOptions & {
+    ssrContext?: any;
+}) => Promise<string | undefined>;

package/dist/types/runtime/i18n/detection/index.d.ts

@@ -1,50 +1,5 @@
-import { type TRuntimeContext } from '@modern-js/runtime';
-import type { I18nInitOptions, I18nInstance, LanguageDetectorOptions } from '../instance';
-import { cacheUserLanguage } from './middleware';
-export { cacheUserLanguage };
-export declare function exportServerLngToWindow(context: TRuntimeContext, lng: string): void;
-export declare const getLanguageFromSSRData: (window: Window) => string | undefined;
-export interface BaseLanguageDetectionOptions {
-    languages: string[];
-    fallbackLanguage: string;
-    localePathRedirect: boolean;
-    i18nextDetector: boolean;
-    detection?: LanguageDetectorOptions;
-    userInitOptions?: I18nInitOptions;
-    mergedBackend?: any;
-}
-export interface LanguageDetectionOptions extends BaseLanguageDetectionOptions {
-    pathname: string;
-    ssrContext?: any;
-}
-export interface LanguageDetectionResult {
-    detectedLanguage?: string;
-    finalLanguage: string;
-}
-/**
- * Detect language with priority:
- * Priority 1: SSR data (try window._SSR_DATA first, works for both SSR and CSR)
- * Priority 2: Path detection
- * Priority 3: i18next detector (reads from cookie/localStorage)
- * Priority 4: User config language or fallback
- */
-export declare const detectLanguageWithPriority: (i18nInstance: I18nInstance, options: LanguageDetectionOptions) => Promise<LanguageDetectionResult>;
-/**
- * Options for building i18n init options
- */
-export interface BuildInitOptionsParams {
-    finalLanguage: string;
-    fallbackLanguage: string;
-    languages: string[];
-    userInitOptions?: I18nInitOptions;
-    mergedDetection?: any;
-    mergeBackend?: any;
-}
-/**
- * Build i18n initialization options
- */
-export declare const buildInitOptions: (params: BuildInitOptionsParams) => I18nInitOptions;
-/**
- * Merge detection and backend options
- */
-export declare const mergeDetectionOptions: (i18nextDetector: boolean, detection?: LanguageDetectorOptions, localePathRedirect?: boolean, userInitOptions?: I18nInitOptions) => LanguageDetectorOptions;
+export { buildInitOptions, mergeDetectionOptions } from './initOptions';
+export { cacheUserLanguage } from './middleware';
+export { detectLanguageWithPriority } from './priority';
+export { exportServerLngToWindow, getLanguageFromSSRData } from './ssr';
+export type { BaseLanguageDetectionOptions, BuildInitOptionsParams, LanguageDetectionOptions, LanguageDetectionResult, } from './types';

package/dist/types/runtime/i18n/detection/initOptions.d.ts

@@ -0,0 +1,10 @@
+import type { I18nInitOptions, LanguageDetectorOptions } from '../instance';
+import type { BuildInitOptionsParams } from './types';
+/**
+ * Build i18n initialization options
+ */
+export declare const buildInitOptions: (params: BuildInitOptionsParams) => I18nInitOptions;
+/**
+ * Merge detection and backend options
+ */
+export declare const mergeDetectionOptions: (i18nextDetector: boolean, detection?: LanguageDetectorOptions, localePathRedirect?: boolean, userInitOptions?: I18nInitOptions) => LanguageDetectorOptions;

package/dist/types/runtime/i18n/detection/language.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Check if a language is supported
+ * Also checks the base language code (e.g., 'zh-CN' matches 'zh')
+ */
+export declare const isLanguageSupported: (language: string | undefined, supportedLanguages: string[]) => boolean;
+/**
+ * Get the supported language that matches the given language
+ * Returns the exact match if available, otherwise returns the base language code match
+ * Returns undefined if no match is found
+ */
+export declare const getSupportedLanguage: (language: string | undefined, supportedLanguages: string[]) => string | undefined;

package/dist/types/runtime/i18n/detection/path.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Priority 2: Detect language from URL path
+ * Only returns a language if the path explicitly contains a language prefix
+ */
+export declare const detectLanguageFromPathPriority: (pathname: string, languages: string[], localePathRedirect: boolean) => string | undefined;

package/dist/types/runtime/i18n/detection/priority.d.ts

@@ -0,0 +1,10 @@
+import { type I18nInstance } from '../instance';
+import type { LanguageDetectionOptions, LanguageDetectionResult } from './types';
+/**
+ * Detect language with priority:
+ * Priority 1: Path detection
+ * Priority 2: SSR data (try window._SSR_DATA first, works for both SSR and CSR)
+ * Priority 3: i18next detector (reads from cookie/localStorage)
+ * Priority 4: User config language or fallback
+ */
+export declare const detectLanguageWithPriority: (i18nInstance: I18nInstance, options: LanguageDetectionOptions) => Promise<LanguageDetectionResult>;

package/dist/types/runtime/i18n/detection/ssr.d.ts

@@ -0,0 +1,9 @@
+import { type TRuntimeContext } from '@modern-js/runtime';
+export declare function exportServerLngToWindow(context: TRuntimeContext, lng: string): void;
+export declare const getLanguageFromSSRData: (window: Window) => string | undefined;
+/**
+ * Priority 1: Detect language from SSR data
+ * Try to get language from window._SSR_DATA first (both SSR and CSR projects)
+ * Returns undefined if SSR data is not available or invalid
+ */
+export declare const detectLanguageFromSSR: (languages: string[]) => string | undefined;

package/dist/types/runtime/i18n/detection/types.d.ts

@@ -0,0 +1,29 @@
+import type { I18nInitOptions, LanguageDetectorOptions } from '../instance';
+export interface BaseLanguageDetectionOptions {
+    languages: string[];
+    fallbackLanguage: string;
+    localePathRedirect: boolean;
+    i18nextDetector: boolean;
+    detection?: LanguageDetectorOptions;
+    userInitOptions?: I18nInitOptions;
+    mergedBackend?: any;
+}
+export interface LanguageDetectionOptions extends BaseLanguageDetectionOptions {
+    pathname: string;
+    ssrContext?: any;
+}
+export interface LanguageDetectionResult {
+    detectedLanguage?: string;
+    finalLanguage: string;
+}
+/**
+ * Options for building i18n init options
+ */
+export interface BuildInitOptionsParams {
+    finalLanguage: string;
+    fallbackLanguage: string;
+    languages: string[];
+    userInitOptions?: I18nInitOptions;
+    mergedDetection?: any;
+    mergeBackend?: any;
+}

package/dist/types/runtime/i18n/react-i18next.d.ts

@@ -1,7 +1,2 @@
-import type React from 'react';
-interface ReactI18nextIntegration {
-    I18nextProvider: React.ComponentType<any> | null;
-    initReactI18next: any | null;
-}
+import type { ReactI18nextIntegration } from '../reactI18next';
 export declare function getReactI18nextIntegration(): Promise<ReactI18nextIntegration>;
-export {};

package/dist/types/runtime/linkHelpers.d.ts

@@ -0,0 +1,17 @@
+export declare const warnOnce: (key: string, message: string) => void;
+export type LinkParams = Record<string, string | number | undefined>;
+type NormalizedSearchValue = string | string[];
+/**
+ * Interpolate `$param`, `:param`, optional (`{-$param}` / `:param?`) and splat
+ * (`$` / `*`) segments with concrete values before localization, so
+ * pattern-mapped slugs localize correctly.
+ */
+export declare const interpolateRouteParams: (pathname: string, params?: LinkParams) => string;
+export declare const normalizeSearch: (search: string | Record<string, unknown> | undefined, searchFromTo: string) => {
+    searchString: string;
+    searchObject: Record<string, NormalizedSearchValue> | undefined;
+};
+type ActivePropsResult<TActiveProps extends Record<string, unknown>> = Record<string, unknown> & Partial<TActiveProps>;
+export declare const splitActiveProps: <TActiveProps extends Record<string, unknown>>(active: boolean, activeProps?: TActiveProps) => ActivePropsResult<TActiveProps>;
+export declare const mergeClassNames: (...values: Array<unknown>) => string | undefined;
+export {};

package/dist/types/runtime/pluginSetup.d.ts

@@ -0,0 +1,32 @@
+import type { TInternalRuntimeContext } from '@modern-js/runtime/internal';
+import type { BaseBackendOptions, BaseLocaleDetectionOptions } from '../shared/type';
+import type { I18nInitOptions, I18nInstance } from './i18n';
+import type { ReactI18nextIntegration } from './reactI18next';
+interface RuntimeConfigWithI18n {
+    i18n?: {
+        initOptions?: I18nInitOptions;
+    };
+}
+interface I18nRuntimeApi {
+    getRuntimeConfig: () => RuntimeConfigWithI18n;
+}
+export interface RuntimeContextWithI18n extends TInternalRuntimeContext {
+    i18nInstance?: I18nInstance;
+    changeLanguage?: (lang: string) => Promise<void>;
+}
+export interface SetupI18nBeforeRenderOptions {
+    api: I18nRuntimeApi;
+    userI18nInstance?: I18nInstance;
+    initOptions?: I18nInitOptions;
+    backend?: BaseBackendOptions;
+    backendEnabled: boolean;
+    i18nextDetector: boolean;
+    detection?: BaseLocaleDetectionOptions['detection'];
+    localePathRedirect: boolean;
+    languages: string[];
+    fallbackLanguage: string;
+    resolveReactI18nextIntegration: () => Promise<ReactI18nextIntegration | null>;
+    setI18nextProvider: (provider: ReactI18nextIntegration['I18nextProvider']) => void;
+}
+export declare function setupI18nBeforeRender(context: RuntimeContextWithI18n, options: SetupI18nBeforeRenderOptions): Promise<I18nInstance>;
+export {};

package/dist/types/runtime/providerComposition.d.ts

@@ -0,0 +1,15 @@
+import type React from 'react';
+import type { BaseLocaleDetectionOptions } from '../shared/type';
+import type { I18nInstance } from './i18n';
+export interface I18nRootWrapperOptions {
+    entryName?: string;
+    htmlLangAttr: boolean;
+    localePathRedirect: boolean;
+    languages: string[];
+    fallbackLanguage: string;
+    ignoreRedirectRoutes?: BaseLocaleDetectionOptions['ignoreRedirectRoutes'];
+    localisedUrls?: BaseLocaleDetectionOptions['localisedUrls'];
+    getLatestI18nInstance: () => I18nInstance | undefined;
+    getI18nextProvider: () => React.ComponentType<any> | null | undefined;
+}
+export declare const createI18nRootWrapper: (options: I18nRootWrapperOptions) => (App: React.ComponentType<any>) => (props: Record<string, unknown>) => React.JSX.Element;

package/dist/types/runtime/reactI18next.d.ts

@@ -0,0 +1,7 @@
+import type React from 'react';
+export interface ReactI18nextIntegration {
+    I18nextProvider: React.ComponentType<any> | null;
+    initReactI18next: any | null;
+}
+export type LoadReactI18nextIntegration = () => Promise<ReactI18nextIntegration | null>;
+export declare const resolveReactI18nextIntegration: (reactI18next: boolean, loadReactI18nextIntegration?: LoadReactI18nextIntegration) => Promise<ReactI18nextIntegration | null>;

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

@@ -0,0 +1,7 @@
+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 {};

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

@@ -0,0 +1,21 @@
+import type { LanguageDetectorOptions } from '../runtime/i18n/instance';
+/**
+ * Convert i18next detection options to hono languageDetector options
+ */
+export declare const convertToHonoLanguageDetectorOptions: (languages: string[], fallbackLanguage: string, detectionOptions?: LanguageDetectorOptions) => {
+    supportedLanguages: string[];
+    fallbackLanguage: string;
+    order: ("cookie" | "header" | "path" | "querystring")[];
+    lookupQueryString: string;
+    lookupCookie: string;
+    lookupFromHeaderKey: string;
+    caches?: false | ["cookie"] | undefined;
+    cookieOptions?: {
+        maxAge: number;
+        sameSite: "Lax" | "None" | "Strict";
+        secure: boolean;
+        httpOnly: boolean;
+        domain?: string | undefined;
+    } | undefined;
+    ignoreCase: boolean;
+};