@bleedingdev/modern-js-plugin-i18n 3.2.0-ultramodern.11 → 3.2.0-ultramodern.111

package/dist/cjs/shared/localisedUrls.js

@@ -0,0 +1,241 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+const LOCALE_PARAM_NAMES = new Set([
+    'lang',
+    'locale',
+    'language'
+]);
+const normalisePathPattern = (path)=>{
+    const withoutDuplicateSlashes = path.replace(/\/+/g, '/');
+    const withLeadingSlash = withoutDuplicateSlashes.startsWith('/') ? withoutDuplicateSlashes : `/${withoutDuplicateSlashes}`;
+    const withoutTrailingSlash = withLeadingSlash.length > 1 ? withLeadingSlash.replace(/\/+$/, '') : withLeadingSlash;
+    return withoutTrailingSlash.replace(/\[(.+?)\]/g, ':$1');
+};
+const normaliseRoutePath = (path)=>{
+    const normalized = normalisePathPattern(path);
+    return '/' === normalized ? '' : normalized.slice(1);
+};
+const getLocaleParamSegment = (segment)=>{
+    if (!segment.startsWith(':')) return null;
+    const paramName = segment.slice(1).replace(/\?$/, '');
+    return LOCALE_PARAM_NAMES.has(paramName) ? segment : null;
+};
+const splitPathSegments = (path)=>{
+    if (!path) return [];
+    return normalisePathPattern(path).split('/').filter(Boolean);
+};
+const stripLeadingLocaleParam = (path)=>{
+    const segments = splitPathSegments(path);
+    const leadingLocaleParam = getLocaleParamSegment(segments[0] || '');
+    if (!leadingLocaleParam) return path;
+    const remainingPath = segments.slice(1).join('/');
+    return remainingPath ? `/${remainingPath}` : void 0;
+};
+const getLeadingLocaleParam = (path)=>{
+    const segments = splitPathSegments(path);
+    return getLocaleParamSegment(segments[0] || '');
+};
+const resolveLocalisedUrlsConfig = (option)=>{
+    if (false === option) return {
+        enabled: false,
+        map: {}
+    };
+    if (option && 'object' == typeof option) return {
+        enabled: true,
+        map: option
+    };
+    return {
+        enabled: true,
+        map: {}
+    };
+};
+const isLocalisableRoutePath = (path)=>{
+    const pathWithoutLocale = stripLeadingLocaleParam(path);
+    if (!pathWithoutLocale || '/' === pathWithoutLocale || '*' === pathWithoutLocale) return false;
+    return true;
+};
+const joinPath = (parentPath, routePath)=>{
+    if (!isLocalisableRoutePath(routePath)) return parentPath;
+    const segment = normaliseRoutePath(stripLeadingLocaleParam(routePath) || '');
+    return normalisePathPattern(`${parentPath}/${segment}`);
+};
+const ensureLocalisedUrlsForPath = (canonicalPath, languages, localisedUrls)=>{
+    const entry = localisedUrls[canonicalPath];
+    if (!entry) throw new Error(`localisedUrls is enabled, but route "${canonicalPath}" does not define localised URLs for languages: ${languages.join(', ')}. Add localisedUrls["${canonicalPath}"] or set localeDetection.localisedUrls to false.`);
+    const missingLanguages = languages.filter((language)=>!entry[language]);
+    if (missingLanguages.length > 0) throw new Error(`localisedUrls["${canonicalPath}"] is missing languages: ${missingLanguages.join(', ')}. Every configured language must have a localised URL.`);
+    return entry;
+};
+const validateLocalisedUrls = (routes, languages, localisedUrls)=>{
+    const visit = (route, parentPath)=>{
+        const canonicalPath = joinPath(parentPath, route.path);
+        if (isLocalisableRoutePath(route.path)) ensureLocalisedUrlsForPath(canonicalPath, languages, localisedUrls);
+        if ('children' in route && route.children) route.children.forEach((child)=>visit(child, canonicalPath));
+    };
+    routes.forEach((route)=>visit(route, ''));
+};
+const getLocalisedRoutePaths = (canonicalPath, parentLocalisedPaths, languages, entry)=>{
+    const paths = languages.map((language)=>{
+        const fullPath = normalisePathPattern(entry[language]);
+        const parentPath = normalisePathPattern(parentLocalisedPaths[language] || '/');
+        if ('/' === parentPath) return normaliseRoutePath(fullPath) || void 0;
+        const parentPrefix = `${parentPath}/`;
+        if (!fullPath.startsWith(parentPrefix)) throw new Error(`localisedUrls["${canonicalPath}"].${language} must be nested under "${parentPath}" because its parent route is localised there.`);
+        return normaliseRoutePath(fullPath.slice(parentPath.length));
+    });
+    return Array.from(new Set(paths.filter(Boolean)));
+};
+const transformLocalisedRoute = (route, parentCanonicalPath, parentLocalisedPaths, languages, localisedUrls)=>{
+    const canonicalPath = joinPath(parentCanonicalPath, route.path);
+    const localisedUrlEntry = isLocalisableRoutePath(route.path) ? ensureLocalisedUrlsForPath(canonicalPath, languages, localisedUrls) : void 0;
+    const routeLocalisedPaths = localisedUrlEntry ? languages.reduce((acc, language)=>{
+        acc[language] = normalisePathPattern(localisedUrlEntry[language]);
+        return acc;
+    }, {}) : parentLocalisedPaths;
+    const children = 'children' in route && route.children ? route.children.flatMap((child)=>transformLocalisedRoute(child, canonicalPath, routeLocalisedPaths, languages, localisedUrls)) : void 0;
+    const baseRoute = {
+        ...route,
+        ...children ? {
+            children
+        } : {}
+    };
+    if (!localisedUrlEntry) return [
+        baseRoute
+    ];
+    return getLocalisedRoutePaths(canonicalPath, parentLocalisedPaths, languages, localisedUrlEntry).map((localisedPath, index)=>cloneRouteWithLocalisedPath(baseRoute, localisedPath, index));
+};
+const legalRouteIdPart = (value)=>value.replace(/[^a-zA-Z0-9_$-]+/g, '_').replace(/^_+|_+$/g, '') || 'index';
+const suffixRouteIds = (route, suffix)=>{
+    const children = 'children' in route && route.children ? route.children.map((child)=>suffixRouteIds(child, suffix)) : void 0;
+    return {
+        ...route,
+        ...route.id ? {
+            id: `${route.id}__localised_${suffix}`
+        } : {},
+        ...children ? {
+            children
+        } : {}
+    };
+};
+const cloneRouteWithLocalisedPath = (route, path, index)=>{
+    const leadingLocaleParam = getLeadingLocaleParam(route.path);
+    const localisedPath = leadingLocaleParam ? normaliseRoutePath(`${leadingLocaleParam}/${path}`) : path;
+    const routeWithPath = {
+        ...route,
+        path: localisedPath
+    };
+    return 0 === index ? routeWithPath : suffixRouteIds(routeWithPath, legalRouteIdPart(localisedPath));
+};
+const applyLocalisedUrlsToRoutes = (routes, languages, localisedUrls)=>{
+    const rootLocalisedPaths = languages.reduce((acc, language)=>{
+        acc[language] = '/';
+        return acc;
+    }, {});
+    validateLocalisedUrls(routes, languages, localisedUrls);
+    return routes.flatMap((route)=>transformLocalisedRoute(route, '', rootLocalisedPaths, languages, localisedUrls));
+};
+const escapeRegExp = (value)=>value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+const getParamName = (segment)=>segment.slice(1).replace(/\?$/, '');
+const compilePathPattern = (pattern)=>{
+    const names = [];
+    const segments = normalisePathPattern(pattern).split('/').filter(Boolean);
+    const source = segments.map((segment)=>{
+        if (segment.startsWith(':')) {
+            names.push(getParamName(segment));
+            const paramPattern = '([^/]+)';
+            return segment.endsWith('?') ? `(?:/${paramPattern})?` : `/${paramPattern}`;
+        }
+        if ('*' === segment) {
+            names.push('*');
+            return '/(.*)';
+        }
+        return `/${escapeRegExp(segment)}`;
+    }).join('');
+    return {
+        names,
+        regexp: new RegExp(`^${source || '/'}$`)
+    };
+};
+const matchPathPattern = (pathname, pattern)=>{
+    const { names, regexp } = compilePathPattern(pattern);
+    const match = regexp.exec(normalisePathPattern(pathname));
+    if (!match) return null;
+    return names.reduce((params, name, index)=>{
+        params[name] = decodeURIComponent(match[index + 1] || '');
+        return params;
+    }, {});
+};
+const buildPathFromPattern = (pattern, params)=>{
+    const segments = normalisePathPattern(pattern).split('/').filter(Boolean);
+    const path = segments.map((segment)=>{
+        if (segment.startsWith(':')) {
+            const param = params[getParamName(segment)];
+            return param ? encodeURIComponent(param) : '';
+        }
+        if ('*' === segment) return params['*'] || '';
+        return segment;
+    }).filter(Boolean).join('/');
+    return `/${path}`;
+};
+const resolveLocalisedPath = (pathname, targetLanguage, languages, localisedUrls)=>{
+    const normalizedPathname = normalisePathPattern(pathname);
+    for (const localisedUrlEntry of Object.values(localisedUrls)){
+        const targetPattern = localisedUrlEntry[targetLanguage];
+        if (targetPattern) for (const language of languages){
+            const sourcePattern = localisedUrlEntry[language];
+            if (!sourcePattern) continue;
+            const params = matchPathPattern(normalizedPathname, sourcePattern);
+            if (params) return buildPathFromPattern(targetPattern, params);
+        }
+    }
+    return normalizedPathname;
+};
+__webpack_require__.d(__webpack_exports__, {}, {
+    applyLocalisedUrlsToRoutes: applyLocalisedUrlsToRoutes,
+    normalisePathPattern: normalisePathPattern,
+    resolveLocalisedPath: resolveLocalisedPath,
+    resolveLocalisedUrlsConfig: resolveLocalisedUrlsConfig,
+    validateLocalisedUrls: validateLocalisedUrls
+});
+exports.applyLocalisedUrlsToRoutes = __webpack_exports__.applyLocalisedUrlsToRoutes;
+exports.normalisePathPattern = __webpack_exports__.normalisePathPattern;
+exports.resolveLocalisedPath = __webpack_exports__.resolveLocalisedPath;
+exports.resolveLocalisedUrlsConfig = __webpack_exports__.resolveLocalisedUrlsConfig;
+exports.validateLocalisedUrls = __webpack_exports__.validateLocalisedUrls;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "applyLocalisedUrlsToRoutes",
+    "normalisePathPattern",
+    "resolveLocalisedPath",
+    "resolveLocalisedUrlsConfig",
+    "validateLocalisedUrls"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/shared/utils.js

@@ -1,11 +1,15 @@
 "use strict";
 var __webpack_require__ = {};
 (()=>{
-    __webpack_require__.d = (exports1, definition)=>{
-        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
-            enumerable: true,
-            get: definition[key]
-        });
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
     };
 })();
 (()=>{
@@ -23,12 +27,6 @@ var __webpack_require__ = {};
 })();
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
-__webpack_require__.d(__webpack_exports__, {
-    getBackendOptions: ()=>getBackendOptions,
-    getEntryConfig: ()=>getEntryConfig,
-    getLocaleDetectionOptions: ()=>getLocaleDetectionOptions,
-    removeEntryConfigKey: ()=>removeEntryConfigKey
-});
 function getEntryConfig(entryName, config, entryKey) {
     const entryConfigMap = config[entryKey];
     return entryConfigMap?.[entryName];
@@ -63,6 +61,12 @@ function getBackendOptions(entryName, backend) {
     if ('backendOptionsByEntry' in fullConfig) return removeEntryConfigKey(fullConfig, 'backendOptionsByEntry');
     return backend;
 }
+__webpack_require__.d(__webpack_exports__, {
+    getBackendOptions: ()=>getBackendOptions,
+    getEntryConfig: ()=>getEntryConfig,
+    getLocaleDetectionOptions: ()=>getLocaleDetectionOptions,
+    removeEntryConfigKey: ()=>removeEntryConfigKey
+});
 exports.getBackendOptions = __webpack_exports__.getBackendOptions;
 exports.getEntryConfig = __webpack_exports__.getEntryConfig;
 exports.getLocaleDetectionOptions = __webpack_exports__.getLocaleDetectionOptions;

package/dist/esm/cli/index.mjs

@@ -1,7 +1,9 @@
 import { getPublicDirRoutePrefixes } from "@modern-js/server-core";
 import fs from "fs";
 import path from "path";
+import { applyLocalisedUrlsToRoutes, resolveLocalisedUrlsConfig } from "../shared/localisedUrls.mjs";
 import { getBackendOptions, getLocaleDetectionOptions } from "../shared/utils.mjs";
+import "../runtime/types.mjs";
 function hasJsonFiles(dirPath) {
     try {
         if (!fs.existsSync(dirPath) || !fs.statSync(dirPath).isDirectory()) return false;
@@ -80,6 +82,27 @@ const i18nPlugin = (options = {})=>({
                     plugins
                 };
             });
+            api.modifyFileSystemRoutes(({ entrypoint, routes })=>{
+                if (!localeDetection) return {
+                    entrypoint,
+                    routes
+                };
+                const localeDetectionOptions = getLocaleDetectionOptions(entrypoint.entryName, localeDetection);
+                const { localePathRedirect, languages = [], localisedUrls } = localeDetectionOptions;
+                if (!localePathRedirect || 0 === languages.length) return {
+                    entrypoint,
+                    routes
+                };
+                const localisedUrlsConfig = resolveLocalisedUrlsConfig(localisedUrls);
+                if (!localisedUrlsConfig.enabled) return {
+                    entrypoint,
+                    routes
+                };
+                return {
+                    entrypoint,
+                    routes: applyLocalisedUrlsToRoutes(routes, languages, localisedUrlsConfig.map)
+                };
+            });
             api._internalServerPlugins(({ plugins })=>{
                 const { serverRoutes, metaName } = api.getAppContext();
                 const normalizedConfig = api.getNormalizedConfig();

package/dist/esm/runtime/I18nLink.mjs

@@ -1,26 +1,21 @@
 import { jsx } from "react/jsx-runtime";
-import { Link as router_Link, useInRouterContext, useParams } from "@modern-js/runtime/router";
 import { useModernI18n } from "./context.mjs";
+import { useI18nRouterAdapter } from "./routerAdapter.mjs";
 import { buildLocalizedUrl } from "./utils.mjs";
-const useRouterHooks = ()=>{
-    const inRouter = useInRouterContext();
-    return {
-        Link: inRouter ? router_Link : null,
-        params: inRouter ? useParams() : {},
-        hasRouter: inRouter
-    };
-};
 const I18nLink = ({ to, children, ...props })=>{
-    const { Link, params, hasRouter } = useRouterHooks();
-    const { language, supportedLanguages } = useModernI18n();
+    const { Link, params, hasRouter } = useI18nRouterAdapter();
+    const { language, supportedLanguages, localisedUrls } = useModernI18n();
     const currentLang = language;
-    const localizedTo = buildLocalizedUrl(to, currentLang, supportedLanguages);
+    const localizedTo = buildLocalizedUrl(to, currentLang, supportedLanguages, localisedUrls);
     if ('development' === process.env.NODE_ENV && hasRouter && !params.lang) console.warn("I18nLink is being used outside of a :lang dynamic route context. This may cause unexpected behavior. Please ensure I18nLink is used within a route that has a :lang parameter.");
-    if (!hasRouter || !Link) return /*#__PURE__*/ jsx("a", {
-        href: localizedTo,
-        ...props,
-        children: children
-    });
+    if (!hasRouter || !Link) {
+        const { prefetch: _prefetch, preload: _preload, ...anchorProps } = props;
+        return /*#__PURE__*/ jsx("a", {
+            href: localizedTo,
+            ...anchorProps,
+            children: children
+        });
+    }
     return /*#__PURE__*/ jsx(Link, {
         to: localizedTo,
         ...props,

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) {