@bleedingdev/modern-js-plugin-i18n 3.2.0-ultramodern.9 → 3.2.0-ultramodern.91

package/dist/esm/runtime/context.mjs

@@ -1,8 +1,9 @@
 import { jsx } from "react/jsx-runtime";
 import { isBrowser } from "@modern-js/runtime";
-import { createContext, useCallback, useContext, useMemo } from "react";
+import { createContext, useCallback, useContext, useEffect, useMemo } from "react";
 import { cacheUserLanguage } from "./i18n/detection/index.mjs";
-import { buildLocalizedUrl, detectLanguageFromPath, getEntryPath, shouldIgnoreRedirect, useRouterHooks } from "./utils.mjs";
+import { useI18nRouterAdapter } from "./routerAdapter.mjs";
+import { buildLocalizedUrl, detectLanguageFromPath, getEntryPath, shouldIgnoreRedirect } from "./utils.mjs";
 const ModernI18nContext = /*#__PURE__*/ createContext(null);
 const ModernI18nProvider = ({ children, value })=>/*#__PURE__*/ jsx(ModernI18nContext.Provider, {
         value: value,
@@ -11,9 +12,33 @@ const ModernI18nProvider = ({ children, value })=>/*#__PURE__*/ jsx(ModernI18nCo
 const useModernI18n = ()=>{
     const context = useContext(ModernI18nContext);
     if (!context) throw new Error('useModernI18n must be used within a ModernI18nProvider');
-    const { language: contextLanguage, i18nInstance, languages, localePathRedirect, ignoreRedirectRoutes, updateLanguage } = context;
-    const { navigate, location, hasRouter } = useRouterHooks();
-    const currentLanguage = contextLanguage;
+    const { language: contextLanguage, i18nInstance, languages, localePathRedirect, ignoreRedirectRoutes, localisedUrls, updateLanguage } = context;
+    const { navigate, location, hasRouter } = useI18nRouterAdapter();
+    const pathLanguage = useMemo(()=>{
+        if (!localePathRedirect || !location?.pathname) return;
+        const detected = detectLanguageFromPath(location.pathname, languages || [], localePathRedirect);
+        return detected.detected ? detected.language : void 0;
+    }, [
+        languages,
+        localePathRedirect,
+        location?.pathname
+    ]);
+    const currentLanguage = pathLanguage || contextLanguage;
+    useEffect(()=>{
+        if (!pathLanguage || pathLanguage === contextLanguage) return;
+        updateLanguage?.(pathLanguage);
+        i18nInstance?.setLang?.(pathLanguage);
+        i18nInstance?.changeLanguage?.(pathLanguage);
+        if (isBrowser()) {
+            const detectionOptions = i18nInstance.options?.detection;
+            cacheUserLanguage(i18nInstance, pathLanguage, detectionOptions);
+        }
+    }, [
+        contextLanguage,
+        i18nInstance,
+        pathLanguage,
+        updateLanguage
+    ]);
     const changeLanguage = useCallback(async (newLang)=>{
         try {
             if (!newLang || 'string' != typeof newLang) throw new Error('Language must be a non-empty string');
@@ -30,7 +55,7 @@ const useModernI18n = ()=>{
                 const pathLanguage = detectLanguageFromPath(currentPath, languages || [], localePathRedirect);
                 if (pathLanguage.detected && pathLanguage.language === newLang) return;
                 if (!shouldIgnoreRedirect(relativePath, languages || [], ignoreRedirectRoutes)) {
-                    const newPath = buildLocalizedUrl(relativePath, newLang, languages || []);
+                    const newPath = buildLocalizedUrl(relativePath, newLang, languages || [], localisedUrls);
                     const newUrl = entryPath + newPath + location.search + location.hash;
                     await navigate(newUrl, {
                         replace: true
@@ -43,7 +68,7 @@ const useModernI18n = ()=>{
                 const pathLanguage = detectLanguageFromPath(currentPath, languages || [], localePathRedirect);
                 if (pathLanguage.detected && pathLanguage.language === newLang) return;
                 if (!shouldIgnoreRedirect(relativePath, languages || [], ignoreRedirectRoutes)) {
-                    const newPath = buildLocalizedUrl(relativePath, newLang, languages || []);
+                    const newPath = buildLocalizedUrl(relativePath, newLang, languages || [], localisedUrls);
                     const newUrl = entryPath + newPath + window.location.search + window.location.hash;
                     window.history.pushState(null, '', newUrl);
                 }
@@ -58,6 +83,7 @@ const useModernI18n = ()=>{
         updateLanguage,
         localePathRedirect,
         ignoreRedirectRoutes,
+        localisedUrls,
         languages,
         hasRouter,
         navigate,
@@ -98,6 +124,7 @@ const useModernI18n = ()=>{
         changeLanguage,
         i18nInstance,
         supportedLanguages: languages || [],
+        localisedUrls,
         isLanguageSupported,
         isResourcesReady
     };

package/dist/esm/runtime/hooks.mjs

@@ -2,7 +2,8 @@ import { isBrowser } from "@modern-js/runtime";
 import { useEffect, useRef } from "react";
 import { I18N_SDK_RESOURCES_LOADED_EVENT, getI18nSdkBackendId } from "./i18n/backend/sdk-event.mjs";
 import { cacheUserLanguage } from "./i18n/detection/index.mjs";
-import { buildLocalizedUrl, detectLanguageFromPath, getEntryPath, getPathname, shouldIgnoreRedirect, useRouterHooks } from "./utils.mjs";
+import { useI18nRouterAdapter } from "./routerAdapter.mjs";
+import { buildLocalizedUrl, detectLanguageFromPath, getEntryPath, getPathname, shouldIgnoreRedirect } from "./utils.mjs";
 function createMinimalI18nInstance(language) {
     const minimalInstance = {
         language,
@@ -14,7 +15,7 @@ function createMinimalI18nInstance(language) {
     };
     return minimalInstance;
 }
-function createContextValue(lang, i18nInstance, entryName, languages, localePathRedirect, ignoreRedirectRoutes, setLang) {
+function createContextValue(lang, i18nInstance, entryName, languages, localePathRedirect, ignoreRedirectRoutes, localisedUrls, setLang) {
     const instance = i18nInstance || createMinimalI18nInstance(lang);
     return {
         language: lang,
@@ -23,6 +24,7 @@ function createContextValue(lang, i18nInstance, entryName, languages, localePath
         languages,
         localePathRedirect,
         ignoreRedirectRoutes,
+        localisedUrls,
         updateLanguage: setLang
     };
 }
@@ -72,9 +74,9 @@ function useSdkResourcesLoader(i18nInstance, setForceUpdate) {
         setForceUpdate
     ]);
 }
-function useClientSideRedirect(i18nInstance, localePathRedirect, languages, fallbackLanguage, ignoreRedirectRoutes) {
+function useClientSideRedirect(i18nInstance, localePathRedirect, languages, fallbackLanguage, ignoreRedirectRoutes, localisedUrls) {
     const hasRedirectedRef = useRef(false);
-    const { navigate, location, hasRouter } = useRouterHooks();
+    const { navigate, location, hasRouter } = useI18nRouterAdapter();
     useEffect(()=>{
         if ('browser' !== process.env.MODERN_TARGET) return;
         if (!localePathRedirect || !i18nInstance) return;
@@ -93,7 +95,7 @@ function useClientSideRedirect(i18nInstance, localePathRedirect, languages, fall
         const pathDetection = detectLanguageFromPath(currentPathname, languages, localePathRedirect);
         if (pathDetection.detected) return;
         const targetLanguage = i18nInstance.language || fallbackLanguage || languages[0] || 'en';
-        const newPath = buildLocalizedUrl(relativePath, targetLanguage, languages);
+        const newPath = buildLocalizedUrl(relativePath, targetLanguage, languages, localisedUrls);
         const newUrl = entryPath + newPath + currentSearch + currentHash;
         if (newUrl !== currentPathname + currentSearch + currentHash) {
             hasRedirectedRef.current = true;
@@ -110,7 +112,8 @@ function useClientSideRedirect(i18nInstance, localePathRedirect, languages, fall
         i18nInstance,
         languages,
         fallbackLanguage,
-        ignoreRedirectRoutes
+        ignoreRedirectRoutes,
+        localisedUrls
     ]);
 }
 function useLanguageSync(i18nInstance, localePathRedirect, languages, runtimeContextRef, prevLangRef, setLang) {

package/dist/esm/runtime/i18n/backend/defaults.mjs

@@ -4,7 +4,7 @@ const DEFAULT_I18NEXT_BACKEND_OPTIONS = {
 };
 function convertPath(path) {
     if (!path) return path;
-    if (path.startsWith('/')) return `${window.__assetPrefix__ || ''}${path}`;
+    if (path.startsWith('/')) return "u" < typeof window ? path : `${window.__assetPrefix__ || ''}${path}`;
     return path;
 }
 function convertBackendOptions(options) {

package/dist/esm/runtime/i18n/backend/defaults.node.mjs

@@ -1,6 +1,6 @@
 const DEFAULT_I18NEXT_BACKEND_OPTIONS = {
-    loadPath: './locales/{{lng}}/{{ns}}.json',
-    addPath: './locales/{{lng}}/{{ns}}.json'
+    loadPath: './config/public/locales/{{lng}}/{{ns}}.json',
+    addPath: './config/public/locales/{{lng}}/{{ns}}.json'
 };
 function convertPath(path) {
     if (!path) return path;

package/dist/esm/runtime/i18n/backend/middleware.node.mjs

@@ -1,8 +1,8 @@
-import i18next_fs_backend from "i18next-fs-backend";
+import cjs from "i18next-fs-backend/cjs";
 import { useI18nextBackendCommon } from "./middleware.common.mjs";
-class FsBackendWithSave extends i18next_fs_backend {
+class FsBackendWithSave extends cjs {
     save(_language, _namespace, _data) {}
 }
 const HttpBackendWithSave = FsBackendWithSave;
-const useI18nextBackend = (i18nInstance, backend)=>useI18nextBackendCommon(i18nInstance, FsBackendWithSave, i18next_fs_backend, backend);
+const useI18nextBackend = (i18nInstance, backend)=>useI18nextBackendCommon(i18nInstance, FsBackendWithSave, cjs, backend);
 export { FsBackendWithSave, HttpBackendWithSave, useI18nextBackend };

package/dist/esm/runtime/i18n/instance.mjs

@@ -40,14 +40,6 @@ async function createI18nextInstance() {
         return null;
     }
 }
-async function tryImportReactI18next() {
-    try {
-        const reactI18next = await import("react-i18next");
-        return reactI18next;
-    } catch (error) {
-        return null;
-    }
-}
 function getI18nextInstanceForProvider(instance) {
     if (isI18nWrapperInstance(instance)) {
         const i18nextInstance = getI18nWrapperI18nextInstance(instance);
@@ -64,14 +56,4 @@ async function getI18nInstance(userInstance) {
     if (i18nextInstance) return i18nextInstance;
     throw new Error('No i18n instance found');
 }
-async function getInitReactI18next() {
-    const reactI18nextModule = await tryImportReactI18next();
-    if (reactI18nextModule) return reactI18nextModule.initReactI18next;
-    return null;
-}
-async function getI18nextProvider() {
-    const reactI18nextModule = await tryImportReactI18next();
-    if (reactI18nextModule) return reactI18nextModule.I18nextProvider;
-    return null;
-}
-export { getActualI18nextInstance, getI18nInstance, getI18nWrapperI18nextInstance, getI18nextInstanceForProvider, getI18nextProvider, getInitReactI18next, isI18nInstance, isI18nWrapperInstance };
+export { getActualI18nextInstance, getI18nInstance, getI18nWrapperI18nextInstance, getI18nextInstanceForProvider, isI18nInstance, isI18nWrapperInstance };

package/dist/esm/runtime/i18n/react-i18next.mjs

@@ -0,0 +1,15 @@
+async function tryImportReactI18next() {
+    try {
+        return await import("react-i18next");
+    } catch (error) {
+        return null;
+    }
+}
+async function getReactI18nextIntegration() {
+    const reactI18nextModule = await tryImportReactI18next();
+    return {
+        I18nextProvider: reactI18nextModule?.I18nextProvider ?? null,
+        initReactI18next: reactI18nextModule?.initReactI18next ?? null
+    };
+}
+export { getReactI18nextIntegration };

package/dist/esm/runtime/i18n/utils.mjs

@@ -100,18 +100,6 @@ const initializeI18nInstance = async (i18nInstance, finalLanguage, fallbackLangu
                 };
             }
         }
-        if (mergedBackend && hasOptions(i18nInstance)) {
-            const defaultNS = initOptions.defaultNS || initOptions.ns || 'translation';
-            const ns = Array.isArray(defaultNS) ? defaultNS[0] : defaultNS;
-            let retries = 20;
-            while(retries > 0){
-                const actualInstance = getActualI18nextInstance(i18nInstance);
-                const store = actualInstance.store;
-                if (store?.data?.[finalLanguage]?.[ns]) break;
-                await new Promise((resolve)=>setTimeout(resolve, 100));
-                retries--;
-            }
-        }
     }
 };
 function hasOptions(instance) {

package/dist/esm/runtime/index.mjs

@@ -10,26 +10,31 @@ import { mergeBackendOptions } from "./i18n/backend/index.mjs";
 import { useI18nextBackend } from "./i18n/backend/middleware.mjs";
 import { detectLanguageWithPriority, exportServerLngToWindow, mergeDetectionOptions } from "./i18n/detection/index.mjs";
 import { useI18nextLanguageDetector } from "./i18n/detection/middleware.mjs";
-import { getI18nextInstanceForProvider, getI18nextProvider, getInitReactI18next } from "./i18n/instance.mjs";
+import { getI18nextInstanceForProvider } from "./i18n/instance.mjs";
 import { changeI18nLanguage, ensureLanguageMatch, initializeI18nInstance, setupClonedInstance } from "./i18n/utils.mjs";
 import { getPathname } from "./utils.mjs";
 import "./types.mjs";
 const i18nPlugin = (options)=>({
         name: '@modern-js/plugin-i18n',
         setup: (api)=>{
-            const { entryName, i18nInstance: userI18nInstance, initOptions, localeDetection, backend, htmlLangAttr = false } = options;
-            const { localePathRedirect = false, i18nextDetector = true, languages = [], fallbackLanguage = 'en', detection, ignoreRedirectRoutes } = localeDetection || {};
+            const { entryName, i18nInstance: userI18nInstance, initOptions, localeDetection, backend, htmlLangAttr = false, reactI18next = true } = options;
+            const { localePathRedirect = false, i18nextDetector = true, languages = [], fallbackLanguage = 'en', detection, ignoreRedirectRoutes, localisedUrls } = localeDetection || {};
             const { enabled: backendEnabled = false } = backend || {};
             let latestI18nInstance;
             let I18nextProvider;
+            const loadReactI18nextIntegration = async ()=>{
+                if (!reactI18next) return null;
+                const { getReactI18nextIntegration } = await import("./i18n/react-i18next.mjs");
+                return getReactI18nextIntegration();
+            };
             api.onBeforeRender(async (context)=>{
                 let i18nInstance = await getI18nInstance(userI18nInstance);
                 const { i18n: otherConfig } = api.getRuntimeConfig();
                 const { initOptions: otherInitOptions } = otherConfig || {};
                 const userInitOptions = merge(otherInitOptions || {}, initOptions || {});
-                const initReactI18next = await getInitReactI18next();
-                I18nextProvider = await getI18nextProvider();
-                if (initReactI18next) i18nInstance.use(initReactI18next);
+                const reactI18nextIntegration = await loadReactI18nextIntegration();
+                I18nextProvider = reactI18nextIntegration?.I18nextProvider ?? null;
+                if (reactI18nextIntegration?.initReactI18next) i18nInstance.use(reactI18nextIntegration.initReactI18next);
                 const pathname = getPathname(context);
                 if (i18nextDetector) useI18nextLanguageDetector(i18nInstance);
                 const mergedDetection = mergeDetectionOptions(i18nextDetector, detection, localePathRedirect, userInitOptions);
@@ -89,16 +94,18 @@ const i18nPlugin = (options)=>({
                     ]);
                     useSdkResourcesLoader(i18nInstance, setForceUpdate);
                     useLanguageSync(i18nInstance, localePathRedirect, languages, runtimeContextRef, prevLangRef, setLang);
-                    useClientSideRedirect(i18nInstance, localePathRedirect, languages, fallbackLanguage, ignoreRedirectRoutes);
-                    const contextValue = useMemo(()=>createContextValue(lang, i18nInstance, entryName, languages, localePathRedirect, ignoreRedirectRoutes, setLang), [
+                    useClientSideRedirect(i18nInstance, localePathRedirect, languages, fallbackLanguage, ignoreRedirectRoutes, localisedUrls);
+                    const contextValue = useMemo(()=>createContextValue(lang, i18nInstance, entryName, languages, localePathRedirect, ignoreRedirectRoutes, localisedUrls, setLang), [
                         lang,
                         i18nInstance,
                         entryName,
                         languages,
                         localePathRedirect,
                         ignoreRedirectRoutes,
+                        localisedUrls,
                         forceUpdate
                     ]);
+                    const children = props.children;
                     const appContent = /*#__PURE__*/ jsxs(Fragment, {
                         children: [
                             Boolean(htmlLangAttr) && /*#__PURE__*/ jsx(Helmet, {
@@ -108,9 +115,10 @@ const i18nPlugin = (options)=>({
                             }),
                             /*#__PURE__*/ jsx(ModernI18nProvider, {
                                 value: contextValue,
-                                children: /*#__PURE__*/ jsx(App, {
-                                    ...props
-                                })
+                                children: App ? /*#__PURE__*/ jsx(App, {
+                                    ...props,
+                                    children: children
+                                }) : children
                             })
                         ]
                     });

package/dist/esm/runtime/routerAdapter.mjs

@@ -0,0 +1,129 @@
+import { RuntimeContext, isBrowser } from "@modern-js/runtime";
+import { InternalRuntimeContext } from "@modern-js/runtime/context";
+import { Link as router_Link, useInRouterContext, useLocation, useNavigate, useParams } from "@modern-js/runtime/router";
+import { useCallback, useContext, useEffect, useState } from "react";
+const normalizeUrlPart = (value, prefix)=>{
+    if ('string' != typeof value || !value) return '';
+    return value.startsWith(prefix) ? value : `${prefix}${value}`;
+};
+const normalizeLocation = (location)=>{
+    if (!location || 'object' != typeof location) return null;
+    const locationValue = location;
+    if ('string' != typeof locationValue.pathname) return null;
+    return {
+        pathname: locationValue.pathname,
+        search: normalizeUrlPart('string' == typeof locationValue.search ? locationValue.search : locationValue.searchStr, '?'),
+        hash: normalizeUrlPart(locationValue.hash, '#')
+    };
+};
+const getWindowLocation = ()=>{
+    if (!isBrowser()) return null;
+    return {
+        pathname: window.location.pathname,
+        search: window.location.search,
+        hash: window.location.hash
+    };
+};
+const getRouterFramework = (runtimeContext, internalContext, inReactRouter)=>{
+    const framework = internalContext.routerFramework || internalContext.routerRuntime?.framework || runtimeContext.routerFramework;
+    if (framework) return framework;
+    if (internalContext.router?.useRouter || runtimeContext.router?.useRouter) return 'tanstack';
+    if (internalContext.router?.useLocation || internalContext.router?.useHref || runtimeContext.router?.useLocation || runtimeContext.router?.useHref) return 'react-router';
+    if (inReactRouter) return 'react-router';
+};
+const getRouterInstance = (internalContext, contextRouter)=>{
+    if (contextRouter) return contextRouter;
+    const router = internalContext.routerInstance || internalContext.routerRuntime?.instance;
+    if (!router || 'object' != typeof router) return null;
+    return router;
+};
+const getRouterStateLocation = (internalContext, contextRouter)=>{
+    const router = getRouterInstance(internalContext, contextRouter);
+    return normalizeLocation(router?.stores?.location?.get?.()) || normalizeLocation(router?.state?.location);
+};
+const getRouterParams = (internalContext, contextRouter)=>{
+    const router = getRouterInstance(internalContext, contextRouter);
+    const matches = router?.stores?.matches?.get?.() || router?.state?.matches;
+    if (!Array.isArray(matches)) return {};
+    return matches.reduce((params, match)=>{
+        if (match?.params) Object.assign(params, match.params);
+        return params;
+    }, {});
+};
+const useI18nRouterAdapter = ()=>{
+    const runtimeContext = useContext(RuntimeContext);
+    const internalContext = useContext(InternalRuntimeContext);
+    const inReactRouter = useInRouterContext();
+    const reactRouterNavigate = inReactRouter ? useNavigate() : null;
+    const reactRouterLocation = inReactRouter ? useLocation() : null;
+    const reactRouterParams = inReactRouter ? useParams() : {};
+    const framework = getRouterFramework(runtimeContext, internalContext, inReactRouter);
+    const contextUseRouter = inReactRouter || 'tanstack' !== framework ? void 0 : internalContext.router?.useRouter || runtimeContext.router?.useRouter;
+    const contextRouter = contextUseRouter ? contextUseRouter({
+        warn: false
+    }) : null;
+    const [, setRouterVersion] = useState(0);
+    const hasRouter = 'tanstack' === framework || 'react-router' === framework || Boolean(reactRouterNavigate);
+    useEffect(()=>{
+        if ('tanstack' !== framework) return;
+        const router = getRouterInstance(internalContext, contextRouter);
+        if (!router) return;
+        const update = ()=>setRouterVersion((version)=>version + 1);
+        const unsubscribers = [];
+        if ('function' == typeof router.stores?.location?.subscribe) {
+            const unsubscribe = router.stores.location.subscribe(update);
+            if ('function' == typeof unsubscribe) unsubscribers.push(unsubscribe);
+        }
+        if ('function' == typeof router.subscribe) for (const eventType of [
+            'onBeforeNavigate',
+            'onBeforeLoad'
+        ]){
+            const unsubscribe = router.subscribe(eventType, update);
+            if ('function' == typeof unsubscribe) unsubscribers.push(unsubscribe);
+        }
+        return ()=>{
+            for (const unsubscribe of unsubscribers)unsubscribe();
+        };
+    }, [
+        contextRouter,
+        framework,
+        internalContext
+    ]);
+    const navigate = useCallback((href, options)=>{
+        const router = getRouterInstance(internalContext, contextRouter);
+        const activeFramework = getRouterFramework(runtimeContext, internalContext, inReactRouter);
+        if ('tanstack' === activeFramework) {
+            if ('function' == typeof router?.navigate) return router.navigate({
+                to: href,
+                replace: options?.replace,
+                ...options?.state === void 0 ? {} : {
+                    state: options.state
+                }
+            });
+            throw new Error('TanStack router instance is not available.');
+        }
+        if (reactRouterNavigate) return reactRouterNavigate(href, options);
+        if ('react-router' === activeFramework) {
+            if ('function' == typeof router?.navigate) return router.navigate(href, options);
+            throw new Error('React Router instance is not available.');
+        }
+    }, [
+        contextRouter,
+        internalContext,
+        inReactRouter,
+        reactRouterNavigate,
+        runtimeContext
+    ]);
+    const location = (reactRouterLocation ? normalizeLocation(reactRouterLocation) : getRouterStateLocation(internalContext, contextRouter)) || getWindowLocation();
+    const params = inReactRouter ? reactRouterParams : getRouterParams(internalContext, contextRouter);
+    const Link = 'tanstack' === framework ? internalContext.router?.Link || runtimeContext.router?.Link || null : 'react-router' === framework || inReactRouter ? router_Link : null;
+    return {
+        framework,
+        hasRouter,
+        location,
+        navigate: hasRouter ? navigate : null,
+        Link,
+        params
+    };
+};
+export { useI18nRouterAdapter };

package/dist/esm/runtime/utils.mjs

@@ -1,12 +1,6 @@
 import { isBrowser } from "@modern-js/runtime";
 import { getGlobalBasename } from "@modern-js/runtime/context";
-import { __webpack_require__ } from "../rslib-runtime.mjs";
-import * as __rspack_external__modern_js_runtime_router_2dfd0c78 from "@modern-js/runtime/router";
-__webpack_require__.add({
-    "@modern-js/runtime/router?f1fa" (module) {
-        module.exports = __rspack_external__modern_js_runtime_router_2dfd0c78;
-    }
-});
+import { resolveLocalisedPath, resolveLocalisedUrlsConfig } from "../shared/localisedUrls.mjs";
 const getPathname = (context)=>{
     if (isBrowser()) return window.location.pathname;
     return context.ssrContext?.request?.pathname || '/';
@@ -22,11 +16,16 @@ const getLanguageFromPath = (pathname, languages, fallbackLanguage)=>{
     if (languages.includes(firstSegment)) return firstSegment;
     return fallbackLanguage;
 };
-const buildLocalizedUrl = (pathname, language, languages)=>{
+const buildLocalizedUrl = (pathname, language, languages, localisedUrls)=>{
     const segments = pathname.split('/').filter(Boolean);
-    if (segments.length > 0 && languages.includes(segments[0])) segments[0] = language;
-    else segments.unshift(language);
-    return `/${segments.join('/')}`;
+    const localisedUrlsConfig = resolveLocalisedUrlsConfig(localisedUrls);
+    const pathWithoutLanguage = segments.length > 0 && languages.includes(segments[0]) ? `/${segments.slice(1).join('/')}` : pathname;
+    const resolvedPath = localisedUrlsConfig.enabled ? resolveLocalisedPath(pathWithoutLanguage, language, languages, localisedUrlsConfig.map) : pathWithoutLanguage;
+    const resolvedSegments = resolvedPath.split('/').filter(Boolean);
+    return `/${[
+        language,
+        ...resolvedSegments
+    ].join('/')}`;
 };
 const detectLanguageFromPath = (pathname, languages, localePathRedirect)=>{
     if (!localePathRedirect) return {
@@ -54,22 +53,4 @@ const shouldIgnoreRedirect = (pathname, languages, ignoreRedirectRoutes)=>{
     if ('function' == typeof ignoreRedirectRoutes) return ignoreRedirectRoutes(normalizedPath);
     return ignoreRedirectRoutes.some((pattern)=>normalizedPath === pattern || normalizedPath.startsWith(`${pattern}/`));
 };
-const useRouterHooks = ()=>{
-    try {
-        const { useLocation, useNavigate, useParams } = __webpack_require__("@modern-js/runtime/router?f1fa");
-        return {
-            navigate: useNavigate(),
-            location: useLocation(),
-            params: useParams(),
-            hasRouter: true
-        };
-    } catch (error) {
-        return {
-            navigate: null,
-            location: null,
-            params: {},
-            hasRouter: false
-        };
-    }
-};
-export { buildLocalizedUrl, detectLanguageFromPath, getEntryPath, getLanguageFromPath, getPathname, shouldIgnoreRedirect, useRouterHooks };
+export { buildLocalizedUrl, detectLanguageFromPath, getEntryPath, getLanguageFromPath, getPathname, shouldIgnoreRedirect };

package/dist/esm/server/index.mjs

@@ -1,7 +1,38 @@
 import { DEFAULT_I18NEXT_DETECTION_OPTIONS, mergeDetectionOptions } from "../runtime/i18n/detection/config.mjs";
+import { resolveLocalisedPath, resolveLocalisedUrlsConfig } from "../shared/localisedUrls.mjs";
 import { getLocaleDetectionOptions } from "../shared/utils.mjs";
 import * as __rspack_external__modern_js_server_core_hono_a76ca254 from "@modern-js/server-core/hono";
 const { languageDetector: languageDetector } = __rspack_external__modern_js_server_core_hono_a76ca254;
+const normalizeApiPrefix = (prefix)=>{
+    const trimmedPrefix = prefix.trim();
+    if (!trimmedPrefix) return null;
+    const prefixedPath = trimmedPrefix.startsWith('/') ? trimmedPrefix : `/${trimmedPrefix}`;
+    const withoutWildcard = prefixedPath.replace(/\/\*$/, '');
+    const normalizedPrefix = withoutWildcard.length > 1 ? withoutWildcard.replace(/\/+$/, '') : withoutWildcard;
+    return '/' === normalizedPrefix ? null : normalizedPrefix;
+};
+const collectApiPrefixes = (routes, bffPrefix)=>{
+    const prefixes = new Set();
+    for (const route of routes){
+        if (!route.isApi || !route.urlPath) continue;
+        const normalizedPrefix = normalizeApiPrefix(route.urlPath);
+        if (normalizedPrefix) prefixes.add(normalizedPrefix);
+    }
+    const bffPrefixes = Array.isArray(bffPrefix) ? bffPrefix : bffPrefix ? [
+        bffPrefix
+    ] : [];
+    for (const prefix of bffPrefixes){
+        const normalizedPrefix = normalizeApiPrefix(prefix);
+        if (normalizedPrefix) prefixes.add(normalizedPrefix);
+    }
+    return [
+        ...prefixes
+    ];
+};
+const matchesApiPrefix = (pathname, apiPrefixes)=>{
+    const normalizedPathname = pathname.startsWith('/') ? pathname : `/${pathname}`;
+    return apiPrefixes.some((prefix)=>normalizedPathname === prefix || normalizedPathname.startsWith(`${prefix}/`));
+};
 const convertToHonoLanguageDetectorOptions = (languages, fallbackLanguage, detectionOptions)=>{
     const mergedDetection = detectionOptions ? mergeDetectionOptions(detectionOptions) : DEFAULT_I18NEXT_DETECTION_OPTIONS;
     const order = (mergedDetection.order || []).filter((item)=>![
@@ -91,15 +122,20 @@ const getLanguageFromPath = (req, urlPath, languages)=>{
     if (languages.includes(firstSegment)) return firstSegment;
     return null;
 };
-const buildLocalizedUrl = (req, urlPath, language, languages)=>{
+const buildLocalizedUrl = (req, urlPath, language, languages, localisedUrls)=>{
     const url = new URL(req.url);
     const pathname = url.pathname;
     const basePath = urlPath.replace('/*', '');
     const remainingPath = pathname.startsWith(basePath) ? pathname.slice(basePath.length) : pathname;
     const segments = remainingPath.split('/').filter(Boolean);
-    if (segments.length > 0 && languages.includes(segments[0])) segments[0] = language;
-    else segments.unshift(language);
-    const newPathname = `/${segments.join('/')}`;
+    const localisedUrlsConfig = resolveLocalisedUrlsConfig(localisedUrls);
+    const pathWithoutLanguage = segments.length > 0 && languages.includes(segments[0]) ? `/${segments.slice(1).join('/')}` : remainingPath;
+    const resolvedPath = localisedUrlsConfig.enabled ? resolveLocalisedPath(pathWithoutLanguage, language, languages, localisedUrlsConfig.map) : pathWithoutLanguage;
+    const resolvedSegments = resolvedPath.split('/').filter(Boolean);
+    const newPathname = `/${[
+        language,
+        ...resolvedSegments
+    ].join('/')}`;
     const suffix = `${url.search}${url.hash}`;
     const localizedUrl = '/' === basePath ? newPathname + suffix : basePath + newPathname + suffix;
     return localizedUrl;
@@ -109,6 +145,9 @@ const i18nServerPlugin = (options)=>({
         setup: (api)=>{
             api.onPrepare(()=>{
                 const { middlewares, routes } = api.getServerContext();
+                const serverConfig = api.getServerConfig();
+                const bffPrefix = serverConfig?.bff ? serverConfig.bff.prefix ?? '/api' : void 0;
+                const apiPrefixes = collectApiPrefixes(routes, bffPrefix);
                 const entryPaths = new Set();
                 routes.forEach((route)=>{
                     if (route.entryName && route.urlPath && '/' !== route.urlPath) {
@@ -120,7 +159,7 @@ const i18nServerPlugin = (options)=>({
                     const { entryName } = route;
                     if (!entryName) return;
                     if (!options.localeDetection) return;
-                    const { localePathRedirect, i18nextDetector = true, languages = [], fallbackLanguage = 'en', detection, ignoreRedirectRoutes } = getLocaleDetectionOptions(entryName, options.localeDetection);
+                    const { localePathRedirect, i18nextDetector = true, languages = [], fallbackLanguage = 'en', detection, ignoreRedirectRoutes, localisedUrls } = getLocaleDetectionOptions(entryName, options.localeDetection);
                     const staticRoutePrefixes = options.staticRoutePrefixes;
                     const originUrlPath = route.urlPath;
                     const urlPath = originUrlPath.endsWith('/') ? `${originUrlPath}*` : `${originUrlPath}/*`;
@@ -134,6 +173,7 @@ const i18nServerPlugin = (options)=>({
                                 handler: async (c, next)=>{
                                     const url = new URL(c.req.url);
                                     const pathname = url.pathname;
+                                    if (matchesApiPrefix(pathname, apiPrefixes)) return await next();
                                     if (isStaticResourceRequest(pathname, staticRoutePrefixes, languages)) return await next();
                                     if ('/' === originUrlPath) {
                                         const pathSegments = pathname.split('/').filter(Boolean);
@@ -152,6 +192,7 @@ const i18nServerPlugin = (options)=>({
                             handler: async (c, next)=>{
                                 const url = new URL(c.req.url);
                                 const pathname = url.pathname;
+                                if (matchesApiPrefix(pathname, apiPrefixes)) return await next();
                                 if (isStaticResourceRequest(pathname, staticRoutePrefixes, languages)) return await next();
                                 if (shouldIgnoreRedirect(pathname, urlPath, ignoreRedirectRoutes)) return await next();
                                 if ('/' === originUrlPath) {
@@ -166,9 +207,14 @@ const i18nServerPlugin = (options)=>({
                                     let detectedLanguage = null;
                                     if (i18nextDetector) detectedLanguage = c.get('language') || null;
                                     const targetLanguage = detectedLanguage || fallbackLanguage;
-                                    const localizedUrl = buildLocalizedUrl(c.req, originUrlPath, targetLanguage, languages);
+                                    const localizedUrl = buildLocalizedUrl(c.req, originUrlPath, targetLanguage, languages, localisedUrls);
                                     return c.redirect(localizedUrl);
                                 }
+                                const localisedUrlsConfig = resolveLocalisedUrlsConfig(localisedUrls);
+                                if (localisedUrlsConfig.enabled) {
+                                    const expectedUrl = buildLocalizedUrl(c.req, originUrlPath, language, languages, localisedUrls);
+                                    if (expectedUrl !== `${pathname}${url.search}${url.hash}`) return c.redirect(expectedUrl);
+                                }
                                 await next();
                             }
                         });
@@ -179,4 +225,4 @@ const i18nServerPlugin = (options)=>({
     });
 const server = i18nServerPlugin;
 export default server;
-export { i18nServerPlugin };
+export { collectApiPrefixes, i18nServerPlugin, matchesApiPrefix };