@bleedingdev/modern-js-plugin-i18n 3.2.0-ultramodern.3 → 3.2.0-ultramodern.30

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

@@ -0,0 +1,21 @@
+import type { AppTools, CliPlugin } from '@modern-js/app-tools';
+import type { Entrypoint } from '@modern-js/types';
+import type { BackendOptions, LocaleDetectionOptions } from '../shared/type';
+export type TransformRuntimeConfigFn = (extendedConfig: Record<string, any>, entrypoint: Entrypoint) => Record<string, any>;
+export interface I18nPluginOptions {
+    localeDetection?: LocaleDetectionOptions;
+    backend?: BackendOptions;
+    transformRuntimeConfig?: TransformRuntimeConfigFn;
+    customPlugin?: {
+        runtime?: {
+            name?: string;
+            path?: string;
+        };
+        server?: {
+            name?: string;
+        };
+    };
+    [key: string]: any;
+}
+export declare const i18nPlugin: (options?: I18nPluginOptions) => CliPlugin<AppTools>;
+export default i18nPlugin;

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

@@ -0,0 +1,23 @@
+import type React from 'react';
+export interface I18nLinkProps {
+    to: string;
+    children: React.ReactNode;
+    [key: string]: any;
+}
+/**
+ * I18nLink component that automatically adds language prefix to navigation links.
+ * This component should be used within a :lang dynamic route context.
+ *
+ * @example
+ * ```tsx
+ * // When current language is 'en' and to="/about"
+ * // The actual link will be "/en/about"
+ * <I18nLink to="/about">About</I18nLink>
+ *
+ * // When current language is 'zh' and to="/"
+ * // The actual link will be "/zh"
+ * <I18nLink to="/">Home</I18nLink>
+ * ```
+ */
+export declare const I18nLink: React.FC<I18nLinkProps>;
+export default I18nLink;

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

@@ -0,0 +1,41 @@
+import type { FC, ReactNode } from 'react';
+import type { LocalisedUrlsOption } from '../shared/localisedUrls';
+import type { I18nInstance } from './i18n';
+export interface ModernI18nContextValue {
+    language: string;
+    i18nInstance: I18nInstance;
+    entryName?: string;
+    languages?: string[];
+    localePathRedirect?: boolean;
+    ignoreRedirectRoutes?: string[] | ((pathname: string) => boolean);
+    localisedUrls?: LocalisedUrlsOption;
+    updateLanguage?: (newLang: string) => void;
+}
+export interface ModernI18nProviderProps {
+    children: ReactNode;
+    value: ModernI18nContextValue;
+}
+export declare const ModernI18nProvider: FC<ModernI18nProviderProps>;
+export interface UseModernI18nReturn {
+    language: string;
+    changeLanguage: (newLang: string) => Promise<void>;
+    i18nInstance: I18nInstance;
+    supportedLanguages: string[];
+    localisedUrls?: LocalisedUrlsOption;
+    isLanguageSupported: (lang: string) => boolean;
+    isResourcesReady: boolean;
+}
+/**
+ * Hook for accessing i18n functionality in Modern.js applications.
+ *
+ * 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
+ * - List of supported languages
+ * - Helper function to check if a language is supported
+ *
+ * @param options - Optional configuration to override context settings
+ * @returns Object containing i18n functionality and utilities
+ */
+export declare const useModernI18n: () => UseModernI18nReturn;

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

@@ -0,0 +1,30 @@
+import type { TRuntimeContext } from '@modern-js/runtime';
+import type React from 'react';
+import type { LocalisedUrlsOption } from '../shared/localisedUrls';
+import type { I18nInstance } from './i18n';
+interface RuntimeContextWithI18n extends TRuntimeContext {
+    i18nInstance?: I18nInstance;
+}
+export declare function createContextValue(lang: string, i18nInstance: I18nInstance | undefined, entryName: string | undefined, languages: string[], localePathRedirect: boolean, ignoreRedirectRoutes: string[] | ((pathname: string) => boolean) | undefined, localisedUrls: LocalisedUrlsOption | undefined, setLang: (lang: string) => void): {
+    language: string;
+    i18nInstance: I18nInstance;
+    entryName: string | undefined;
+    languages: string[];
+    localePathRedirect: boolean;
+    ignoreRedirectRoutes: string[] | ((pathname: string) => boolean) | undefined;
+    localisedUrls: LocalisedUrlsOption | undefined;
+    updateLanguage: (lang: string) => void;
+};
+export declare function useSdkResourcesLoader(i18nInstance: I18nInstance | undefined, setForceUpdate: React.Dispatch<React.SetStateAction<number>>): void;
+/**
+ * Hook to handle client-side redirect for locale path redirect in static deployments
+ * This ensures that when users access paths without language prefix, they are redirected
+ * to the localized version of the path
+ *
+ * Note: This hook only runs in CSR (Client-Side Rendering) scenarios.
+ * In SSR/SSG scenarios, server-side middleware handles redirects, so this hook is skipped.
+ * We use process.env.MODERN_TARGET to ensure this code is only included in browser bundles.
+ */
+export declare function useClientSideRedirect(i18nInstance: I18nInstance | undefined, localePathRedirect: boolean, languages: string[], fallbackLanguage: string, ignoreRedirectRoutes?: string[] | ((pathname: string) => boolean), localisedUrls?: LocalisedUrlsOption): void;
+export declare function useLanguageSync(i18nInstance: I18nInstance | undefined, localePathRedirect: boolean, languages: string[], runtimeContextRef: React.MutableRefObject<RuntimeContextWithI18n>, prevLangRef: React.MutableRefObject<string>, setLang: (lang: string) => void): void;
+export {};

package/dist/types/runtime/i18n/backend/config.d.ts

@@ -0,0 +1,2 @@
+import type { BackendOptions } from '../instance';
+export declare function mergeBackendOptions(defaultOptions: BackendOptions, cliOptions?: BackendOptions, userOptions?: BackendOptions): BackendOptions;

package/dist/types/runtime/i18n/backend/defaults.d.ts

@@ -0,0 +1,13 @@
+export declare const DEFAULT_I18NEXT_BACKEND_OPTIONS: {
+    loadPath: string;
+    addPath: string;
+};
+declare global {
+    interface Window {
+        __assetPrefix__?: string;
+    }
+}
+export declare function convertBackendOptions<T extends {
+    loadPath?: string;
+    addPath?: string;
+}>(options: T): T;

package/dist/types/runtime/i18n/backend/defaults.node.d.ts

@@ -0,0 +1,8 @@
+export declare const DEFAULT_I18NEXT_BACKEND_OPTIONS: {
+    loadPath: string;
+    addPath: string;
+};
+export declare function convertBackendOptions<T extends {
+    loadPath?: string;
+    addPath?: string;
+}>(options: T): T;

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

@@ -0,0 +1,3 @@
+import type { BaseBackendOptions } from '../../../shared/type';
+import type { BackendOptions, I18nInitOptions } from '../instance';
+export declare const mergeBackendOptions: (backend?: BaseBackendOptions, userInitOptions?: I18nInitOptions) => BackendOptions | undefined;

package/dist/types/runtime/i18n/backend/middleware.common.d.ts

@@ -0,0 +1,14 @@
+import type { BaseBackendOptions, ChainedBackendConfig } from '../../../shared/type';
+import type { I18nInstance } from '../instance';
+type BackendConfigWithChained = BaseBackendOptions & Partial<ChainedBackendConfig>;
+/**
+ * Common logic for using i18next backend
+ * This function handles the backend selection and chained backend configuration
+ *
+ * @param i18nInstance - The i18n instance to configure
+ * @param BackendWithSave - The wrapped backend class with save method (required for chained backend refresh logic)
+ * @param BackendBase - The base backend class (for non-chained use)
+ * @param backend - Optional backend configuration
+ */
+export declare function useI18nextBackendCommon(i18nInstance: I18nInstance, BackendWithSave: new (...args: any[]) => any, BackendBase: new (...args: any[]) => any, backend?: BackendConfigWithChained): void;
+export {};

package/dist/types/runtime/i18n/backend/middleware.d.ts

@@ -0,0 +1,12 @@
+import Backend from 'i18next-http-backend';
+import type { ExtendedBackendOptions } from '../../../shared/type';
+import type { I18nInstance } from '../instance';
+/**
+ * Wrapper for HTTP backend to add a no-op save method
+ * This is required for i18next-chained-backend to trigger refresh logic
+ * when cacheHitMode is 'refresh' or 'refreshAndUpdateStore'
+ */
+export declare class HttpBackendWithSave extends Backend {
+    save(_language: string, _namespace: string, _data: unknown): void;
+}
+export declare const useI18nextBackend: (i18nInstance: I18nInstance, backend?: ExtendedBackendOptions) => void;

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

@@ -0,0 +1,13 @@
+import Backend from 'i18next-fs-backend/cjs';
+import type { ExtendedBackendOptions } from '../../../shared/type';
+import type { I18nInstance } from '../instance';
+/**
+ * Wrapper for FS backend to add a no-op save method
+ * This is required for i18next-chained-backend to trigger refresh logic
+ * when cacheHitMode is 'refresh' or 'refreshAndUpdateStore'
+ */
+export declare class FsBackendWithSave extends Backend {
+    save(_language: string, _namespace: string, _data: unknown): void;
+}
+export declare const HttpBackendWithSave: typeof FsBackendWithSave;
+export declare const useI18nextBackend: (i18nInstance: I18nInstance, backend?: ExtendedBackendOptions) => void;

package/dist/types/runtime/i18n/backend/sdk-backend.d.ts

@@ -0,0 +1,53 @@
+import type { I18nSdkLoader } from '../../../shared/type';
+interface BackendOptions {
+    sdk?: I18nSdkLoader;
+    [key: string]: unknown;
+}
+interface I18nextServices {
+    resourceStore?: {
+        data?: {
+            [language: string]: {
+                [namespace: string]: Record<string, string>;
+            };
+        };
+    };
+    store?: {
+        data?: {
+            [language: string]: {
+                [namespace: string]: Record<string, string>;
+            };
+        };
+    };
+    [key: string]: any;
+}
+export declare class SdkBackend {
+    static type: string;
+    type: 'backend';
+    sdk?: I18nSdkLoader;
+    private allResourcesCache;
+    private backendId;
+    private loadingPromises;
+    private services?;
+    constructor(_services: unknown, _options: Record<string, unknown>);
+    init(services: I18nextServices, backendOptions: BackendOptions, _i18nextOptions: unknown): void;
+    read(language: string, namespace: string, callback: (error: Error | null, data: unknown) => void): void;
+    create(_languages: string[], _namespace: string, _key: string, _fallbackValue: string): void;
+    isLoading(language: string, namespace: string): boolean;
+    getLoadingResources(): Array<{
+        language: string;
+        namespace: string;
+    }>;
+    hasLoadingResources(): boolean;
+    private getCacheKey;
+    private loadResource;
+    private handlePromise;
+    private normalizeError;
+    private callSdk;
+    private extractFromCache;
+    private updateCache;
+    private formatResources;
+    private isObject;
+    private mergeWithExistingResources;
+    private triggerI18nextUpdate;
+}
+export {};

package/dist/types/runtime/i18n/backend/sdk-event.d.ts

@@ -0,0 +1,9 @@
+export declare const I18N_SDK_RESOURCES_LOADED_EVENT = "i18n-sdk-resources-loaded";
+export interface I18nSdkResourcesLoadedEventDetail {
+    language: string;
+    namespace: string;
+    backendId?: string;
+}
+export declare function createI18nSdkBackendId(): string;
+export declare function setI18nSdkBackendId(target: unknown, backendId: string): void;
+export declare function getI18nSdkBackendId(target: unknown): string | undefined;

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

@@ -0,0 +1,11 @@
+import type { LanguageDetectorOptions } from '../instance';
+export declare const DEFAULT_I18NEXT_DETECTION_OPTIONS: {
+    caches: string[];
+    order: string[];
+    cookieMinutes: number;
+    lookupQuerystring: string;
+    lookupCookie: string;
+    lookupLocalStorage: string;
+    lookupHeader: string;
+};
+export declare function mergeDetectionOptions(cliOptions?: LanguageDetectorOptions, userOptions?: LanguageDetectorOptions, defaultOptions?: LanguageDetectorOptions): LanguageDetectorOptions;

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

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

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

@@ -0,0 +1,24 @@
+import type { I18nInstance } from '../instance';
+/**
+ * Register LanguageDetector plugin to i18n instance
+ * Must be called before init() to properly register the detector
+ * For wrapper instances, ensure detector is registered on the underlying i18next instance
+ */
+export declare const useI18nextLanguageDetector: (i18nInstance: I18nInstance) => void | I18nInstance;
+/**
+ * Read language directly from localStorage/cookie
+ * Fallback when detector is not available in services
+ */
+export declare const readLanguageFromStorage: (detectionOptions?: any) => 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;
+/**
+ * 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;

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

@@ -0,0 +1,17 @@
+import type { I18nInstance } from '../instance';
+export declare const cacheUserLanguage: (_i18nInstance: I18nInstance, _language: string, _detectionOptions?: any) => void;
+/**
+ * Read language directly from storage (localStorage/cookie)
+ * Not available in Node.js environment, returns undefined
+ */
+export declare const readLanguageFromStorage: (_detectionOptions?: any) => string | undefined;
+/**
+ * Register LanguageDetector plugin to i18n instance
+ * Must be called before init() to properly register the detector
+ */
+export declare const useI18nextLanguageDetector: (i18nInstance: I18nInstance) => void | 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;

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

@@ -0,0 +1,3 @@
+export type { I18nInitOptions, I18nInstance, } from './instance';
+export { getI18nInstance, isI18nInstance } from './instance';
+export { assertI18nInstance } from './utils';

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

@@ -0,0 +1,96 @@
+import type { BaseBackendOptions } from '../../shared/type';
+type ReactI18nextModule = typeof import('react-i18next');
+type InitReactI18next = ReactI18nextModule['initReactI18next'];
+type I18nextProviderComponent = ReactI18nextModule['I18nextProvider'];
+export interface I18nResourceStore {
+    data?: {
+        [language: string]: {
+            [namespace: string]: string | {
+                [key: string]: any;
+            };
+        };
+    };
+    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;
+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>;
+    };
+    changeLanguage?: (lng?: string, callback?: (error: any, t: any) => void) => Promise<any>;
+    setLang?: (lang: string) => void | Promise<void>;
+    use: (plugin: any) => void;
+    createInstance?: (options?: I18nInitOptions) => I18nInstance;
+    cloneInstance?: () => I18nInstance;
+    store?: I18nResourceStore;
+    emit?: (event: string, ...args: any[]) => void;
+    reloadResources?: (language?: string, namespace?: string) => Promise<void>;
+    services?: {
+        languageDetector?: {
+            detect: (request?: any, options?: any) => string | string[] | undefined;
+            [key: string]: any;
+        };
+        resourceStore?: I18nResourceStore;
+        backend?: any;
+        [key: string]: any;
+    };
+    options?: {
+        backend?: BackendOptions;
+        [key: string]: any;
+    };
+    [key: string]: any;
+}
+type LanguageDetectorOrder = string[];
+type LanguageDetectorCaches = boolean | string[];
+export interface LanguageDetectorOptions {
+    order?: LanguageDetectorOrder;
+    lookupQuerystring?: string;
+    lookupCookie?: string;
+    lookupLocalStorage?: string;
+    lookupSession?: string;
+    lookupFromPathIndex?: number;
+    caches?: LanguageDetectorCaches;
+    cookieExpirationDate?: Date;
+    cookieDomain?: string;
+    lookupHeader?: string;
+}
+export interface BackendOptions extends Omit<BaseBackendOptions, 'enabled'> {
+    parse?: (data: string) => any;
+    stringify?: (data: any) => string;
+    [key: string]: any;
+}
+export interface Resources {
+    [lng: string]: {
+        [source: string]: string | Record<string, string>;
+    };
+}
+export type I18nInitOptions = {
+    lng?: string;
+    fallbackLng?: string;
+    supportedLngs?: string[];
+    initImmediate?: boolean;
+    detection?: LanguageDetectorOptions;
+    backend?: BackendOptions;
+    resources?: Resources;
+    ns?: string | string[];
+    defaultNS?: string | string[];
+    interpolation?: {
+        escapeValue?: boolean;
+        [key: string]: any;
+    };
+    react?: {
+        useSuspense?: boolean;
+        [key: string]: any;
+    };
+};
+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 getInitReactI18next(): Promise<InitReactI18next | null>;
+export declare function getI18nextProvider(): Promise<I18nextProviderComponent | null>;
+export {};

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

@@ -0,0 +1,29 @@
+import type { BaseBackendOptions } from '../../shared/type';
+import type { I18nInitOptions, I18nInstance } from './instance';
+export declare function assertI18nInstance(obj: any): 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>;
+/**
+ * Ensure i18n instance language matches the final detected language
+ */
+export declare const ensureLanguageMatch: (i18nInstance: I18nInstance, finalLanguage: string) => Promise<void>;
+/**
+ * Change language for i18n instance in onBeforeRender hook
+ * This function can be used by other runtime plugins to change language
+ * @param i18nInstance - The i18n instance
+ * @param newLang - The new language code to switch to
+ * @param options - Optional configuration
+ */
+export declare const changeI18nLanguage: (i18nInstance: I18nInstance, newLang: string, options?: {
+    detectionOptions?: any;
+}) => 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>;
+/**
+ * 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>;

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

@@ -0,0 +1,21 @@
+import { type RuntimePlugin } from '@modern-js/runtime';
+import type { BaseBackendOptions, BaseLocaleDetectionOptions } from '../shared/type';
+import type { I18nInitOptions, I18nInstance } from './i18n';
+import './types';
+export type { I18nSdkLoader, I18nSdkLoadOptions } from '../shared/type';
+export type { Resources } from './i18n/instance';
+export interface I18nPluginOptions {
+    entryName?: string;
+    localeDetection?: BaseLocaleDetectionOptions;
+    backend?: BaseBackendOptions;
+    i18nInstance?: I18nInstance;
+    changeLanguage?: (lang: string) => void;
+    initOptions?: I18nInitOptions;
+    htmlLangAttr?: boolean;
+    reactI18next?: boolean;
+    [key: string]: any;
+}
+export declare const i18nPlugin: (options: I18nPluginOptions) => RuntimePlugin;
+export { useModernI18n } from './context';
+export { I18nLink } from './I18nLink';
+export default i18nPlugin;

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

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

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

@@ -0,0 +1,15 @@
+import type { I18nInitOptions, I18nInstance } from './i18n';
+declare module '@modern-js/runtime' {
+    interface RuntimeConfig {
+        i18n?: {
+            i18nInstance?: I18nInstance;
+            changeLanguage?: (lang: string) => void;
+            setLang?: (lang: string) => void;
+            initOptions?: I18nInitOptions;
+        };
+    }
+    interface TInternalRuntimeContext {
+        i18nInstance?: I18nInstance;
+        changeLanguage?: (lang: string) => Promise<void>;
+    }
+}

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

@@ -0,0 +1,28 @@
+import { type TInternalRuntimeContext } from '@modern-js/runtime/context';
+import type { LocalisedUrlsMap } from '../shared/localisedUrls';
+export declare const getPathname: (context: TInternalRuntimeContext) => string;
+export declare const getEntryPath: () => string;
+/**
+ * Helper function to get language from current pathname
+ * @param pathname - The current pathname
+ * @param languages - Array of supported languages
+ * @param fallbackLanguage - Fallback language when no language is detected
+ * @returns The detected language or fallback language
+ */
+export declare const getLanguageFromPath: (pathname: string, languages: string[], fallbackLanguage: string) => string;
+/**
+ * Helper function to build localized URL
+ * @param pathname - The current pathname
+ * @param language - The target language
+ * @param languages - Array of supported languages
+ * @returns The localized URL path
+ */
+export declare const buildLocalizedUrl: (pathname: string, language: string, languages: string[], localisedUrls?: boolean | LocalisedUrlsMap) => string;
+export declare const detectLanguageFromPath: (pathname: string, languages: string[], localePathRedirect: boolean) => {
+    detected: boolean;
+    language?: string;
+};
+/**
+ * Check if the given pathname should ignore automatic locale redirect
+ */
+export declare const shouldIgnoreRedirect: (pathname: string, languages: string[], ignoreRedirectRoutes?: string[] | ((pathname: string) => boolean)) => boolean;

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

@@ -0,0 +1,14 @@
+import type { ServerPlugin } from '@modern-js/server-runtime';
+import type { LocaleDetectionOptions } from '../shared/type';
+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/shared/deepMerge.d.ts

@@ -0,0 +1 @@
+export declare function deepMerge<T extends Record<string, any>>(defaultOptions: T, userOptions?: Partial<T>): T;

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

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

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

@@ -0,0 +1,13 @@
+import type { NestedRouteForCli, PageRoute } from '@modern-js/types';
+export type LocalisedUrlPathMap = Record<string, string>;
+export type LocalisedUrlsMap = Record<string, LocalisedUrlPathMap>;
+export type LocalisedUrlsOption = boolean | LocalisedUrlsMap;
+export interface ResolvedLocalisedUrlsConfig {
+    enabled: boolean;
+    map: LocalisedUrlsMap;
+}
+export declare const normalisePathPattern: (path: string) => string;
+export declare const resolveLocalisedUrlsConfig: (option: LocalisedUrlsOption | undefined) => ResolvedLocalisedUrlsConfig;
+export declare const validateLocalisedUrls: (routes: (NestedRouteForCli | PageRoute)[], languages: string[], localisedUrls: LocalisedUrlsMap) => void;
+export declare const applyLocalisedUrlsToRoutes: (routes: (NestedRouteForCli | PageRoute)[], languages: string[], localisedUrls: LocalisedUrlsMap) => (NestedRouteForCli | PageRoute)[];
+export declare const resolveLocalisedPath: (pathname: string, targetLanguage: string, languages: string[], localisedUrls: LocalisedUrlsMap) => string;