@bleedingdev/modern-js-plugin-i18n 3.5.0-ultramodern.36 → 3.5.0-ultramodern.37

package/dist/cjs/shared/localisedUrls.js

@@ -28,41 +28,56 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
+    DEFAULT_LOCALE_REDIRECT_SKIP_RULES: ()=>index_js_namespaceObject.DEFAULT_LOCALE_REDIRECT_SKIP_RULES,
     applyLocalisedUrlsToRoutes: ()=>index_js_namespaceObject.applyLocalisedUrlsToRoutes,
     buildPathFromPattern: ()=>index_js_namespaceObject.buildPathFromPattern,
     canonicalTargetPathname: ()=>index_js_namespaceObject.canonicalTargetPathname,
+    isDefaultLocaleRedirectSkipPath: ()=>index_js_namespaceObject.isDefaultLocaleRedirectSkipPath,
     localiseTargetPathname: ()=>index_js_namespaceObject.localiseTargetPathname,
     matchPathPattern: ()=>index_js_namespaceObject.matchPathPattern,
+    matchesPathPrefix: ()=>index_js_namespaceObject.matchesPathPrefix,
     normalisePathPattern: ()=>index_js_namespaceObject.normalisePathPattern,
     normalisePathname: ()=>index_js_namespaceObject.normalisePathname,
     resolveCanonicalLocalisedPath: ()=>index_js_namespaceObject.resolveCanonicalLocalisedPath,
     resolveLocalisedPath: ()=>index_js_namespaceObject.resolveLocalisedPath,
     resolveLocalisedUrlsConfig: ()=>index_js_namespaceObject.resolveLocalisedUrlsConfig,
+    shouldSkipLocaleRedirect: ()=>index_js_namespaceObject.shouldSkipLocaleRedirect,
+    stripLanguagePrefix: ()=>index_js_namespaceObject.stripLanguagePrefix,
     validateLocalisedUrls: ()=>index_js_namespaceObject.validateLocalisedUrls
 });
 const index_js_namespaceObject = require("./localisedUrls/index.js");
+exports.DEFAULT_LOCALE_REDIRECT_SKIP_RULES = __webpack_exports__.DEFAULT_LOCALE_REDIRECT_SKIP_RULES;
 exports.applyLocalisedUrlsToRoutes = __webpack_exports__.applyLocalisedUrlsToRoutes;
 exports.buildPathFromPattern = __webpack_exports__.buildPathFromPattern;
 exports.canonicalTargetPathname = __webpack_exports__.canonicalTargetPathname;
+exports.isDefaultLocaleRedirectSkipPath = __webpack_exports__.isDefaultLocaleRedirectSkipPath;
 exports.localiseTargetPathname = __webpack_exports__.localiseTargetPathname;
 exports.matchPathPattern = __webpack_exports__.matchPathPattern;
+exports.matchesPathPrefix = __webpack_exports__.matchesPathPrefix;
 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;
+exports.shouldSkipLocaleRedirect = __webpack_exports__.shouldSkipLocaleRedirect;
+exports.stripLanguagePrefix = __webpack_exports__.stripLanguagePrefix;
 exports.validateLocalisedUrls = __webpack_exports__.validateLocalisedUrls;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "DEFAULT_LOCALE_REDIRECT_SKIP_RULES",
     "applyLocalisedUrlsToRoutes",
     "buildPathFromPattern",
     "canonicalTargetPathname",
+    "isDefaultLocaleRedirectSkipPath",
     "localiseTargetPathname",
     "matchPathPattern",
+    "matchesPathPrefix",
     "normalisePathPattern",
     "normalisePathname",
     "resolveCanonicalLocalisedPath",
     "resolveLocalisedPath",
     "resolveLocalisedUrlsConfig",
+    "shouldSkipLocaleRedirect",
+    "stripLanguagePrefix",
     "validateLocalisedUrls"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {

package/dist/cjs/shared/utils.js

@@ -63,19 +63,13 @@ function getBackendOptions(entryName, backend) {
 }
 __webpack_require__.d(__webpack_exports__, {
     getBackendOptions: ()=>getBackendOptions,
-    getEntryConfig: ()=>getEntryConfig,
-    getLocaleDetectionOptions: ()=>getLocaleDetectionOptions,
-    removeEntryConfigKey: ()=>removeEntryConfigKey
+    getLocaleDetectionOptions: ()=>getLocaleDetectionOptions
 });
 exports.getBackendOptions = __webpack_exports__.getBackendOptions;
-exports.getEntryConfig = __webpack_exports__.getEntryConfig;
 exports.getLocaleDetectionOptions = __webpack_exports__.getLocaleDetectionOptions;
-exports.removeEntryConfigKey = __webpack_exports__.removeEntryConfigKey;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "getBackendOptions",
-    "getEntryConfig",
-    "getLocaleDetectionOptions",
-    "removeEntryConfigKey"
+    "getLocaleDetectionOptions"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true

package/dist/esm/cli/locales.mjs

@@ -1,14 +1,14 @@
+import node_fs from "node:fs";
+import node_path from "node:path";
 import { getPublicDirRoutePrefixes, normalizePublicDir, normalizePublicDirPath } from "@modern-js/server-core";
-import fs from "fs";
-import path from "path";
 const LOCALES_RESOURCE_PATTERN = '{{lng}}/{{ns}}.json';
 function hasJsonFiles(dirPath) {
     try {
-        if (!fs.existsSync(dirPath) || !fs.statSync(dirPath).isDirectory()) return false;
-        const entries = fs.readdirSync(dirPath);
+        if (!node_fs.existsSync(dirPath) || !node_fs.statSync(dirPath).isDirectory()) return false;
+        const entries = node_fs.readdirSync(dirPath);
         for (const entry of entries){
-            const entryPath = path.join(dirPath, entry);
-            const stat = fs.statSync(entryPath);
+            const entryPath = node_path.join(dirPath, entry);
+            const stat = node_fs.statSync(entryPath);
             if (stat.isFile() && entry.endsWith('.json')) return true;
             if (stat.isDirectory() && hasJsonFiles(entryPath)) return true;
         }
@@ -18,7 +18,7 @@ function hasJsonFiles(dirPath) {
     }
 }
 function toPosixPath(filePath) {
-    return filePath.split(path.sep).join(path.posix.sep);
+    return filePath.split(node_path.sep).join(node_path.posix.sep);
 }
 function getPublicDirOutputPath(publicDir) {
     return normalizePublicDirPath(publicDir);
@@ -45,20 +45,20 @@ function detectLocalesDirectory(appDirectory, normalizedConfig) {
     const publicDirPrefixes = getPublicDirRoutePrefixes(normalizedConfig?.server?.publicDir);
     for(let index = 0; index < publicDirs.length; index++){
         const publicDir = publicDirs[index];
-        if (path.isAbsolute(publicDir)) continue;
-        const publicDirPath = path.join(appDirectory, publicDir);
+        if (node_path.isAbsolute(publicDir)) continue;
+        const publicDirPath = node_path.join(appDirectory, publicDir);
         const publicDirPrefix = publicDirPrefixes[index] || `/${normalizePublicDirPath(publicDir)}`;
         const publicDirOutputPath = getPublicDirOutputPath(publicDir);
-        if ('locales' === path.basename(normalizePublicDirPath(publicDir)) && hasJsonFiles(publicDirPath)) return buildDetectedLocalesDirectory(publicDirPrefix, `./${publicDirOutputPath}`);
-        const localesPath = path.join(publicDirPath, 'locales');
+        if ('locales' === node_path.basename(normalizePublicDirPath(publicDir)) && hasJsonFiles(publicDirPath)) return buildDetectedLocalesDirectory(publicDirPrefix, `./${publicDirOutputPath}`);
+        const localesPath = node_path.join(publicDirPath, 'locales');
         if (hasJsonFiles(localesPath)) return buildDetectedLocalesDirectory(`${publicDirPrefix}/locales`, `./${publicDirOutputPath}/locales`);
     }
-    const configPublicPath = path.join(appDirectory, 'config', 'public', 'locales');
+    const configPublicPath = node_path.join(appDirectory, 'config', 'public', 'locales');
     if (hasJsonFiles(configPublicPath)) return buildDetectedLocalesDirectory('/locales', './public/locales', [
         './config/public/locales',
         './public/locales'
     ]);
-    const rootLocalesPath = path.join(appDirectory, 'locales');
+    const rootLocalesPath = node_path.join(appDirectory, 'locales');
     if (hasJsonFiles(rootLocalesPath)) return buildDetectedLocalesDirectory('/locales', './locales');
 }
 function applyDetectedBackendPaths(backendOptions, detectedLocales) {

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

@@ -1,18 +1,18 @@
-import fs from "fs";
-import path_0 from "path";
+import node_fs from "node:fs";
+import node_path from "node:path";
 const CONVENTIONAL_LOCALES_DIRS = [
     './locales',
     './config/public/locales'
 ];
 const isDirectory = (dirPath)=>{
     try {
-        return fs.statSync(dirPath).isDirectory();
+        return node_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;
+    for (const dir of CONVENTIONAL_LOCALES_DIRS)if (isDirectory(node_path.resolve(cwd, dir))) return dir;
     return CONVENTIONAL_LOCALES_DIRS[0];
 };
 const DEFAULT_I18NEXT_BACKEND_OPTIONS = {
@@ -38,7 +38,7 @@ function getResourceBasePath(resourcePath) {
 }
 function pathExists(resourcePath) {
     try {
-        return fs.existsSync(getResourceBasePath(resourcePath));
+        return node_fs.existsSync(getResourceBasePath(resourcePath));
     } catch  {
         return false;
     }

package/dist/esm/runtime/i18n/detection/cache.mjs

@@ -21,9 +21,10 @@ const stableStringify = (value)=>{
     if (null == value) return JSON.stringify(value);
     if ('object' != typeof value) return JSON.stringify(value);
     if (Array.isArray(value)) return `[${value.map((item)=>stableStringify(item)).join(',')}]`;
-    const sortedKeys = Object.keys(value).sort();
+    const record = value;
+    const sortedKeys = Object.keys(record).sort();
     const sortedEntries = sortedKeys.map((key)=>{
-        const stringifiedValue = stableStringify(value[key]);
+        const stringifiedValue = stableStringify(record[key]);
         return `${JSON.stringify(key)}:${stringifiedValue}`;
     });
     return `{${sortedEntries.join(',')}}`;

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

@@ -1,8 +1,10 @@
 function isI18nWrapperInstance(obj) {
     if (!obj || 'object' != typeof obj) return false;
-    if (!obj.i18nInstance || 'object' != typeof obj.i18nInstance) return false;
-    if (!obj.i18nInstance.instance) return false;
-    if ('function' != typeof obj.init || 'function' != typeof obj.use) return false;
+    const candidate = obj;
+    if (!candidate.i18nInstance || 'object' != typeof candidate.i18nInstance) return false;
+    const wrapper = candidate.i18nInstance;
+    if (!wrapper.instance) return false;
+    if ('function' != typeof candidate.init || 'function' != typeof candidate.use) return false;
     return true;
 }
 function getI18nWrapperI18nextInstance(wrapperInstance) {
@@ -19,7 +21,8 @@ function getActualI18nextInstance(instance) {
 function isI18nInstance(obj) {
     if (!obj || 'object' != typeof obj) return false;
     if (isI18nWrapperInstance(obj)) return true;
-    return 'function' == typeof obj.init && 'function' == typeof obj.use;
+    const candidate = obj;
+    return 'function' == typeof candidate.init && 'function' == typeof candidate.use;
 }
 async function tryImportI18next() {
     try {
@@ -56,4 +59,4 @@ async function getI18nInstance(userInstance) {
     if (i18nextInstance) return i18nextInstance;
     throw new Error('No i18n instance found');
 }
-export { getActualI18nextInstance, getI18nInstance, getI18nWrapperI18nextInstance, getI18nextInstanceForProvider, isI18nInstance, isI18nWrapperInstance };
+export { getActualI18nextInstance, getI18nInstance, getI18nextInstanceForProvider, isI18nInstance, isI18nWrapperInstance };

package/dist/esm/runtime/utils.mjs

@@ -1,6 +1,6 @@
 import { isBrowser } from "@modern-js/runtime";
 import { getGlobalBasename } from "@modern-js/runtime/context";
-import { localiseTargetPathname } from "../shared/localisedUrls.mjs";
+import { localiseTargetPathname, shouldSkipLocaleRedirect } from "../shared/localisedUrls.mjs";
 const getPathname = (context)=>{
     if (isBrowser()) return window.location.pathname;
     return context.ssrContext?.request?.pathname || '/';
@@ -51,13 +51,5 @@ const detectLanguageFromPath = (pathname, languages, localePathRedirect)=>{
         detected: false
     };
 };
-const shouldIgnoreRedirect = (pathname, languages, ignoreRedirectRoutes)=>{
-    if (!ignoreRedirectRoutes) return false;
-    const segments = pathname.split('/').filter(Boolean);
-    let pathWithoutLang = pathname;
-    if (segments.length > 0 && languages.includes(segments[0])) pathWithoutLang = `/${segments.slice(1).join('/')}`;
-    const normalizedPath = pathWithoutLang.startsWith('/') ? pathWithoutLang : `/${pathWithoutLang}`;
-    if ('function' == typeof ignoreRedirectRoutes) return ignoreRedirectRoutes(normalizedPath);
-    return ignoreRedirectRoutes.some((pattern)=>normalizedPath === pattern || normalizedPath.startsWith(`${pattern}/`));
-};
+const shouldIgnoreRedirect = (pathname, languages, ignoreRedirectRoutes)=>shouldSkipLocaleRedirect(pathname, languages, ignoreRedirectRoutes);
 export { buildLocalizedUrl, detectLanguageFromPath, getEntryPath, getLanguageFromPath, getPathname, shouldIgnoreRedirect, splitUrlTarget };

package/dist/esm/server/index.mjs

@@ -3,8 +3,8 @@ import { getLocaleDetectionOptions } from "../shared/utils.mjs";
 import { collectApiPrefixes, matchesApiPrefix } from "./apiPrefix.mjs";
 import { convertToHonoLanguageDetectorOptions } from "./detectorOptions.mjs";
 import { buildLocalizedUrl, createLocaleRedirectResponse, getLanguageFromPath, isStaticResourceRequest, shouldIgnoreRedirect } from "./redirectPolicy.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;
+import * as __rspack_external__modern_js_server_core_hono_0af3baa7 from "@modern-js/server-core/hono";
+const { languageDetector: languageDetector } = __rspack_external__modern_js_server_core_hono_0af3baa7;
 const i18nServerPlugin = (options)=>({
         name: '@modern-js/plugin-i18n/server',
         setup: (api)=>{

package/dist/esm/server/redirectPolicy.mjs

@@ -1,31 +1,25 @@
-import { localiseTargetPathname } from "../shared/localisedUrls.mjs";
-const shouldIgnoreRedirect = (pathname, urlPath, ignoreRedirectRoutes)=>{
-    if (!ignoreRedirectRoutes) return false;
+import { isDefaultLocaleRedirectSkipPath, localiseTargetPathname, matchesPathPrefix, shouldSkipLocaleRedirect, stripLanguagePrefix } from "../shared/localisedUrls.mjs";
+const stripUrlPathPrefix = (pathname, urlPath)=>{
     const basePath = urlPath.replace('/*', '');
+    if (!basePath || '/' === basePath) return pathname;
     const remainingPath = pathname.startsWith(basePath) ? pathname.slice(basePath.length) : pathname;
-    const normalizedPath = remainingPath.startsWith('/') ? remainingPath : `/${remainingPath}`;
-    if ('function' == typeof ignoreRedirectRoutes) return ignoreRedirectRoutes(normalizedPath);
-    return ignoreRedirectRoutes.some((pattern)=>normalizedPath === pattern || normalizedPath.startsWith(`${pattern}/`));
+    return remainingPath || '/';
+};
+const shouldIgnoreRedirect = (pathname, urlPath, ignoreRedirectRoutes)=>{
+    const remainingPath = stripUrlPathPrefix(pathname, urlPath);
+    return shouldSkipLocaleRedirect(remainingPath, [], ignoreRedirectRoutes);
 };
 const isStaticResourceRequest = (pathname, staticRoutePrefixes, languages = [])=>{
-    if (staticRoutePrefixes.some((prefix)=>pathname.startsWith(`${prefix}/`) || pathname === prefix)) return true;
-    const standardStaticPrefixes = [
-        '/static/',
-        '/upload/'
-    ];
-    if (standardStaticPrefixes.some((prefix)=>pathname.startsWith(prefix))) return true;
-    const pathSegments = pathname.split('/').filter(Boolean);
-    if (pathSegments.length > 0 && languages.includes(pathSegments[0])) {
-        const pathWithoutLang = '/' + pathSegments.slice(1).join('/');
-        if (standardStaticPrefixes.some((prefix)=>pathWithoutLang.startsWith(prefix)) || staticRoutePrefixes.some((prefix)=>pathWithoutLang.startsWith(`${prefix}/`) || pathWithoutLang === prefix)) return true;
-    }
-    return false;
+    if (isDefaultLocaleRedirectSkipPath(pathname, languages)) return true;
+    const matchesStaticRoutePrefix = (targetPathname)=>staticRoutePrefixes.some((prefix)=>matchesPathPrefix(targetPathname, prefix));
+    if (matchesStaticRoutePrefix(pathname)) return true;
+    const pathWithoutLanguage = stripLanguagePrefix(pathname, languages);
+    return pathWithoutLanguage !== pathname && matchesStaticRoutePrefix(pathWithoutLanguage);
 };
 const getLanguageFromPath = (req, urlPath, languages)=>{
     const url = new URL(req.url, `http://${req.header().host}`);
     const pathname = url.pathname;
-    const basePath = urlPath.replace('/*', '');
-    const remainingPath = pathname.startsWith(basePath) ? pathname.slice(basePath.length) : pathname;
+    const remainingPath = stripUrlPathPrefix(pathname, urlPath);
     const segments = remainingPath.split('/').filter(Boolean);
     const firstSegment = segments[0];
     if (languages.includes(firstSegment)) return firstSegment;
@@ -35,7 +29,7 @@ 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 remainingPath = stripUrlPathPrefix(pathname, urlPath);
     const newPathname = localiseTargetPathname(remainingPath, language, languages, localisedUrls);
     const suffix = `${url.search}${url.hash}`;
     const localizedUrl = '/' === basePath ? newPathname + suffix : basePath + newPathname + suffix;

package/dist/esm/shared/detection.mjs

@@ -1,71 +1 @@
-import { DEFAULT_I18NEXT_DETECTION_OPTIONS, mergeDetectionOptions } from "../runtime/i18n/detection/config.mjs";
-function detectLanguageFromRequest(req, languages, detectionOptions) {
-    try {
-        const mergedDetection = detectionOptions ? mergeDetectionOptions(detectionOptions) : DEFAULT_I18NEXT_DETECTION_OPTIONS;
-        const order = (mergedDetection.order || []).filter((item)=>![
-                'path',
-                'localStorage',
-                'navigator',
-                'htmlTag',
-                'subdomain'
-            ].includes(item));
-        const detectionOrder = order.length > 0 ? order : [
-            'querystring',
-            'cookie',
-            'header'
-        ];
-        const getHeader = (name)=>{
-            req.headers, Headers;
-            return req.headers.get(name);
-        };
-        for (const method of detectionOrder){
-            let detectedLang = null;
-            switch(method){
-                case 'querystring':
-                    {
-                        const lookupKey = mergedDetection.lookupQuerystring || DEFAULT_I18NEXT_DETECTION_OPTIONS.lookupQuerystring || 'lng';
-                        const host = getHeader('host') || 'localhost';
-                        const url = new URL(req.url, `http://${host}`);
-                        detectedLang = url.searchParams.get(lookupKey);
-                        break;
-                    }
-                case 'cookie':
-                    {
-                        const lookupKey = mergedDetection.lookupCookie || DEFAULT_I18NEXT_DETECTION_OPTIONS.lookupCookie || 'i18next';
-                        const cookieHeader = getHeader('Cookie');
-                        if (cookieHeader) {
-                            const cookies = cookieHeader.split(';').reduce((acc, item)=>{
-                                const [key, value] = item.trim().split('=');
-                                if (key && value) acc[key] = value;
-                                return acc;
-                            }, {});
-                            detectedLang = cookies[lookupKey] || null;
-                        }
-                        break;
-                    }
-                case 'header':
-                    {
-                        const lookupKey = mergedDetection.lookupHeader || DEFAULT_I18NEXT_DETECTION_OPTIONS.lookupHeader || 'accept-language';
-                        const acceptLanguage = getHeader(lookupKey);
-                        if (acceptLanguage) {
-                            const languagesList = acceptLanguage.split(',').map((lang)=>{
-                                const [code, q] = lang.trim().split(';');
-                                return {
-                                    code: code.split('-')[0],
-                                    quality: q ? parseFloat(q.split('=')[1]) : 1.0
-                                };
-                            }).sort((a, b)=>b.quality - a.quality);
-                            for (const lang of languagesList)if (0 === languages.length || languages.includes(lang.code)) {
-                                detectedLang = lang.code;
-                                break;
-                            }
-                        }
-                        break;
-                    }
-            }
-            if (detectedLang && (0 === languages.length || languages.includes(detectedLang))) return detectedLang;
-        }
-    } catch (error) {}
-    return null;
-}
-export { detectLanguageFromRequest };
+import "../runtime/i18n/detection/config.mjs";

package/dist/esm/shared/localisedUrls/index.mjs

@@ -1,6 +1,7 @@
 export { resolveLocalisedUrlsConfig } from "./config.mjs";
 export { normalisePathPattern, normalisePathname } from "./normalise.mjs";
-export { canonicalTargetPathname, localiseTargetPathname } from "./pathname.mjs";
+export { canonicalTargetPathname, localiseTargetPathname, stripLanguagePrefix } from "./pathname.mjs";
 export { buildPathFromPattern, matchPathPattern } from "./patterns.mjs";
+export { DEFAULT_LOCALE_REDIRECT_SKIP_RULES, isDefaultLocaleRedirectSkipPath, matchesPathPrefix, shouldSkipLocaleRedirect } from "./redirect.mjs";
 export { resolveCanonicalLocalisedPath, resolveLocalisedPath } from "./resolve.mjs";
 export { applyLocalisedUrlsToRoutes, validateLocalisedUrls } from "./routes.mjs";

package/dist/esm/shared/localisedUrls/pathname.mjs

@@ -21,4 +21,4 @@ const canonicalTargetPathname = (pathname, languages, localisedUrls)=>{
     const localisedUrlsConfig = resolveLocalisedUrlsConfig(localisedUrls);
     return localisedUrlsConfig.enabled ? resolveCanonicalLocalisedPath(pathWithoutLanguage, languages, localisedUrlsConfig.map) : pathWithoutLanguage;
 };
-export { canonicalTargetPathname, localiseTargetPathname };
+export { canonicalTargetPathname, localiseTargetPathname, stripLanguagePrefix };

package/dist/esm/shared/localisedUrls/redirect.mjs

@@ -0,0 +1,48 @@
+import { normalisePathname } from "./normalise.mjs";
+import { stripLanguagePrefix } from "./pathname.mjs";
+const DEFAULT_LOCALE_REDIRECT_SKIP_RULES = [
+    {
+        type: 'exact',
+        path: '/mf-manifest.json'
+    },
+    {
+        type: 'exact',
+        path: '/mf-stats.json'
+    },
+    {
+        type: 'exact',
+        path: '/remoteEntry.js'
+    },
+    {
+        type: 'prefix',
+        path: '/static/'
+    },
+    {
+        type: 'prefix',
+        path: '/upload/'
+    }
+];
+const stripTrailingSlash = (pathname)=>pathname.length > 1 ? pathname.replace(/\/+$/, '') : pathname;
+const matchesPathPrefix = (pathname, prefix)=>{
+    const normalizedPathname = normalisePathname(pathname);
+    const normalizedPrefix = stripTrailingSlash(normalisePathname(prefix));
+    return normalizedPathname === normalizedPrefix || normalizedPathname.startsWith(`${normalizedPrefix}/`);
+};
+const matchesSkipRule = (pathname, rule)=>{
+    if ('exact' === rule.type) return normalisePathname(pathname) === normalisePathname(rule.path);
+    return matchesPathPrefix(pathname, rule.path);
+};
+const isDefaultLocaleRedirectSkipPath = (pathname, languages = [])=>{
+    const normalizedPathname = normalisePathname(pathname);
+    const pathWithoutLanguage = stripLanguagePrefix(normalizedPathname, languages);
+    return DEFAULT_LOCALE_REDIRECT_SKIP_RULES.some((rule)=>matchesSkipRule(pathWithoutLanguage, rule));
+};
+const shouldSkipLocaleRedirect = (pathname, languages = [], ignoreRedirectRoutes)=>{
+    const normalizedPathname = normalisePathname(pathname);
+    const pathWithoutLanguage = stripLanguagePrefix(normalizedPathname, languages);
+    if (isDefaultLocaleRedirectSkipPath(pathWithoutLanguage)) return true;
+    if (!ignoreRedirectRoutes) return false;
+    if ('function' == typeof ignoreRedirectRoutes) return ignoreRedirectRoutes(pathWithoutLanguage);
+    return ignoreRedirectRoutes.some((pattern)=>matchesPathPrefix(pathWithoutLanguage, pattern));
+};
+export { DEFAULT_LOCALE_REDIRECT_SKIP_RULES, isDefaultLocaleRedirectSkipPath, matchesPathPrefix, shouldSkipLocaleRedirect };

package/dist/esm/shared/localisedUrls/resolve.mjs

@@ -1,50 +1,47 @@
 import { normalisePathname } from "./normalise.mjs";
 import { buildPathFromPattern, matchPathPattern, sortPatternsBySpecificity } from "./patterns.mjs";
-const resolveLocalisedPath = (pathname, targetLanguage, languages, localisedUrls)=>{
-    const normalizedPathname = normalisePathname(pathname);
-    const canonicalCandidates = sortPatternsBySpecificity(Object.entries(localisedUrls).map(([canonicalPattern, localisedUrlEntry])=>({
+const getCanonicalCandidates = (localisedUrls)=>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);
-    }
-    const localisedCandidates = sortPatternsBySpecificity(Object.values(localisedUrls).flatMap((localisedUrlEntry)=>{
-        const targetPattern = localisedUrlEntry[targetLanguage];
-        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 resolveLocalisedUrlPath = (pathname, languages, localisedUrls, options)=>{
     const normalizedPathname = normalisePathname(pathname);
-    const canonicalCandidates = sortPatternsBySpecificity(Object.entries(localisedUrls).map(([canonicalPattern, localisedUrlEntry])=>({
-            pattern: canonicalPattern,
-            canonicalPattern,
-            localisedUrlEntry
-        })));
+    const canonicalCandidates = getCanonicalCandidates(localisedUrls);
     for (const { canonicalPattern, localisedUrlEntry } of canonicalCandidates){
+        const targetPattern = 'localised' === options.mode ? localisedUrlEntry[options.targetLanguage] : canonicalPattern;
+        if (!targetPattern) continue;
         const canonicalParams = matchPathPattern(normalizedPathname, canonicalPattern);
-        if (canonicalParams) return buildPathFromPattern(canonicalPattern, canonicalParams);
-        for (const language of languages){
+        if (canonicalParams) return buildPathFromPattern(targetPattern, canonicalParams);
+        if ('canonical' === options.mode) for (const language of languages){
             const sourcePattern = localisedUrlEntry[language];
             if (!sourcePattern) continue;
             const params = matchPathPattern(normalizedPathname, sourcePattern);
             if (params) return buildPathFromPattern(canonicalPattern, params);
         }
     }
+    if ('localised' === options.mode) {
+        const localisedCandidates = sortPatternsBySpecificity(Object.values(localisedUrls).flatMap((localisedUrlEntry)=>{
+            const targetPattern = localisedUrlEntry[options.targetLanguage];
+            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 resolveLocalisedPath = (pathname, targetLanguage, languages, localisedUrls)=>resolveLocalisedUrlPath(pathname, languages, localisedUrls, {
+        mode: 'localised',
+        targetLanguage
+    });
+const resolveCanonicalLocalisedPath = (pathname, languages, localisedUrls)=>resolveLocalisedUrlPath(pathname, languages, localisedUrls, {
+        mode: 'canonical'
+    });
 export { resolveCanonicalLocalisedPath, resolveLocalisedPath };

package/dist/esm/shared/localisedUrls.mjs

@@ -1 +1 @@
-export { applyLocalisedUrlsToRoutes, buildPathFromPattern, canonicalTargetPathname, localiseTargetPathname, matchPathPattern, normalisePathPattern, normalisePathname, resolveCanonicalLocalisedPath, resolveLocalisedPath, resolveLocalisedUrlsConfig, validateLocalisedUrls } from "./localisedUrls/index.mjs";
+export { DEFAULT_LOCALE_REDIRECT_SKIP_RULES, applyLocalisedUrlsToRoutes, buildPathFromPattern, canonicalTargetPathname, isDefaultLocaleRedirectSkipPath, localiseTargetPathname, matchPathPattern, matchesPathPrefix, normalisePathPattern, normalisePathname, resolveCanonicalLocalisedPath, resolveLocalisedPath, resolveLocalisedUrlsConfig, shouldSkipLocaleRedirect, stripLanguagePrefix, validateLocalisedUrls } from "./localisedUrls/index.mjs";

package/dist/esm/shared/utils.mjs

@@ -32,4 +32,4 @@ function getBackendOptions(entryName, backend) {
     if ('backendOptionsByEntry' in fullConfig) return removeEntryConfigKey(fullConfig, 'backendOptionsByEntry');
     return backend;
 }
-export { getBackendOptions, getEntryConfig, getLocaleDetectionOptions, removeEntryConfigKey };
+export { getBackendOptions, getLocaleDetectionOptions };

package/dist/esm-node/cli/locales.mjs

@@ -1,15 +1,15 @@
 import "node:module";
+import node_fs from "node:fs";
+import node_path from "node:path";
 import { getPublicDirRoutePrefixes, normalizePublicDir, normalizePublicDirPath } from "@modern-js/server-core";
-import fs from "fs";
-import path from "path";
 const LOCALES_RESOURCE_PATTERN = '{{lng}}/{{ns}}.json';
 function hasJsonFiles(dirPath) {
     try {
-        if (!fs.existsSync(dirPath) || !fs.statSync(dirPath).isDirectory()) return false;
-        const entries = fs.readdirSync(dirPath);
+        if (!node_fs.existsSync(dirPath) || !node_fs.statSync(dirPath).isDirectory()) return false;
+        const entries = node_fs.readdirSync(dirPath);
         for (const entry of entries){
-            const entryPath = path.join(dirPath, entry);
-            const stat = fs.statSync(entryPath);
+            const entryPath = node_path.join(dirPath, entry);
+            const stat = node_fs.statSync(entryPath);
             if (stat.isFile() && entry.endsWith('.json')) return true;
             if (stat.isDirectory() && hasJsonFiles(entryPath)) return true;
         }
@@ -19,7 +19,7 @@ function hasJsonFiles(dirPath) {
     }
 }
 function toPosixPath(filePath) {
-    return filePath.split(path.sep).join(path.posix.sep);
+    return filePath.split(node_path.sep).join(node_path.posix.sep);
 }
 function getPublicDirOutputPath(publicDir) {
     return normalizePublicDirPath(publicDir);
@@ -46,20 +46,20 @@ function detectLocalesDirectory(appDirectory, normalizedConfig) {
     const publicDirPrefixes = getPublicDirRoutePrefixes(normalizedConfig?.server?.publicDir);
     for(let index = 0; index < publicDirs.length; index++){
         const publicDir = publicDirs[index];
-        if (path.isAbsolute(publicDir)) continue;
-        const publicDirPath = path.join(appDirectory, publicDir);
+        if (node_path.isAbsolute(publicDir)) continue;
+        const publicDirPath = node_path.join(appDirectory, publicDir);
         const publicDirPrefix = publicDirPrefixes[index] || `/${normalizePublicDirPath(publicDir)}`;
         const publicDirOutputPath = getPublicDirOutputPath(publicDir);
-        if ('locales' === path.basename(normalizePublicDirPath(publicDir)) && hasJsonFiles(publicDirPath)) return buildDetectedLocalesDirectory(publicDirPrefix, `./${publicDirOutputPath}`);
-        const localesPath = path.join(publicDirPath, 'locales');
+        if ('locales' === node_path.basename(normalizePublicDirPath(publicDir)) && hasJsonFiles(publicDirPath)) return buildDetectedLocalesDirectory(publicDirPrefix, `./${publicDirOutputPath}`);
+        const localesPath = node_path.join(publicDirPath, 'locales');
         if (hasJsonFiles(localesPath)) return buildDetectedLocalesDirectory(`${publicDirPrefix}/locales`, `./${publicDirOutputPath}/locales`);
     }
-    const configPublicPath = path.join(appDirectory, 'config', 'public', 'locales');
+    const configPublicPath = node_path.join(appDirectory, 'config', 'public', 'locales');
     if (hasJsonFiles(configPublicPath)) return buildDetectedLocalesDirectory('/locales', './public/locales', [
         './config/public/locales',
         './public/locales'
     ]);
-    const rootLocalesPath = path.join(appDirectory, 'locales');
+    const rootLocalesPath = node_path.join(appDirectory, 'locales');
     if (hasJsonFiles(rootLocalesPath)) return buildDetectedLocalesDirectory('/locales', './locales');
 }
 function applyDetectedBackendPaths(backendOptions, detectedLocales) {

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

@@ -1,19 +1,19 @@
 import "node:module";
-import fs from "fs";
-import path_0 from "path";
+import node_fs from "node:fs";
+import node_path from "node:path";
 const CONVENTIONAL_LOCALES_DIRS = [
     './locales',
     './config/public/locales'
 ];
 const isDirectory = (dirPath)=>{
     try {
-        return fs.statSync(dirPath).isDirectory();
+        return node_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;
+    for (const dir of CONVENTIONAL_LOCALES_DIRS)if (isDirectory(node_path.resolve(cwd, dir))) return dir;
     return CONVENTIONAL_LOCALES_DIRS[0];
 };
 const DEFAULT_I18NEXT_BACKEND_OPTIONS = {
@@ -39,7 +39,7 @@ function getResourceBasePath(resourcePath) {
 }
 function pathExists(resourcePath) {
     try {
-        return fs.existsSync(getResourceBasePath(resourcePath));
+        return node_fs.existsSync(getResourceBasePath(resourcePath));
     } catch  {
         return false;
     }