@bleedingdev/modern-js-i18n-runtime-extensions 3.9.0-ultramodern.2 → 3.9.0-ultramodern.21

package/dist/cjs/index.js

@@ -6,8 +6,11 @@ var __webpack_modules__ = {
     "./language-sync/react" (module) {
         module.exports = require("./language-sync/react.js");
     },
-    "./localisedUrls/index" (module) {
-        module.exports = require("./localisedUrls/index.js");
+    "./localeRedirectPolicy" (module) {
+        module.exports = require("./localeRedirectPolicy.js");
+    },
+    "@modern-js/runtime-extensions/localised-urls" (module) {
+        module.exports = require("@modern-js/runtime-extensions/localised-urls");
     }
 };
 var __webpack_module_cache__ = {};
@@ -57,17 +60,21 @@ function __webpack_require__(moduleId) {
 var __webpack_exports__ = {};
 (()=>{
     __webpack_require__.r(__webpack_exports__);
-    var _language_sync_controller__rspack_import_0 = __webpack_require__("./language-sync/controller");
+    var _modern_js_runtime_extensions_localised_urls__rspack_import_0 = __webpack_require__("@modern-js/runtime-extensions/localised-urls");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _modern_js_runtime_extensions_localised_urls__rspack_import_0)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_modern_js_runtime_extensions_localised_urls__rspack_import_0[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _language_sync_controller__rspack_import_1 = __webpack_require__("./language-sync/controller");
     var __rspack_reexport = {};
-    for(const __rspack_import_key in _language_sync_controller__rspack_import_0)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_language_sync_controller__rspack_import_0[__rspack_import_key];
+    for(const __rspack_import_key in _language_sync_controller__rspack_import_1)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_language_sync_controller__rspack_import_1[__rspack_import_key];
     __webpack_require__.d(__webpack_exports__, __rspack_reexport);
-    var _language_sync_react__rspack_import_1 = __webpack_require__("./language-sync/react");
+    var _language_sync_react__rspack_import_2 = __webpack_require__("./language-sync/react");
     var __rspack_reexport = {};
-    for(const __rspack_import_key in _language_sync_react__rspack_import_1)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_language_sync_react__rspack_import_1[__rspack_import_key];
+    for(const __rspack_import_key in _language_sync_react__rspack_import_2)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_language_sync_react__rspack_import_2[__rspack_import_key];
     __webpack_require__.d(__webpack_exports__, __rspack_reexport);
-    var _localisedUrls_index__rspack_import_2 = __webpack_require__("./localisedUrls/index");
+    var _localeRedirectPolicy__rspack_import_3 = __webpack_require__("./localeRedirectPolicy");
     var __rspack_reexport = {};
-    for(const __rspack_import_key in _localisedUrls_index__rspack_import_2)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_localisedUrls_index__rspack_import_2[__rspack_import_key];
+    for(const __rspack_import_key in _localeRedirectPolicy__rspack_import_3)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_localeRedirectPolicy__rspack_import_3[__rspack_import_key];
     __webpack_require__.d(__webpack_exports__, __rspack_reexport);
 })();
 for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];

package/dist/cjs/localeRedirectPolicy.js

@@ -0,0 +1,96 @@
+"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__);
+__webpack_require__.d(__webpack_exports__, {
+    buildLocalizedUrl: ()=>buildLocalizedUrl,
+    createLocaleRedirectResponse: ()=>createLocaleRedirectResponse,
+    getLanguageFromPath: ()=>getLanguageFromPath,
+    isStaticResourceRequest: ()=>isStaticResourceRequest,
+    shouldIgnoreRedirect: ()=>shouldIgnoreRedirect
+});
+const localised_urls_namespaceObject = require("@modern-js/runtime-extensions/localised-urls");
+const stripUrlPathPrefix = (pathname, urlPath)=>{
+    const basePath = urlPath.replace('/*', '');
+    if (!basePath || '/' === basePath) return pathname;
+    const remainingPath = pathname.startsWith(basePath) ? pathname.slice(basePath.length) : pathname;
+    return remainingPath || '/';
+};
+const shouldIgnoreRedirect = (pathname, urlPath, ignoreRedirectRoutes)=>{
+    const remainingPath = stripUrlPathPrefix(pathname, urlPath);
+    return (0, localised_urls_namespaceObject.shouldSkipLocaleRedirect)(remainingPath, [], ignoreRedirectRoutes);
+};
+const isStaticResourceRequest = (pathname, staticRoutePrefixes, languages = [])=>{
+    if ((0, localised_urls_namespaceObject.isDefaultLocaleRedirectSkipPath)(pathname, languages)) return true;
+    const matchesStaticRoutePrefix = (targetPathname)=>staticRoutePrefixes.some((prefix)=>(0, localised_urls_namespaceObject.matchesPathPrefix)(targetPathname, prefix));
+    if (matchesStaticRoutePrefix(pathname)) return true;
+    const pathWithoutLanguage = (0, localised_urls_namespaceObject.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 remainingPath = stripUrlPathPrefix(pathname, urlPath);
+    const segments = remainingPath.split('/').filter(Boolean);
+    const firstSegment = segments[0];
+    if (languages.includes(firstSegment)) return firstSegment;
+    return null;
+};
+const buildLocalizedUrl = (req, urlPath, language, languages, localisedUrls)=>{
+    const url = new URL(req.url);
+    const pathname = url.pathname;
+    const basePath = urlPath.replace('/*', '');
+    const remainingPath = stripUrlPathPrefix(pathname, urlPath);
+    const newPathname = (0, localised_urls_namespaceObject.localiseTargetPathname)(remainingPath, language, languages, localisedUrls);
+    const suffix = `${url.search}${url.hash}`;
+    const localizedUrl = '/' === basePath ? newPathname + suffix : basePath + newPathname + suffix;
+    return localizedUrl;
+};
+const createLocaleRedirectResponse = (location)=>new Response(null, {
+        status: 302,
+        headers: {
+            'Cache-Control': 'private, no-store',
+            Location: location,
+            Vary: 'Accept-Language, Cookie'
+        }
+    });
+exports.buildLocalizedUrl = __webpack_exports__.buildLocalizedUrl;
+exports.createLocaleRedirectResponse = __webpack_exports__.createLocaleRedirectResponse;
+exports.getLanguageFromPath = __webpack_exports__.getLanguageFromPath;
+exports.isStaticResourceRequest = __webpack_exports__.isStaticResourceRequest;
+exports.shouldIgnoreRedirect = __webpack_exports__.shouldIgnoreRedirect;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "buildLocalizedUrl",
+    "createLocaleRedirectResponse",
+    "getLanguageFromPath",
+    "isStaticResourceRequest",
+    "shouldIgnoreRedirect"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/paths.js

@@ -0,0 +1,56 @@
+"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__);
+__webpack_require__.d(__webpack_exports__, {
+    buildLocalizedUrl: ()=>buildLocalizedUrl,
+    canonicalPath: ()=>canonicalPath,
+    localizePath: ()=>localizePath
+});
+const localised_urls_namespaceObject = require("@modern-js/runtime-extensions/localised-urls");
+const url_namespaceObject = require("@modern-js/runtime-utils/url");
+const buildLocalizedUrl = (target, language, languages, localisedUrls)=>{
+    const { pathname, search, hash } = (0, url_namespaceObject.splitUrlTarget)(target);
+    return `${(0, localised_urls_namespaceObject.localiseTargetPathname)(pathname, language, languages, localisedUrls)}${search}${hash}`;
+};
+const localizePath = (target, language, config)=>buildLocalizedUrl(target, language, config.languages, config.localisedUrls);
+const canonicalPath = (target, config)=>{
+    const { pathname, search, hash } = (0, url_namespaceObject.splitUrlTarget)(target);
+    return `${(0, localised_urls_namespaceObject.canonicalTargetPathname)(pathname, config.languages, config.localisedUrls)}${search}${hash}`;
+};
+exports.buildLocalizedUrl = __webpack_exports__.buildLocalizedUrl;
+exports.canonicalPath = __webpack_exports__.canonicalPath;
+exports.localizePath = __webpack_exports__.localizePath;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "buildLocalizedUrl",
+    "canonicalPath",
+    "localizePath"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/router-navigation/adapter.js

@@ -0,0 +1,93 @@
+"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__);
+__webpack_require__.d(__webpack_exports__, {
+    createI18nRouterNavigation: ()=>createI18nRouterNavigation
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const runtime_namespaceObject = require("@modern-js/runtime");
+const context_namespaceObject = require("@modern-js/runtime/context");
+const router_state_namespaceObject = require("@modern-js/runtime-extensions/router-state");
+const external_react_namespaceObject = require("react");
+const subscribeNone = ()=>()=>{};
+const getEmptySnapshot = ()=>null;
+const createI18nRouterNavigation = ({ I18nNavigationProvider, useNativeI18nRouterAdapter })=>{
+    const NavigationProvider = I18nNavigationProvider;
+    const useIntegratedRouterAdapter = ()=>{
+        const runtimeContext = (0, external_react_namespaceObject.useContext)(runtime_namespaceObject.RuntimeContext);
+        const internalContext = (0, external_react_namespaceObject.useContext)(context_namespaceObject.InternalRuntimeContext);
+        const native = useNativeI18nRouterAdapter();
+        const getCapability = (0, external_react_namespaceObject.useCallback)(()=>(0, router_state_namespaceObject.getRouterRuntimeState)(internalContext)?.navigation ?? (0, router_state_namespaceObject.getRouterRuntimeState)(runtimeContext)?.navigation, [
+            internalContext,
+            runtimeContext
+        ]);
+        const subscribeCapability = (0, external_react_namespaceObject.useCallback)((update)=>{
+            const stopInternal = (0, router_state_namespaceObject.subscribeRouterRuntimeState)(internalContext, update);
+            const stopPublic = internalContext === runtimeContext ? void 0 : (0, router_state_namespaceObject.subscribeRouterRuntimeState)(runtimeContext, update);
+            return ()=>{
+                stopInternal();
+                stopPublic?.();
+            };
+        }, [
+            internalContext,
+            runtimeContext
+        ]);
+        const capability = (0, external_react_namespaceObject.useSyncExternalStore)(subscribeCapability, getCapability, getCapability);
+        const snapshot = (0, external_react_namespaceObject.useSyncExternalStore)(capability?.subscribe ?? subscribeNone, capability?.getSnapshot ?? getEmptySnapshot, capability?.getSnapshot ?? getEmptySnapshot);
+        if (native.hasRouter || !capability || !snapshot) return native;
+        const internalState = (0, router_state_namespaceObject.getRouterRuntimeState)(internalContext);
+        return {
+            framework: internalState?.navigation === capability ? internalState.framework : (0, router_state_namespaceObject.getRouterRuntimeState)(runtimeContext)?.framework,
+            hasRouter: true,
+            ...snapshot,
+            navigate: capability.navigate,
+            Link: capability.Link,
+            createLinkProps: capability.createLinkProps
+        };
+    };
+    const I18nRouterNavigationProvider = ({ children })=>{
+        const value = useIntegratedRouterAdapter();
+        const native = useNativeI18nRouterAdapter();
+        return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(NavigationProvider, {
+            value: value.hasRouter && !native.hasRouter ? value : null,
+            children: children
+        });
+    };
+    return {
+        useIntegratedRouterAdapter,
+        I18nRouterNavigationProvider
+    };
+};
+exports.createI18nRouterNavigation = __webpack_exports__.createI18nRouterNavigation;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createI18nRouterNavigation"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/{localisedUrls/config.js → router-navigation/index.js}

@@ -27,22 +27,13 @@ var __webpack_require__ = {};
 })();
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
-const resolveLocalisedUrlsConfig = (option)=>{
-    if (option && 'object' == typeof option && Object.keys(option).length > 0) return {
-        enabled: true,
-        map: option
-    };
-    return {
-        enabled: false,
-        map: {}
-    };
-};
-__webpack_require__.d(__webpack_exports__, {}, {
-    resolveLocalisedUrlsConfig: resolveLocalisedUrlsConfig
+__webpack_require__.d(__webpack_exports__, {
+    createI18nRouterNavigation: ()=>external_adapter_js_namespaceObject.createI18nRouterNavigation
 });
-exports.resolveLocalisedUrlsConfig = __webpack_exports__.resolveLocalisedUrlsConfig;
+const external_adapter_js_namespaceObject = require("./adapter.js");
+exports.createI18nRouterNavigation = __webpack_exports__.createI18nRouterNavigation;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "resolveLocalisedUrlsConfig"
+    "createI18nRouterNavigation"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true

package/dist/esm/index.mjs

@@ -1,3 +1,4 @@
+export * from "@modern-js/runtime-extensions/localised-urls";
 export * from "./language-sync/controller.mjs";
 export * from "./language-sync/react.mjs";
-export * from "./localisedUrls/index.mjs";
+export * from "./localeRedirectPolicy.mjs";

package/dist/esm/localeRedirectPolicy.mjs

@@ -0,0 +1,46 @@
+import { isDefaultLocaleRedirectSkipPath, localiseTargetPathname, matchesPathPrefix, shouldSkipLocaleRedirect, stripLanguagePrefix } from "@modern-js/runtime-extensions/localised-urls";
+const stripUrlPathPrefix = (pathname, urlPath)=>{
+    const basePath = urlPath.replace('/*', '');
+    if (!basePath || '/' === basePath) return pathname;
+    const remainingPath = pathname.startsWith(basePath) ? pathname.slice(basePath.length) : pathname;
+    return remainingPath || '/';
+};
+const shouldIgnoreRedirect = (pathname, urlPath, ignoreRedirectRoutes)=>{
+    const remainingPath = stripUrlPathPrefix(pathname, urlPath);
+    return shouldSkipLocaleRedirect(remainingPath, [], ignoreRedirectRoutes);
+};
+const isStaticResourceRequest = (pathname, staticRoutePrefixes, languages = [])=>{
+    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 remainingPath = stripUrlPathPrefix(pathname, urlPath);
+    const segments = remainingPath.split('/').filter(Boolean);
+    const firstSegment = segments[0];
+    if (languages.includes(firstSegment)) return firstSegment;
+    return null;
+};
+const buildLocalizedUrl = (req, urlPath, language, languages, localisedUrls)=>{
+    const url = new URL(req.url);
+    const pathname = url.pathname;
+    const basePath = urlPath.replace('/*', '');
+    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;
+    return localizedUrl;
+};
+const createLocaleRedirectResponse = (location)=>new Response(null, {
+        status: 302,
+        headers: {
+            'Cache-Control': 'private, no-store',
+            Location: location,
+            Vary: 'Accept-Language, Cookie'
+        }
+    });
+export { buildLocalizedUrl, createLocaleRedirectResponse, getLanguageFromPath, isStaticResourceRequest, shouldIgnoreRedirect };

package/dist/esm/paths.mjs

@@ -0,0 +1,12 @@
+import { canonicalTargetPathname, localiseTargetPathname } from "@modern-js/runtime-extensions/localised-urls";
+import { splitUrlTarget } from "@modern-js/runtime-utils/url";
+const buildLocalizedUrl = (target, language, languages, localisedUrls)=>{
+    const { pathname, search, hash } = splitUrlTarget(target);
+    return `${localiseTargetPathname(pathname, language, languages, localisedUrls)}${search}${hash}`;
+};
+const localizePath = (target, language, config)=>buildLocalizedUrl(target, language, config.languages, config.localisedUrls);
+const canonicalPath = (target, config)=>{
+    const { pathname, search, hash } = splitUrlTarget(target);
+    return `${canonicalTargetPathname(pathname, config.languages, config.localisedUrls)}${search}${hash}`;
+};
+export { buildLocalizedUrl, canonicalPath, localizePath };

package/dist/esm/router-navigation/adapter.mjs

@@ -0,0 +1,55 @@
+import { jsx } from "react/jsx-runtime";
+import { RuntimeContext } from "@modern-js/runtime";
+import { InternalRuntimeContext } from "@modern-js/runtime/context";
+import { getRouterRuntimeState, subscribeRouterRuntimeState } from "@modern-js/runtime-extensions/router-state";
+import { useCallback, useContext, useSyncExternalStore } from "react";
+const subscribeNone = ()=>()=>{};
+const getEmptySnapshot = ()=>null;
+const createI18nRouterNavigation = ({ I18nNavigationProvider, useNativeI18nRouterAdapter })=>{
+    const NavigationProvider = I18nNavigationProvider;
+    const useIntegratedRouterAdapter = ()=>{
+        const runtimeContext = useContext(RuntimeContext);
+        const internalContext = useContext(InternalRuntimeContext);
+        const native = useNativeI18nRouterAdapter();
+        const getCapability = useCallback(()=>getRouterRuntimeState(internalContext)?.navigation ?? getRouterRuntimeState(runtimeContext)?.navigation, [
+            internalContext,
+            runtimeContext
+        ]);
+        const subscribeCapability = useCallback((update)=>{
+            const stopInternal = subscribeRouterRuntimeState(internalContext, update);
+            const stopPublic = internalContext === runtimeContext ? void 0 : subscribeRouterRuntimeState(runtimeContext, update);
+            return ()=>{
+                stopInternal();
+                stopPublic?.();
+            };
+        }, [
+            internalContext,
+            runtimeContext
+        ]);
+        const capability = useSyncExternalStore(subscribeCapability, getCapability, getCapability);
+        const snapshot = useSyncExternalStore(capability?.subscribe ?? subscribeNone, capability?.getSnapshot ?? getEmptySnapshot, capability?.getSnapshot ?? getEmptySnapshot);
+        if (native.hasRouter || !capability || !snapshot) return native;
+        const internalState = getRouterRuntimeState(internalContext);
+        return {
+            framework: internalState?.navigation === capability ? internalState.framework : getRouterRuntimeState(runtimeContext)?.framework,
+            hasRouter: true,
+            ...snapshot,
+            navigate: capability.navigate,
+            Link: capability.Link,
+            createLinkProps: capability.createLinkProps
+        };
+    };
+    const I18nRouterNavigationProvider = ({ children })=>{
+        const value = useIntegratedRouterAdapter();
+        const native = useNativeI18nRouterAdapter();
+        return /*#__PURE__*/ jsx(NavigationProvider, {
+            value: value.hasRouter && !native.hasRouter ? value : null,
+            children: children
+        });
+    };
+    return {
+        useIntegratedRouterAdapter,
+        I18nRouterNavigationProvider
+    };
+};
+export { createI18nRouterNavigation };

package/dist/esm/router-navigation/index.mjs

@@ -0,0 +1 @@
+export { createI18nRouterNavigation } from "./adapter.mjs";

package/dist/esm-node/index.mjs

@@ -1,4 +1,5 @@
 import "node:module";
+export * from "@modern-js/runtime-extensions/localised-urls";
 export * from "./language-sync/controller.mjs";
 export * from "./language-sync/react.mjs";
-export * from "./localisedUrls/index.mjs";
+export * from "./localeRedirectPolicy.mjs";

package/dist/esm-node/localeRedirectPolicy.mjs

@@ -0,0 +1,47 @@
+import "node:module";
+import { isDefaultLocaleRedirectSkipPath, localiseTargetPathname, matchesPathPrefix, shouldSkipLocaleRedirect, stripLanguagePrefix } from "@modern-js/runtime-extensions/localised-urls";
+const stripUrlPathPrefix = (pathname, urlPath)=>{
+    const basePath = urlPath.replace('/*', '');
+    if (!basePath || '/' === basePath) return pathname;
+    const remainingPath = pathname.startsWith(basePath) ? pathname.slice(basePath.length) : pathname;
+    return remainingPath || '/';
+};
+const shouldIgnoreRedirect = (pathname, urlPath, ignoreRedirectRoutes)=>{
+    const remainingPath = stripUrlPathPrefix(pathname, urlPath);
+    return shouldSkipLocaleRedirect(remainingPath, [], ignoreRedirectRoutes);
+};
+const isStaticResourceRequest = (pathname, staticRoutePrefixes, languages = [])=>{
+    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 remainingPath = stripUrlPathPrefix(pathname, urlPath);
+    const segments = remainingPath.split('/').filter(Boolean);
+    const firstSegment = segments[0];
+    if (languages.includes(firstSegment)) return firstSegment;
+    return null;
+};
+const buildLocalizedUrl = (req, urlPath, language, languages, localisedUrls)=>{
+    const url = new URL(req.url);
+    const pathname = url.pathname;
+    const basePath = urlPath.replace('/*', '');
+    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;
+    return localizedUrl;
+};
+const createLocaleRedirectResponse = (location)=>new Response(null, {
+        status: 302,
+        headers: {
+            'Cache-Control': 'private, no-store',
+            Location: location,
+            Vary: 'Accept-Language, Cookie'
+        }
+    });
+export { buildLocalizedUrl, createLocaleRedirectResponse, getLanguageFromPath, isStaticResourceRequest, shouldIgnoreRedirect };

package/dist/esm-node/paths.mjs

@@ -0,0 +1,13 @@
+import "node:module";
+import { canonicalTargetPathname, localiseTargetPathname } from "@modern-js/runtime-extensions/localised-urls";
+import { splitUrlTarget } from "@modern-js/runtime-utils/url";
+const buildLocalizedUrl = (target, language, languages, localisedUrls)=>{
+    const { pathname, search, hash } = splitUrlTarget(target);
+    return `${localiseTargetPathname(pathname, language, languages, localisedUrls)}${search}${hash}`;
+};
+const localizePath = (target, language, config)=>buildLocalizedUrl(target, language, config.languages, config.localisedUrls);
+const canonicalPath = (target, config)=>{
+    const { pathname, search, hash } = splitUrlTarget(target);
+    return `${canonicalTargetPathname(pathname, config.languages, config.localisedUrls)}${search}${hash}`;
+};
+export { buildLocalizedUrl, canonicalPath, localizePath };

package/dist/esm-node/router-navigation/adapter.mjs

@@ -0,0 +1,56 @@
+import "node:module";
+import { jsx } from "react/jsx-runtime";
+import { RuntimeContext } from "@modern-js/runtime";
+import { InternalRuntimeContext } from "@modern-js/runtime/context";
+import { getRouterRuntimeState, subscribeRouterRuntimeState } from "@modern-js/runtime-extensions/router-state";
+import { useCallback, useContext, useSyncExternalStore } from "react";
+const subscribeNone = ()=>()=>{};
+const getEmptySnapshot = ()=>null;
+const createI18nRouterNavigation = ({ I18nNavigationProvider, useNativeI18nRouterAdapter })=>{
+    const NavigationProvider = I18nNavigationProvider;
+    const useIntegratedRouterAdapter = ()=>{
+        const runtimeContext = useContext(RuntimeContext);
+        const internalContext = useContext(InternalRuntimeContext);
+        const native = useNativeI18nRouterAdapter();
+        const getCapability = useCallback(()=>getRouterRuntimeState(internalContext)?.navigation ?? getRouterRuntimeState(runtimeContext)?.navigation, [
+            internalContext,
+            runtimeContext
+        ]);
+        const subscribeCapability = useCallback((update)=>{
+            const stopInternal = subscribeRouterRuntimeState(internalContext, update);
+            const stopPublic = internalContext === runtimeContext ? void 0 : subscribeRouterRuntimeState(runtimeContext, update);
+            return ()=>{
+                stopInternal();
+                stopPublic?.();
+            };
+        }, [
+            internalContext,
+            runtimeContext
+        ]);
+        const capability = useSyncExternalStore(subscribeCapability, getCapability, getCapability);
+        const snapshot = useSyncExternalStore(capability?.subscribe ?? subscribeNone, capability?.getSnapshot ?? getEmptySnapshot, capability?.getSnapshot ?? getEmptySnapshot);
+        if (native.hasRouter || !capability || !snapshot) return native;
+        const internalState = getRouterRuntimeState(internalContext);
+        return {
+            framework: internalState?.navigation === capability ? internalState.framework : getRouterRuntimeState(runtimeContext)?.framework,
+            hasRouter: true,
+            ...snapshot,
+            navigate: capability.navigate,
+            Link: capability.Link,
+            createLinkProps: capability.createLinkProps
+        };
+    };
+    const I18nRouterNavigationProvider = ({ children })=>{
+        const value = useIntegratedRouterAdapter();
+        const native = useNativeI18nRouterAdapter();
+        return /*#__PURE__*/ jsx(NavigationProvider, {
+            value: value.hasRouter && !native.hasRouter ? value : null,
+            children: children
+        });
+    };
+    return {
+        useIntegratedRouterAdapter,
+        I18nRouterNavigationProvider
+    };
+};
+export { createI18nRouterNavigation };

package/dist/esm-node/router-navigation/index.mjs

@@ -0,0 +1,2 @@
+import "node:module";
+export { createI18nRouterNavigation } from "./adapter.mjs";

package/dist/types/index.d.ts

@@ -1,3 +1,4 @@
+export * from '@modern-js/runtime-extensions/localised-urls';
 export * from './language-sync/controller.js';
 export * from './language-sync/react.js';
-export * from './localisedUrls/index.js';
+export * from './localeRedirectPolicy.js';

package/dist/types/localeRedirectPolicy.d.ts

@@ -0,0 +1,22 @@
+import type { LocalisedUrlsOption } from '@modern-js/runtime-extensions/localised-urls';
+interface LocaleRedirectRequest {
+    url: string;
+    header: () => {
+        host?: string;
+    };
+}
+/**
+ * Check if pathname should ignore automatic locale redirect.
+ */
+export declare const shouldIgnoreRedirect: (pathname: string, urlPath: string, ignoreRedirectRoutes?: string[] | ((pathname: string) => boolean)) => boolean;
+/**
+ * Check if pathname is a static or federation resource request.
+ *
+ * This includes configured staticRoutePrefixes, the shared default skip policy
+ * from ADR-0002, and language-prefixed variants such as /en/static/app.js.
+ */
+export declare const isStaticResourceRequest: (pathname: string, staticRoutePrefixes: string[], languages?: string[]) => boolean;
+export declare const getLanguageFromPath: (req: LocaleRedirectRequest, urlPath: string, languages: string[]) => string | null;
+export declare const buildLocalizedUrl: (req: LocaleRedirectRequest, urlPath: string, language: string, languages: string[], localisedUrls?: LocalisedUrlsOption) => string;
+export declare const createLocaleRedirectResponse: (location: string) => Response;
+export {};

package/dist/types/paths.d.ts

@@ -0,0 +1,9 @@
+import { type LocalisedUrlsOption } from '@modern-js/runtime-extensions/localised-urls';
+export interface LocalizedPathsConfig {
+    languages: string[];
+    localisedUrls?: LocalisedUrlsOption;
+}
+/** Synchronous mapped URL construction, independent of React/plugin setup. */
+export declare const buildLocalizedUrl: (target: string, language: string, languages: string[], localisedUrls?: LocalisedUrlsOption) => string;
+export declare const localizePath: (target: string, language: string, config: LocalizedPathsConfig) => string;
+export declare const canonicalPath: (target: string, config: LocalizedPathsConfig) => string;

package/dist/types/router-navigation/adapter.d.ts

@@ -0,0 +1,23 @@
+import { type RouterLinkTarget, type RouterNavigationCapability, type RouterNavigationSnapshot } from '@modern-js/runtime-extensions/router-state';
+import type React from 'react';
+export interface I18nRouterNavigationDependencies<Adapter extends I18nRouterAdapterShape> {
+    I18nNavigationProvider: React.ComponentType<React.PropsWithChildren<{
+        value: Adapter;
+    }>>;
+    useNativeI18nRouterAdapter: () => Adapter;
+}
+export type I18nRouterLinkTarget = RouterLinkTarget;
+export interface I18nRouterAdapterShape {
+    framework?: string;
+    hasRouter: boolean;
+    location: RouterNavigationSnapshot['location'] | null;
+    navigate: RouterNavigationCapability['navigate'] | null;
+    Link: RouterNavigationCapability['Link'] | null;
+    params: Record<string, string>;
+    createLinkProps?: RouterNavigationCapability['createLinkProps'];
+}
+/** The router provider owns navigation; this seam only observes its capability. */
+export declare const createI18nRouterNavigation: <Adapter extends I18nRouterAdapterShape>({ I18nNavigationProvider, useNativeI18nRouterAdapter, }: I18nRouterNavigationDependencies<Adapter>) => {
+    useIntegratedRouterAdapter: () => Adapter;
+    I18nRouterNavigationProvider: ({ children, }: React.PropsWithChildren) => React.JSX.Element;
+};

package/dist/types/router-navigation/index.d.ts

@@ -0,0 +1 @@
+export { createI18nRouterNavigation, type I18nRouterAdapterShape, type I18nRouterLinkTarget, type I18nRouterNavigationDependencies, } from './adapter.js';