@bleedingdev/modern-js-plugin-i18n 3.5.0-ultramodern.4 → 3.5.0-ultramodern.40

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/middleware.d.ts

@@ -1,4 +1,4 @@
-import type { I18nInstance } from '../instance';
+import type { I18nInstance, LanguageDetectorOptions } from '../instance';
 /**
  * Register LanguageDetector plugin to i18n instance
  * Must be called before init() to properly register the detector
@@ -9,16 +9,16 @@ export declare const useI18nextLanguageDetector: (i18nInstance: I18nInstance) =>
  * Read language directly from localStorage/cookie
  * Fallback when detector is not available in services
  */
-export declare const readLanguageFromStorage: (detectionOptions?: any) => string | undefined;
+export declare const readLanguageFromStorage: (detectionOptions?: LanguageDetectorOptions) => string | undefined;
 /**
  * Detect language using i18next-browser-languagedetector
  * For initialized instances without detector in services, manually create a detector instance
  * For wrapper instances, access the underlying i18next instance's services
  */
-export declare const detectLanguage: (i18nInstance: I18nInstance, _request?: any, detectionOptions?: any) => string | undefined;
+export declare const detectLanguage: (i18nInstance: I18nInstance, _request?: unknown, detectionOptions?: LanguageDetectorOptions) => string | undefined;
 /**
  * Cache user language to localStorage/cookie
  * Uses LanguageDetector's cacheUserLanguage method when available
  * For wrapper instances, access the underlying i18next instance's services
  */
-export declare const cacheUserLanguage: (i18nInstance: I18nInstance, language: string, detectionOptions?: any) => void;
+export declare const cacheUserLanguage: (i18nInstance: I18nInstance, language: string, detectionOptions?: unknown) => void;

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

@@ -1,10 +1,10 @@
-import type { I18nInstance } from '../instance';
-export declare const cacheUserLanguage: (_i18nInstance: I18nInstance, _language: string, _detectionOptions?: any) => void;
+import type { I18nInstance, LanguageDetectorOptions } from '../instance';
+export declare const cacheUserLanguage: (_i18nInstance: I18nInstance, _language: string, _detectionOptions?: unknown) => void;
 /**
  * Read language directly from storage (localStorage/cookie)
  * Not available in Node.js environment, returns undefined
  */
-export declare const readLanguageFromStorage: (_detectionOptions?: any) => string | undefined;
+export declare const readLanguageFromStorage: (_detectionOptions?: LanguageDetectorOptions) => string | undefined;
 /**
  * Register LanguageDetector plugin to i18n instance
  * Must be called before init() to properly register the detector
@@ -14,4 +14,4 @@ export declare const useI18nextLanguageDetector: (i18nInstance: I18nInstance) =>
  * Detect language using i18next-http-middleware LanguageDetector
  * For initialized instances without detector in services, manually create a detector instance
  */
-export declare const detectLanguage: (i18nInstance: I18nInstance, request?: any, detectionOptions?: any) => string | undefined;
+export declare const detectLanguage: (i18nInstance: I18nInstance, request?: unknown, detectionOptions?: LanguageDetectorOptions) => 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,32 @@
+import type { BackendOptions, I18nInitOptions, LanguageDetectorOptions } from '../instance';
+export interface LanguageDetectionSsrContext {
+    request?: unknown;
+}
+export interface BaseLanguageDetectionOptions {
+    languages: string[];
+    fallbackLanguage: string;
+    localePathRedirect: boolean;
+    i18nextDetector: boolean;
+    detection?: LanguageDetectorOptions;
+    userInitOptions?: I18nInitOptions;
+    mergedBackend?: BackendOptions;
+}
+export interface LanguageDetectionOptions extends BaseLanguageDetectionOptions {
+    pathname: string;
+    ssrContext?: LanguageDetectionSsrContext;
+}
+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?: LanguageDetectorOptions;
+    mergeBackend?: BackendOptions;
+}

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

@@ -1,46 +1,48 @@
 import type { BaseBackendOptions } from '../../shared/type';
-export interface I18nResourceStore {
+interface I18nResourceStore {
     data?: {
         [language: string]: {
-            [namespace: string]: string | {
-                [key: string]: any;
-            };
+            [namespace: string]: ResourceValue;
         };
     };
     addResourceBundle?: (language: string, namespace: string, resources: Record<string, string>, deep?: boolean, overwrite?: boolean) => void;
 }
-export declare function isI18nWrapperInstance(obj: any): boolean;
-export declare function getI18nWrapperI18nextInstance(wrapperInstance: any): any;
-export declare function getActualI18nextInstance(instance: I18nInstance | any): any;
+type I18nWrapperInstance = I18nInstance & {
+    i18nInstance: {
+        instance: I18nInstance;
+    };
+};
+export declare function isI18nWrapperInstance(obj: unknown): obj is I18nWrapperInstance;
+export declare function getActualI18nextInstance(instance: I18nInstance): I18nInstance;
 export interface I18nInstance {
     language: string;
     isInitialized?: boolean;
     init: {
-        (callback?: (error: any, t: any) => void): Promise<any>;
-        (options: I18nInitOptions, callback?: (error: any, t: any) => void): Promise<any>;
+        (callback?: (error: unknown, t: unknown) => void): Promise<unknown>;
+        (options: I18nInitOptions, callback?: (error: unknown, t: unknown) => void): Promise<unknown>;
     };
-    changeLanguage?: (lng?: string, callback?: (error: any, t: any) => void) => Promise<any>;
+    changeLanguage?: (lng?: string, callback?: (error: unknown, t: unknown) => void) => Promise<unknown>;
     setLang?: (lang: string) => void | Promise<void>;
-    use: (plugin: any) => void;
+    use: (plugin: unknown) => void;
     createInstance?: (options?: I18nInitOptions) => I18nInstance;
     cloneInstance?: () => I18nInstance;
     store?: I18nResourceStore;
-    emit?: (event: string, ...args: any[]) => void;
+    emit?: (event: string, ...args: unknown[]) => void;
     reloadResources?: (language?: string, namespace?: string) => Promise<void>;
     services?: {
         languageDetector?: {
-            detect: (request?: any, options?: any) => string | string[] | undefined;
-            [key: string]: any;
+            detect: (request?: unknown, options?: unknown) => string | string[] | undefined;
+            [key: string]: unknown;
         };
         resourceStore?: I18nResourceStore;
-        backend?: any;
-        [key: string]: any;
+        backend?: unknown;
+        [key: string]: unknown;
     };
     options?: {
         backend?: BackendOptions;
-        [key: string]: any;
+        [key: string]: unknown;
     };
-    [key: string]: any;
+    [key: string]: unknown;
 }
 type LanguageDetectorOrder = string[];
 type LanguageDetectorCaches = boolean | string[];
@@ -57,11 +59,11 @@ export interface LanguageDetectorOptions {
     lookupHeader?: string;
 }
 export interface BackendOptions extends Omit<BaseBackendOptions, 'enabled'> {
-    parse?: (data: string) => any;
-    stringify?: (data: any) => string;
+    parse?: (data: string) => unknown;
+    stringify?: (data: unknown) => string;
     [key: string]: any;
 }
-export type ResourceValue = string | {
+type ResourceValue = string | {
     [key: string]: ResourceValue;
 };
 export interface Resources {
@@ -81,14 +83,14 @@ export type I18nInitOptions = {
     defaultNS?: string | string[];
     interpolation?: {
         escapeValue?: boolean;
-        [key: string]: any;
+        [key: string]: unknown;
     };
     react?: {
         useSuspense?: boolean;
-        [key: string]: any;
+        [key: string]: unknown;
     };
 };
-export declare function isI18nInstance(obj: any): obj is I18nInstance;
-export declare function getI18nextInstanceForProvider(instance: I18nInstance | any): any;
-export declare function getI18nInstance(userInstance?: I18nInstance | any): Promise<I18nInstance>;
+export declare function isI18nInstance(obj: unknown): obj is I18nInstance;
+export declare function getI18nextInstanceForProvider(instance: I18nInstance): I18nInstance;
+export declare function getI18nInstance(userInstance?: unknown): Promise<I18nInstance>;
 export {};

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/i18n/utils.d.ts

@@ -1,10 +1,18 @@
 import type { BaseBackendOptions } from '../../shared/type';
 import type { I18nInitOptions, I18nInstance } from './instance';
-export declare function assertI18nInstance(obj: any): asserts obj is I18nInstance;
+type MergedBackendOptions = NonNullable<I18nInitOptions['backend']> & {
+    _useChainedBackend?: boolean;
+    _chainedBackendConfig?: {
+        backendOptions: Array<Record<string, unknown>>;
+    };
+    backends?: unknown[];
+    backendOptions?: unknown;
+};
+export declare function assertI18nInstance(obj: unknown): asserts obj is I18nInstance;
 /**
  * Build initialization options for i18n instance
  */
-export declare const buildInitOptions: (finalLanguage: string, fallbackLanguage: string, languages: string[], mergedDetection: any, mergedBackend: any, userInitOptions?: I18nInitOptions, useSuspense?: boolean, i18nInstance?: I18nInstance) => Promise<I18nInitOptions>;
+export declare const buildInitOptions: (finalLanguage: string, fallbackLanguage: string, languages: string[], mergedDetection: I18nInitOptions['detection'], mergedBackend: MergedBackendOptions | undefined, userInitOptions?: I18nInitOptions, useSuspense?: boolean, i18nInstance?: I18nInstance) => Promise<I18nInitOptions>;
 /**
  * Ensure i18n instance language matches the final detected language
  */
@@ -17,13 +25,14 @@ export declare const ensureLanguageMatch: (i18nInstance: I18nInstance, finalLang
  * @param options - Optional configuration
  */
 export declare const changeI18nLanguage: (i18nInstance: I18nInstance, newLang: string, options?: {
-    detectionOptions?: any;
+    detectionOptions?: I18nInitOptions['detection'];
 }) => Promise<void>;
 /**
  * Initialize i18n instance if not already initialized
  */
-export declare const initializeI18nInstance: (i18nInstance: I18nInstance, finalLanguage: string, fallbackLanguage: string, languages: string[], mergedDetection: any, mergedBackend: any, userInitOptions?: I18nInitOptions, useSuspense?: boolean) => Promise<void>;
+export declare const initializeI18nInstance: (i18nInstance: I18nInstance, finalLanguage: string, fallbackLanguage: string, languages: string[], mergedDetection: I18nInitOptions['detection'], mergedBackend: MergedBackendOptions | undefined, userInitOptions?: I18nInitOptions, useSuspense?: boolean) => Promise<void>;
 /**
  * Setup cloned instance for SSR with backend support
  */
-export declare const setupClonedInstance: (i18nInstance: I18nInstance, finalLanguage: string, fallbackLanguage: string, languages: string[], backendEnabled: boolean, backend: BaseBackendOptions | undefined, i18nextDetector: boolean, detection: any, localePathRedirect: boolean, userInitOptions: I18nInitOptions | undefined) => Promise<void>;
+export declare const setupClonedInstance: (i18nInstance: I18nInstance, finalLanguage: string, fallbackLanguage: string, languages: string[], backendEnabled: boolean, backend: BaseBackendOptions | undefined, i18nextDetector: boolean, detection: I18nInitOptions['detection'], localePathRedirect: boolean, userInitOptions: I18nInitOptions | undefined) => Promise<void>;
+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>;
+}
+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,16 @@
+import type React from 'react';
+import type { BaseLocaleDetectionOptions } from '../shared/type';
+import type { I18nInstance } from './i18n';
+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;
+export {};

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/runtime/routerAdapter.d.ts

@@ -1,21 +1,21 @@
 import type React from 'react';
-export type I18nRouterFramework = 'react-router' | 'tanstack' | string;
-export interface I18nRouterLocation {
+type I18nRouterFramework = 'react-router' | 'tanstack' | string;
+interface I18nRouterLocation {
     pathname: string;
     search: string;
     hash: string;
 }
-export interface I18nRouterNavigateOptions {
+interface I18nRouterNavigateOptions {
     replace?: boolean;
     state?: unknown;
 }
-export type I18nRouterNavigate = (href: string, options?: I18nRouterNavigateOptions) => void | Promise<void>;
-export type I18nRouterLink = React.ComponentType<{
+type I18nRouterNavigate = (href: string, options?: I18nRouterNavigateOptions) => void | Promise<void>;
+type I18nRouterLink = React.ComponentType<{
     to: string;
     children?: React.ReactNode;
     [key: string]: unknown;
 }>;
-export interface I18nRouterAdapter {
+interface I18nRouterAdapter {
     framework?: I18nRouterFramework;
     hasRouter: boolean;
     location: I18nRouterLocation | null;
@@ -24,3 +24,4 @@ export interface I18nRouterAdapter {
     params: Record<string, string>;
 }
 export declare const useI18nRouterAdapter: () => I18nRouterAdapter;
+export {};

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

@@ -1,6 +1,11 @@
-import { type TInternalRuntimeContext } from '@modern-js/runtime/context';
 import type { LocalisedUrlsOption } from '../shared/localisedUrls';
-export declare const getPathname: (context: TInternalRuntimeContext) => string;
+export declare const getPathname: (context: {
+    ssrContext?: {
+        request?: {
+            pathname?: string;
+        };
+    };
+}) => string;
 export declare const getEntryPath: () => string;
 /**
  * Helper function to get language from current pathname

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;
+};

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[];