@bleedingdev/modern-js-plugin-i18n 3.2.0-ultramodern.120 → 3.2.0-ultramodern.122

package/dist/cjs/runtime/Link.js

@@ -122,7 +122,7 @@ const mergeClassNames = (...values)=>{
     return classNames.length > 0 ? classNames.join(' ') : void 0;
 };
 const Link = (props)=>{
-    const { to, params, children, hash: hashProp, search: searchProp, hashScrollIntoView, activeOptions, activeProps, ...rest } = props;
+    const { to, params, children, hash: hashProp, search: searchProp, hashScrollIntoView, activeOptions, activeProps, prefetch, preload, ...rest } = props;
     const adapter = (0, external_routerAdapter_js_namespaceObject.useI18nRouterAdapter)();
     const { language, supportedLanguages, localisedUrls } = (0, external_context_js_namespaceObject.useModernI18n)();
     const config = {
@@ -180,7 +180,7 @@ const Link = (props)=>{
         'aria-current': rest['aria-current'] ?? resolvedActiveProps['aria-current'] ?? 'page'
     } : {};
     if (!target) {
-        const { prefetch: _prefetch, preload: _preload, replace: _replace, ...anchorProps } = rest;
+        const { replace: _replace, ...anchorProps } = rest;
         return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("a", {
             href: to,
             ...anchorProps,
@@ -189,7 +189,7 @@ const Link = (props)=>{
     }
     const { Link: RouterLink, hasRouter, framework } = adapter;
     if (!hasRouter || !RouterLink) {
-        const { prefetch: _prefetch, preload: _preload, replace: _replace, ...anchorProps } = rest;
+        const { replace: _replace, ...anchorProps } = rest;
         const { className: activeClassName, style: activeStyle, ...activeRest } = resolvedActiveProps;
         return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("a", {
             href: target.href,
@@ -210,26 +210,38 @@ const Link = (props)=>{
         ...rest.style,
         ...activeStyle
     };
-    if ('tanstack' === framework) return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(RouterLink, {
-        to: target.localizedPathname,
-        ...target.searchObject ? {
-            search: target.searchObject
-        } : {},
-        ...target.hash ? {
-            hash: target.hash
-        } : {},
-        ...void 0 === hashScrollIntoView ? {} : {
-            hashScrollIntoView
-        },
-        ...rest,
-        ...activeRest,
-        ...activeAttributes,
-        className: mergedClassName,
-        style: mergedStyle,
-        children: children
-    });
+    if ('tanstack' === framework) {
+        const tanstackPreload = void 0 !== preload ? preload : void 0 === prefetch ? void 0 : 'none' === prefetch ? false : prefetch;
+        return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(RouterLink, {
+            to: target.localizedPathname,
+            ...target.searchObject ? {
+                search: target.searchObject
+            } : {},
+            ...target.hash ? {
+                hash: target.hash
+            } : {},
+            ...void 0 === hashScrollIntoView ? {} : {
+                hashScrollIntoView
+            },
+            ...void 0 === tanstackPreload ? {} : {
+                preload: tanstackPreload
+            },
+            ...rest,
+            ...activeRest,
+            ...activeAttributes,
+            className: mergedClassName,
+            style: mergedStyle,
+            children: children
+        });
+    }
     return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(RouterLink, {
         to: target.href,
+        ...void 0 === prefetch ? {} : {
+            prefetch
+        },
+        ...void 0 === preload ? {} : {
+            preload
+        },
         ...rest,
         ...activeRest,
         ...activeAttributes,

package/dist/cjs/runtime/i18n/backend/defaults.node.js

@@ -1,5 +1,14 @@
 "use strict";
 var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
 (()=>{
     __webpack_require__.d = (exports1, getters, values)=>{
         var define = (defs, kind)=>{
@@ -27,9 +36,37 @@ var __webpack_require__ = {};
 })();
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    DEFAULT_I18NEXT_BACKEND_OPTIONS: ()=>DEFAULT_I18NEXT_BACKEND_OPTIONS,
+    convertBackendOptions: ()=>convertBackendOptions,
+    resolveDefaultLocalesDir: ()=>resolveDefaultLocalesDir
+});
+const external_fs_namespaceObject = require("fs");
+var external_fs_default = /*#__PURE__*/ __webpack_require__.n(external_fs_namespaceObject);
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+const CONVENTIONAL_LOCALES_DIRS = [
+    './locales',
+    './config/public/locales'
+];
+const isDirectory = (dirPath)=>{
+    try {
+        return external_fs_default().statSync(dirPath).isDirectory();
+    } catch  {
+        return false;
+    }
+};
+const resolveDefaultLocalesDir = (cwd = process.cwd())=>{
+    for (const dir of CONVENTIONAL_LOCALES_DIRS)if (isDirectory(external_path_default().resolve(cwd, dir))) return dir;
+    return CONVENTIONAL_LOCALES_DIRS[0];
+};
 const DEFAULT_I18NEXT_BACKEND_OPTIONS = {
-    loadPath: './config/public/locales/{{lng}}/{{ns}}.json',
-    addPath: './config/public/locales/{{lng}}/{{ns}}.json'
+    get loadPath () {
+        return `${resolveDefaultLocalesDir()}/{{lng}}/{{ns}}.json`;
+    },
+    get addPath () {
+        return `${resolveDefaultLocalesDir()}/{{lng}}/{{ns}}.json`;
+    }
 };
 function convertPath(path) {
     if (!path) return path;
@@ -45,16 +82,13 @@ function convertBackendOptions(options) {
     if (converted.addPath) converted.addPath = convertPath(converted.addPath);
     return converted;
 }
-__webpack_require__.d(__webpack_exports__, {
-    convertBackendOptions: ()=>convertBackendOptions
-}, {
-    DEFAULT_I18NEXT_BACKEND_OPTIONS: DEFAULT_I18NEXT_BACKEND_OPTIONS
-});
 exports.DEFAULT_I18NEXT_BACKEND_OPTIONS = __webpack_exports__.DEFAULT_I18NEXT_BACKEND_OPTIONS;
 exports.convertBackendOptions = __webpack_exports__.convertBackendOptions;
+exports.resolveDefaultLocalesDir = __webpack_exports__.resolveDefaultLocalesDir;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "DEFAULT_I18NEXT_BACKEND_OPTIONS",
-    "convertBackendOptions"
+    "convertBackendOptions",
+    "resolveDefaultLocalesDir"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true

package/dist/cjs/runtime/localizedPaths.js

@@ -41,10 +41,7 @@ const external_utils_js_namespaceObject = require("./utils.js");
 const localizePath = (pathname, language, config)=>(0, external_utils_js_namespaceObject.buildLocalizedUrl)(pathname, language, config.languages, config.localisedUrls);
 const canonicalPath = (target, config)=>{
     const { pathname, search, hash } = (0, external_utils_js_namespaceObject.splitUrlTarget)(target);
-    const segments = pathname.split('/').filter(Boolean);
-    const pathWithoutLanguage = segments.length > 0 && config.languages.includes(segments[0]) ? `/${segments.slice(1).join('/')}` : pathname || '/';
-    const localisedUrlsConfig = (0, localisedUrls_js_namespaceObject.resolveLocalisedUrlsConfig)(config.localisedUrls);
-    const resolvedPath = localisedUrlsConfig.enabled ? (0, localisedUrls_js_namespaceObject.resolveCanonicalLocalisedPath)(pathWithoutLanguage, config.languages, localisedUrlsConfig.map) : pathWithoutLanguage;
+    const resolvedPath = (0, localisedUrls_js_namespaceObject.canonicalTargetPathname)(pathname, config.languages, config.localisedUrls);
     return `${resolvedPath}${search}${hash}`;
 };
 const useLocalizedPaths = ()=>{

package/dist/cjs/runtime/routerAdapter.js

@@ -57,7 +57,7 @@ const getWindowLocation = ()=>{
     };
 };
 const getRouterFramework = (runtimeContext, internalContext, inReactRouter)=>{
-    const framework = internalContext.routerFramework || internalContext.routerRuntime?.framework || runtimeContext.routerFramework;
+    const framework = (0, context_namespaceObject.getRouterRuntimeState)(internalContext)?.framework || (0, context_namespaceObject.getRouterRuntimeState)(runtimeContext)?.framework;
     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';
@@ -65,7 +65,7 @@ const getRouterFramework = (runtimeContext, internalContext, inReactRouter)=>{
 };
 const getRouterInstance = (internalContext, contextRouter)=>{
     if (contextRouter) return contextRouter;
-    const router = internalContext.routerInstance || internalContext.routerRuntime?.instance;
+    const router = (0, context_namespaceObject.getRouterRuntimeState)(internalContext)?.instance;
     if (!router || 'object' != typeof router) return null;
     return router;
 };

package/dist/cjs/runtime/utils.js

@@ -69,15 +69,8 @@ const splitUrlTarget = (target)=>{
 };
 const buildLocalizedUrl = (target, language, languages, localisedUrls)=>{
     const { pathname, search, hash } = splitUrlTarget(target);
-    const segments = pathname.split('/').filter(Boolean);
-    const localisedUrlsConfig = (0, localisedUrls_js_namespaceObject.resolveLocalisedUrlsConfig)(localisedUrls);
-    const pathWithoutLanguage = segments.length > 0 && languages.includes(segments[0]) ? `/${segments.slice(1).join('/')}` : pathname || '/';
-    const resolvedPath = localisedUrlsConfig.enabled ? (0, localisedUrls_js_namespaceObject.resolveLocalisedPath)(pathWithoutLanguage, language, languages, localisedUrlsConfig.map) : pathWithoutLanguage;
-    const resolvedSegments = resolvedPath.split('/').filter(Boolean);
-    return `/${[
-        language,
-        ...resolvedSegments
-    ].join('/')}${search}${hash}`;
+    const localizedPathname = (0, localisedUrls_js_namespaceObject.localiseTargetPathname)(pathname, language, languages, localisedUrls);
+    return `${localizedPathname}${search}${hash}`;
 };
 const detectLanguageFromPath = (pathname, languages, localePathRedirect)=>{
     if (!localePathRedirect) return {

package/dist/cjs/server/index.js

@@ -162,15 +162,7 @@ const buildLocalizedUrl = (req, urlPath, language, languages, localisedUrls)=>{
     const pathname = url.pathname;
     const basePath = urlPath.replace('/*', '');
     const remainingPath = pathname.startsWith(basePath) ? pathname.slice(basePath.length) : pathname;
-    const segments = remainingPath.split('/').filter(Boolean);
-    const localisedUrlsConfig = (0, localisedUrls_js_namespaceObject.resolveLocalisedUrlsConfig)(localisedUrls);
-    const pathWithoutLanguage = segments.length > 0 && languages.includes(segments[0]) ? `/${segments.slice(1).join('/')}` : remainingPath;
-    const resolvedPath = localisedUrlsConfig.enabled ? (0, localisedUrls_js_namespaceObject.resolveLocalisedPath)(pathWithoutLanguage, language, languages, localisedUrlsConfig.map) : pathWithoutLanguage;
-    const resolvedSegments = resolvedPath.split('/').filter(Boolean);
-    const newPathname = `/${[
-        language,
-        ...resolvedSegments
-    ].join('/')}`;
+    const newPathname = (0, localisedUrls_js_namespaceObject.localiseTargetPathname)(remainingPath, language, languages, localisedUrls);
     const suffix = `${url.search}${url.hash}`;
     const localizedUrl = '/' === basePath ? newPathname + suffix : basePath + newPathname + suffix;
     return localizedUrl;

package/dist/cjs/shared/localisedUrls.js

@@ -32,12 +32,13 @@ const LOCALE_PARAM_NAMES = new Set([
     'locale',
     'language'
 ]);
-const normalisePathPattern = (path)=>{
+const normaliseSlashes = (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');
+    return withLeadingSlash.length > 1 ? withLeadingSlash.replace(/\/+$/, '') : withLeadingSlash;
 };
+const normalisePathPattern = (path)=>normaliseSlashes(path).replace(/\[(.+?)\]/g, ':$1');
+const normalisePathname = (pathname)=>normaliseSlashes(pathname);
 const normaliseRoutePath = (path)=>{
     const normalized = normalisePathPattern(path);
     return '/' === normalized ? '' : normalized.slice(1);
@@ -63,16 +64,12 @@ const getLeadingLocaleParam = (path)=>{
     return getLocaleParamSegment(segments[0] || '');
 };
 const resolveLocalisedUrlsConfig = (option)=>{
-    if (false === option) return {
-        enabled: false,
-        map: {}
-    };
-    if (option && 'object' == typeof option) return {
+    if (option && 'object' == typeof option && Object.keys(option).length > 0) return {
         enabled: true,
         map: option
     };
     return {
-        enabled: true,
+        enabled: false,
         map: {}
     };
 };
@@ -164,9 +161,13 @@ const applyLocalisedUrlsToRoutes = (routes, languages, localisedUrls)=>{
 };
 const escapeRegExp = (value)=>value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 const getParamName = (segment)=>segment.slice(1).replace(/\?$/, '');
+const compiledPathPatternCache = new Map();
 const compilePathPattern = (pattern)=>{
+    const normalizedPattern = normalisePathPattern(pattern);
+    const cached = compiledPathPatternCache.get(normalizedPattern);
+    if (cached) return cached;
     const names = [];
-    const segments = normalisePathPattern(pattern).split('/').filter(Boolean);
+    const segments = normalizedPattern.split('/').filter(Boolean);
     const source = segments.map((segment)=>{
         if (segment.startsWith(':')) {
             names.push(getParamName(segment));
@@ -179,19 +180,55 @@ const compilePathPattern = (pattern)=>{
         }
         return `/${escapeRegExp(segment)}`;
     }).join('');
-    return {
+    const compiled = {
         names,
         regexp: new RegExp(`^${source || '/'}$`)
     };
+    compiledPathPatternCache.set(normalizedPattern, compiled);
+    return compiled;
+};
+const getPatternSpecificity = (pattern)=>{
+    const segments = normalisePathPattern(pattern).split('/').filter(Boolean);
+    let staticSegments = 0;
+    let dynamicSegments = 0;
+    let splatSegments = 0;
+    for (const segment of segments)if ('*' === segment) splatSegments++;
+    else if (segment.startsWith(':')) dynamicSegments++;
+    else staticSegments++;
+    return {
+        staticSegments,
+        dynamicSegments,
+        splatSegments,
+        totalSegments: segments.length
+    };
+};
+const comparePatternSpecificity = (left, right)=>{
+    const a = getPatternSpecificity(left);
+    const b = getPatternSpecificity(right);
+    return b.staticSegments - a.staticSegments || b.totalSegments - a.totalSegments || a.splatSegments - b.splatSegments || a.dynamicSegments - b.dynamicSegments;
+};
+const sortPatternsBySpecificity = (patterns)=>patterns.map((pattern, index)=>({
+            pattern,
+            index
+        })).sort((left, right)=>comparePatternSpecificity(left.pattern.pattern, right.pattern.pattern) || left.index - right.index).map(({ pattern })=>pattern);
+const decodePathParam = (value)=>{
+    try {
+        return decodeURIComponent(value);
+    } catch  {
+        return null;
+    }
 };
 const matchPathPattern = (pathname, pattern)=>{
     const { names, regexp } = compilePathPattern(pattern);
-    const match = regexp.exec(normalisePathPattern(pathname));
+    const match = regexp.exec(normalisePathname(pathname));
     if (!match) return null;
-    return names.reduce((params, name, index)=>{
-        params[name] = decodeURIComponent(match[index + 1] || '');
-        return params;
-    }, {});
+    const params = {};
+    for(let index = 0; index < names.length; index++){
+        const decoded = decodePathParam(match[index + 1] || '');
+        if (null === decoded) return null;
+        params[names[index]] = decoded;
+    }
+    return params;
 };
 const buildPathFromPattern = (pattern, params)=>{
     const segments = normalisePathPattern(pattern).split('/').filter(Boolean);
@@ -206,27 +243,41 @@ const buildPathFromPattern = (pattern, params)=>{
     return `/${path}`;
 };
 const resolveLocalisedPath = (pathname, targetLanguage, languages, localisedUrls)=>{
-    const normalizedPathname = normalisePathPattern(pathname);
-    for (const [canonicalPattern, localisedUrlEntry] of Object.entries(localisedUrls)){
+    const normalizedPathname = normalisePathname(pathname);
+    const canonicalCandidates = sortPatternsBySpecificity(Object.entries(localisedUrls).map(([canonicalPattern, localisedUrlEntry])=>({
+            pattern: canonicalPattern,
+            canonicalPattern,
+            localisedUrlEntry
+        })));
+    for (const { canonicalPattern, localisedUrlEntry } of canonicalCandidates){
         const targetPattern = localisedUrlEntry[targetLanguage];
         if (!targetPattern) continue;
         const params = matchPathPattern(normalizedPathname, canonicalPattern);
         if (params) return buildPathFromPattern(targetPattern, params);
     }
-    for (const localisedUrlEntry of Object.values(localisedUrls)){
+    const localisedCandidates = sortPatternsBySpecificity(Object.values(localisedUrls).flatMap((localisedUrlEntry)=>{
         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);
-        }
+        if (!targetPattern) return [];
+        return languages.map((language)=>localisedUrlEntry[language]).filter((sourcePattern)=>Boolean(sourcePattern)).map((sourcePattern)=>({
+                pattern: sourcePattern,
+                sourcePattern,
+                targetPattern
+            }));
+    }));
+    for (const { sourcePattern, targetPattern } of localisedCandidates){
+        const params = matchPathPattern(normalizedPathname, sourcePattern);
+        if (params) return buildPathFromPattern(targetPattern, params);
     }
     return normalizedPathname;
 };
 const resolveCanonicalLocalisedPath = (pathname, languages, localisedUrls)=>{
-    const normalizedPathname = normalisePathPattern(pathname);
-    for (const [canonicalPattern, localisedUrlEntry] of Object.entries(localisedUrls)){
+    const normalizedPathname = normalisePathname(pathname);
+    const canonicalCandidates = sortPatternsBySpecificity(Object.entries(localisedUrls).map(([canonicalPattern, localisedUrlEntry])=>({
+            pattern: canonicalPattern,
+            canonicalPattern,
+            localisedUrlEntry
+        })));
+    for (const { canonicalPattern, localisedUrlEntry } of canonicalCandidates){
         const canonicalParams = matchPathPattern(normalizedPathname, canonicalPattern);
         if (canonicalParams) return buildPathFromPattern(canonicalPattern, canonicalParams);
         for (const language of languages){
@@ -238,11 +289,34 @@ const resolveCanonicalLocalisedPath = (pathname, languages, localisedUrls)=>{
     }
     return normalizedPathname;
 };
+const stripLanguagePrefix = (pathname, languages)=>{
+    const segments = pathname.split('/').filter(Boolean);
+    if (segments.length > 0 && languages.includes(segments[0])) return `/${segments.slice(1).join('/')}`;
+    return pathname || '/';
+};
+const localiseTargetPathname = (pathname, language, languages, localisedUrls)=>{
+    const pathWithoutLanguage = stripLanguagePrefix(pathname, languages);
+    const localisedUrlsConfig = resolveLocalisedUrlsConfig(localisedUrls);
+    const resolvedPath = localisedUrlsConfig.enabled ? resolveLocalisedPath(pathWithoutLanguage, language, languages, localisedUrlsConfig.map) : pathWithoutLanguage;
+    const resolvedSegments = resolvedPath.split('/').filter(Boolean);
+    return `/${[
+        language,
+        ...resolvedSegments
+    ].join('/')}`;
+};
+const canonicalTargetPathname = (pathname, languages, localisedUrls)=>{
+    const pathWithoutLanguage = stripLanguagePrefix(pathname, languages);
+    const localisedUrlsConfig = resolveLocalisedUrlsConfig(localisedUrls);
+    return localisedUrlsConfig.enabled ? resolveCanonicalLocalisedPath(pathWithoutLanguage, languages, localisedUrlsConfig.map) : pathWithoutLanguage;
+};
 __webpack_require__.d(__webpack_exports__, {}, {
     applyLocalisedUrlsToRoutes: applyLocalisedUrlsToRoutes,
     buildPathFromPattern: buildPathFromPattern,
+    canonicalTargetPathname: canonicalTargetPathname,
+    localiseTargetPathname: localiseTargetPathname,
     matchPathPattern: matchPathPattern,
     normalisePathPattern: normalisePathPattern,
+    normalisePathname: normalisePathname,
     resolveCanonicalLocalisedPath: resolveCanonicalLocalisedPath,
     resolveLocalisedPath: resolveLocalisedPath,
     resolveLocalisedUrlsConfig: resolveLocalisedUrlsConfig,
@@ -250,8 +324,11 @@ __webpack_require__.d(__webpack_exports__, {}, {
 });
 exports.applyLocalisedUrlsToRoutes = __webpack_exports__.applyLocalisedUrlsToRoutes;
 exports.buildPathFromPattern = __webpack_exports__.buildPathFromPattern;
+exports.canonicalTargetPathname = __webpack_exports__.canonicalTargetPathname;
+exports.localiseTargetPathname = __webpack_exports__.localiseTargetPathname;
 exports.matchPathPattern = __webpack_exports__.matchPathPattern;
 exports.normalisePathPattern = __webpack_exports__.normalisePathPattern;
+exports.normalisePathname = __webpack_exports__.normalisePathname;
 exports.resolveCanonicalLocalisedPath = __webpack_exports__.resolveCanonicalLocalisedPath;
 exports.resolveLocalisedPath = __webpack_exports__.resolveLocalisedPath;
 exports.resolveLocalisedUrlsConfig = __webpack_exports__.resolveLocalisedUrlsConfig;
@@ -259,8 +336,11 @@ exports.validateLocalisedUrls = __webpack_exports__.validateLocalisedUrls;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "applyLocalisedUrlsToRoutes",
     "buildPathFromPattern",
+    "canonicalTargetPathname",
+    "localiseTargetPathname",
     "matchPathPattern",
     "normalisePathPattern",
+    "normalisePathname",
     "resolveCanonicalLocalisedPath",
     "resolveLocalisedPath",
     "resolveLocalisedUrlsConfig",

package/dist/esm/runtime/Link.mjs

@@ -88,7 +88,7 @@ const mergeClassNames = (...values)=>{
     return classNames.length > 0 ? classNames.join(' ') : void 0;
 };
 const Link = (props)=>{
-    const { to, params, children, hash: hashProp, search: searchProp, hashScrollIntoView, activeOptions, activeProps, ...rest } = props;
+    const { to, params, children, hash: hashProp, search: searchProp, hashScrollIntoView, activeOptions, activeProps, prefetch, preload, ...rest } = props;
     const adapter = useI18nRouterAdapter();
     const { language, supportedLanguages, localisedUrls } = useModernI18n();
     const config = {
@@ -146,7 +146,7 @@ const Link = (props)=>{
         'aria-current': rest['aria-current'] ?? resolvedActiveProps['aria-current'] ?? 'page'
     } : {};
     if (!target) {
-        const { prefetch: _prefetch, preload: _preload, replace: _replace, ...anchorProps } = rest;
+        const { replace: _replace, ...anchorProps } = rest;
         return /*#__PURE__*/ jsx("a", {
             href: to,
             ...anchorProps,
@@ -155,7 +155,7 @@ const Link = (props)=>{
     }
     const { Link: RouterLink, hasRouter, framework } = adapter;
     if (!hasRouter || !RouterLink) {
-        const { prefetch: _prefetch, preload: _preload, replace: _replace, ...anchorProps } = rest;
+        const { replace: _replace, ...anchorProps } = rest;
         const { className: activeClassName, style: activeStyle, ...activeRest } = resolvedActiveProps;
         return /*#__PURE__*/ jsx("a", {
             href: target.href,
@@ -176,26 +176,38 @@ const Link = (props)=>{
         ...rest.style,
         ...activeStyle
     };
-    if ('tanstack' === framework) return /*#__PURE__*/ jsx(RouterLink, {
-        to: target.localizedPathname,
-        ...target.searchObject ? {
-            search: target.searchObject
-        } : {},
-        ...target.hash ? {
-            hash: target.hash
-        } : {},
-        ...void 0 === hashScrollIntoView ? {} : {
-            hashScrollIntoView
-        },
-        ...rest,
-        ...activeRest,
-        ...activeAttributes,
-        className: mergedClassName,
-        style: mergedStyle,
-        children: children
-    });
+    if ('tanstack' === framework) {
+        const tanstackPreload = void 0 !== preload ? preload : void 0 === prefetch ? void 0 : 'none' === prefetch ? false : prefetch;
+        return /*#__PURE__*/ jsx(RouterLink, {
+            to: target.localizedPathname,
+            ...target.searchObject ? {
+                search: target.searchObject
+            } : {},
+            ...target.hash ? {
+                hash: target.hash
+            } : {},
+            ...void 0 === hashScrollIntoView ? {} : {
+                hashScrollIntoView
+            },
+            ...void 0 === tanstackPreload ? {} : {
+                preload: tanstackPreload
+            },
+            ...rest,
+            ...activeRest,
+            ...activeAttributes,
+            className: mergedClassName,
+            style: mergedStyle,
+            children: children
+        });
+    }
     return /*#__PURE__*/ jsx(RouterLink, {
         to: target.href,
+        ...void 0 === prefetch ? {} : {
+            prefetch
+        },
+        ...void 0 === preload ? {} : {
+            preload
+        },
         ...rest,
         ...activeRest,
         ...activeAttributes,

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

@@ -1,6 +1,27 @@
+import fs from "fs";
+import path_0 from "path";
+const CONVENTIONAL_LOCALES_DIRS = [
+    './locales',
+    './config/public/locales'
+];
+const isDirectory = (dirPath)=>{
+    try {
+        return fs.statSync(dirPath).isDirectory();
+    } catch  {
+        return false;
+    }
+};
+const resolveDefaultLocalesDir = (cwd = process.cwd())=>{
+    for (const dir of CONVENTIONAL_LOCALES_DIRS)if (isDirectory(path_0.resolve(cwd, dir))) return dir;
+    return CONVENTIONAL_LOCALES_DIRS[0];
+};
 const DEFAULT_I18NEXT_BACKEND_OPTIONS = {
-    loadPath: './config/public/locales/{{lng}}/{{ns}}.json',
-    addPath: './config/public/locales/{{lng}}/{{ns}}.json'
+    get loadPath () {
+        return `${resolveDefaultLocalesDir()}/{{lng}}/{{ns}}.json`;
+    },
+    get addPath () {
+        return `${resolveDefaultLocalesDir()}/{{lng}}/{{ns}}.json`;
+    }
 };
 function convertPath(path) {
     if (!path) return path;
@@ -16,4 +37,4 @@ function convertBackendOptions(options) {
     if (converted.addPath) converted.addPath = convertPath(converted.addPath);
     return converted;
 }
-export { DEFAULT_I18NEXT_BACKEND_OPTIONS, convertBackendOptions };
+export { DEFAULT_I18NEXT_BACKEND_OPTIONS, convertBackendOptions, resolveDefaultLocalesDir };

package/dist/esm/runtime/localizedPaths.mjs

@@ -1,15 +1,12 @@
 import { useMemo } from "react";
-import { resolveCanonicalLocalisedPath, resolveLocalisedUrlsConfig } from "../shared/localisedUrls.mjs";
+import { canonicalTargetPathname } from "../shared/localisedUrls.mjs";
 import { useModernI18n } from "./context.mjs";
 import { useI18nRouterAdapter } from "./routerAdapter.mjs";
 import { buildLocalizedUrl, splitUrlTarget } from "./utils.mjs";
 const localizePath = (pathname, language, config)=>buildLocalizedUrl(pathname, language, config.languages, config.localisedUrls);
 const canonicalPath = (target, config)=>{
     const { pathname, search, hash } = splitUrlTarget(target);
-    const segments = pathname.split('/').filter(Boolean);
-    const pathWithoutLanguage = segments.length > 0 && config.languages.includes(segments[0]) ? `/${segments.slice(1).join('/')}` : pathname || '/';
-    const localisedUrlsConfig = resolveLocalisedUrlsConfig(config.localisedUrls);
-    const resolvedPath = localisedUrlsConfig.enabled ? resolveCanonicalLocalisedPath(pathWithoutLanguage, config.languages, localisedUrlsConfig.map) : pathWithoutLanguage;
+    const resolvedPath = canonicalTargetPathname(pathname, config.languages, config.localisedUrls);
     return `${resolvedPath}${search}${hash}`;
 };
 const useLocalizedPaths = ()=>{

package/dist/esm/runtime/routerAdapter.mjs

@@ -1,5 +1,5 @@
 import { RuntimeContext, isBrowser } from "@modern-js/runtime";
-import { InternalRuntimeContext } from "@modern-js/runtime/context";
+import { InternalRuntimeContext, getRouterRuntimeState } 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)=>{
@@ -25,7 +25,7 @@ const getWindowLocation = ()=>{
     };
 };
 const getRouterFramework = (runtimeContext, internalContext, inReactRouter)=>{
-    const framework = internalContext.routerFramework || internalContext.routerRuntime?.framework || runtimeContext.routerFramework;
+    const framework = getRouterRuntimeState(internalContext)?.framework || getRouterRuntimeState(runtimeContext)?.framework;
     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';
@@ -33,7 +33,7 @@ const getRouterFramework = (runtimeContext, internalContext, inReactRouter)=>{
 };
 const getRouterInstance = (internalContext, contextRouter)=>{
     if (contextRouter) return contextRouter;
-    const router = internalContext.routerInstance || internalContext.routerRuntime?.instance;
+    const router = getRouterRuntimeState(internalContext)?.instance;
     if (!router || 'object' != typeof router) return null;
     return router;
 };

package/dist/esm/runtime/utils.mjs

@@ -1,6 +1,6 @@
 import { isBrowser } from "@modern-js/runtime";
 import { getGlobalBasename } from "@modern-js/runtime/context";
-import { resolveLocalisedPath, resolveLocalisedUrlsConfig } from "../shared/localisedUrls.mjs";
+import { localiseTargetPathname } from "../shared/localisedUrls.mjs";
 const getPathname = (context)=>{
     if (isBrowser()) return window.location.pathname;
     return context.ssrContext?.request?.pathname || '/';
@@ -31,15 +31,8 @@ const splitUrlTarget = (target)=>{
 };
 const buildLocalizedUrl = (target, language, languages, localisedUrls)=>{
     const { pathname, search, hash } = splitUrlTarget(target);
-    const segments = pathname.split('/').filter(Boolean);
-    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('/')}${search}${hash}`;
+    const localizedPathname = localiseTargetPathname(pathname, language, languages, localisedUrls);
+    return `${localizedPathname}${search}${hash}`;
 };
 const detectLanguageFromPath = (pathname, languages, localePathRedirect)=>{
     if (!localePathRedirect) return {