@bleedingdev/modern-js-i18n-runtime-extensions 3.9.0-ultramodern.8 → 3.9.3-ultramodern.1

package/dist/cjs/index.js

@@ -9,8 +9,8 @@ var __webpack_modules__ = {
     "./localeRedirectPolicy" (module) {
         module.exports = require("./localeRedirectPolicy.js");
     },
-    "./localisedUrls/index" (module) {
-        module.exports = require("./localisedUrls/index.js");
+    "@modern-js/runtime-extensions/localised-urls" (module) {
+        module.exports = require("@modern-js/runtime-extensions/localised-urls");
     }
 };
 var __webpack_module_cache__ = {};
@@ -60,21 +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 _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 _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_react__rspack_import_1 = __webpack_require__("./language-sync/react");
+    var _language_sync_controller__rspack_import_1 = __webpack_require__("./language-sync/controller");
     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_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 _localeRedirectPolicy__rspack_import_2 = __webpack_require__("./localeRedirectPolicy");
+    var _language_sync_react__rspack_import_2 = __webpack_require__("./language-sync/react");
     var __rspack_reexport = {};
-    for(const __rspack_import_key in _localeRedirectPolicy__rspack_import_2)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_localeRedirectPolicy__rspack_import_2[__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_3 = __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_3)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_localisedUrls_index__rspack_import_3[__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

@@ -34,7 +34,7 @@ __webpack_require__.d(__webpack_exports__, {
     isStaticResourceRequest: ()=>isStaticResourceRequest,
     shouldIgnoreRedirect: ()=>shouldIgnoreRedirect
 });
-const index_js_namespaceObject = require("./localisedUrls/index.js");
+const localised_urls_namespaceObject = require("@modern-js/runtime-extensions/localised-urls");
 const stripUrlPathPrefix = (pathname, urlPath)=>{
     const basePath = urlPath.replace('/*', '');
     if (!basePath || '/' === basePath) return pathname;
@@ -43,13 +43,13 @@ const stripUrlPathPrefix = (pathname, urlPath)=>{
 };
 const shouldIgnoreRedirect = (pathname, urlPath, ignoreRedirectRoutes)=>{
     const remainingPath = stripUrlPathPrefix(pathname, urlPath);
-    return (0, index_js_namespaceObject.shouldSkipLocaleRedirect)(remainingPath, [], ignoreRedirectRoutes);
+    return (0, localised_urls_namespaceObject.shouldSkipLocaleRedirect)(remainingPath, [], ignoreRedirectRoutes);
 };
 const isStaticResourceRequest = (pathname, staticRoutePrefixes, languages = [])=>{
-    if ((0, index_js_namespaceObject.isDefaultLocaleRedirectSkipPath)(pathname, languages)) return true;
-    const matchesStaticRoutePrefix = (targetPathname)=>staticRoutePrefixes.some((prefix)=>(0, index_js_namespaceObject.matchesPathPrefix)(targetPathname, prefix));
+    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, index_js_namespaceObject.stripLanguagePrefix)(pathname, languages);
+    const pathWithoutLanguage = (0, localised_urls_namespaceObject.stripLanguagePrefix)(pathname, languages);
     return pathWithoutLanguage !== pathname && matchesStaticRoutePrefix(pathWithoutLanguage);
 };
 const getLanguageFromPath = (req, urlPath, languages)=>{
@@ -66,7 +66,7 @@ const buildLocalizedUrl = (req, urlPath, language, languages, localisedUrls)=>{
     const pathname = url.pathname;
     const basePath = urlPath.replace('/*', '');
     const remainingPath = stripUrlPathPrefix(pathname, urlPath);
-    const newPathname = (0, index_js_namespaceObject.localiseTargetPathname)(remainingPath, language, languages, localisedUrls);
+    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;

package/dist/cjs/native.js

@@ -0,0 +1,160 @@
+"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)=>{
+            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__, {
+    createNativeI18n: ()=>createNativeI18n
+});
+const external_i18next_namespaceObject = require("i18next");
+var external_i18next_default = /*#__PURE__*/ __webpack_require__.n(external_i18next_namespaceObject);
+const controller_js_namespaceObject = require("./language-sync/controller.js");
+const external_requestLanguage_js_namespaceObject = require("./requestLanguage.js");
+const external_ssrLanguageHandoff_js_namespaceObject = require("./ssrLanguageHandoff.js");
+const external_urlRewrite_js_namespaceObject = require("./urlRewrite.js");
+function unwrapResource(module) {
+    const resource = 'object' == typeof module && null !== module && 'default' in module ? module.default : module;
+    return resource;
+}
+function createNativeI18n(options, loaders) {
+    const { initOptions = {}, ...routing } = options;
+    const namespaces = [
+        ...new Set(Object.values(loaders).flatMap(Object.keys))
+    ].sort();
+    const defaultNamespace = 'string' == typeof initOptions.defaultNS ? initOptions.defaultNS : namespaces.includes('translation') ? 'translation' : namespaces[0] ?? 'translation';
+    const cookie = routing.detection?.lookupCookie ?? 'i18next';
+    const backend = {
+        type: 'backend',
+        init () {},
+        read (language, namespace, callback) {
+            const bundles = Object.hasOwn(loaders, language) ? loaders[language] : void 0;
+            const load = bundles && Object.hasOwn(bundles, namespace) ? bundles[namespace] : void 0;
+            if (!load) return void callback(null, {});
+            load().then((module)=>callback(null, unwrapResource(module)), (error)=>callback(error, false));
+        }
+    };
+    const currentLanguage = ()=>(0, external_requestLanguage_js_namespaceObject.languageFromPathname)(window.location.pathname, routing.languages, routing.basePath);
+    return {
+        languages: routing.languages,
+        ...void 0 === routing.localisedUrls ? {} : {
+            localisedUrls: routing.localisedUrls
+        },
+        resolveRequest: (request)=>(0, external_requestLanguage_js_namespaceObject.resolveRequestLanguage)(request, routing),
+        redirect: external_requestLanguage_js_namespaceObject.createRequestLanguageRedirect,
+        async create (language, resources) {
+            const instance = external_i18next_default().createInstance();
+            instance.use(backend);
+            await instance.init({
+                ...initOptions,
+                lng: language,
+                fallbackLng: routing.fallbackLanguage,
+                supportedLngs: [
+                    ...routing.languages
+                ],
+                ns: namespaces,
+                defaultNS: defaultNamespace,
+                partialBundledLanguages: true,
+                resources: resources ? {
+                    [language]: resources
+                } : {},
+                interpolation: {
+                    escapeValue: false,
+                    ...initOptions.interpolation
+                }
+            });
+            return instance;
+        },
+        rewrite: (getLanguage)=>(0, external_urlRewrite_js_namespaceObject.createI18nUrlRewrite)({
+                languages: routing.languages,
+                getLanguage,
+                localisedUrls: routing.localisedUrls
+            }),
+        handoff (language, instance) {
+            return (0, external_ssrLanguageHandoff_js_namespaceObject.createI18nSsrHandoffInlineData)({
+                language,
+                ...instance ? {
+                    resources: Object.fromEntries(namespaces.map((namespace)=>[
+                            namespace,
+                            instance.getResourceBundle(language, namespace) ?? {}
+                        ]))
+                } : {}
+            });
+        },
+        clientHandoff () {
+            const handoff = (0, external_ssrLanguageHandoff_js_namespaceObject.readI18nSsrHandoff)();
+            if (handoff && routing.languages.includes(handoff.language)) return handoff;
+            return {
+                language: currentLanguage() ?? routing.fallbackLanguage
+            };
+        },
+        syncWithRouter (router, instance) {
+            const sync = (0, controller_js_namespaceObject.createLatestLanguageSyncBinding)();
+            sync.updateCallbacks({
+                changeLanguage: (target, language)=>target.changeLanguage(language),
+                commitLanguage () {},
+                readLanguage: (target)=>target.language,
+                reportFailure: ()=>window.location.reload()
+            });
+            sync.activate(instance);
+            const unsubscribe = router.subscribe('onBeforeLoad', ({ toLocation })=>{
+                const publicHref = toLocation.maskedLocation?.publicHref ?? toLocation.publicHref;
+                const pathname = new URL(publicHref, window.location.origin).pathname;
+                const language = (0, external_requestLanguage_js_namespaceObject.languageFromPathname)(pathname, routing.languages, routing.basePath);
+                if (language) sync.request(language);
+            });
+            return ()=>{
+                unsubscribe();
+                sync.deactivate();
+            };
+        },
+        persist (instance) {
+            const persist = (language)=>{
+                document.documentElement.lang = language;
+                document.cookie = `${cookie}=${encodeURIComponent(language)}; path=/; max-age=31536000; samesite=lax`;
+            };
+            if (instance.language) persist(instance.language);
+            instance.on('languageChanged', persist);
+            return ()=>instance.off('languageChanged', persist);
+        }
+    };
+}
+exports.createNativeI18n = __webpack_exports__.createNativeI18n;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createNativeI18n"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/paths.js

@@ -30,25 +30,33 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     buildLocalizedUrl: ()=>buildLocalizedUrl,
     canonicalPath: ()=>canonicalPath,
+    configuredLanguage: ()=>configuredLanguage,
     localizePath: ()=>localizePath
 });
+const localised_urls_namespaceObject = require("@modern-js/runtime-extensions/localised-urls");
 const url_namespaceObject = require("@modern-js/runtime-utils/url");
-const index_js_namespaceObject = require("./localisedUrls/index.js");
+const configuredLanguage = (requested, languages)=>{
+    const language = languages.find((candidate)=>candidate.toLowerCase() === String(requested).toLowerCase());
+    if (void 0 === language) throw new RangeError(`Unsupported language "${requested}"; expected one of: ${languages.join(', ')}`);
+    return language;
+};
 const buildLocalizedUrl = (target, language, languages, localisedUrls)=>{
     const { pathname, search, hash } = (0, url_namespaceObject.splitUrlTarget)(target);
-    return `${(0, index_js_namespaceObject.localiseTargetPathname)(pathname, language, languages, localisedUrls)}${search}${hash}`;
+    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, index_js_namespaceObject.canonicalTargetPathname)(pathname, config.languages, config.localisedUrls)}${search}${hash}`;
+    return `${(0, localised_urls_namespaceObject.canonicalTargetPathname)(pathname, config.languages, config.localisedUrls)}${search}${hash}`;
 };
 exports.buildLocalizedUrl = __webpack_exports__.buildLocalizedUrl;
 exports.canonicalPath = __webpack_exports__.canonicalPath;
+exports.configuredLanguage = __webpack_exports__.configuredLanguage;
 exports.localizePath = __webpack_exports__.localizePath;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "buildLocalizedUrl",
     "canonicalPath",
+    "configuredLanguage",
     "localizePath"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {

package/dist/cjs/requestLanguage.js

@@ -0,0 +1,195 @@
+"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__, {
+    createRequestLanguageRedirect: ()=>createRequestLanguageRedirect,
+    detectRequestLanguage: ()=>detectRequestLanguage,
+    languageFromPathname: ()=>languageFromPathname,
+    resolveRequestLanguage: ()=>resolveRequestLanguage
+});
+const localised_urls_namespaceObject = require("@modern-js/runtime-extensions/localised-urls");
+const DEFAULT_ORDER = [
+    'querystring',
+    'cookie',
+    'header'
+];
+const normaliseBasePath = (basePath)=>{
+    if (!basePath || '/' === basePath) return '';
+    return `/${basePath.split('/').filter(Boolean).join('/')}`;
+};
+const entryPathname = (pathname, basePath)=>{
+    const base = normaliseBasePath(basePath);
+    if (!base) return pathname || '/';
+    if (pathname === base) return '/';
+    return pathname.startsWith(`${base}/`) ? pathname.slice(base.length) : void 0;
+};
+const baseLanguage = (tag)=>tag.toLowerCase().split(/[-_]/u)[0];
+const compatibleLanguages = (candidate, languages)=>{
+    const value = candidate?.trim().toLowerCase();
+    if (!value) return [];
+    const base = baseLanguage(value);
+    return [
+        ...languages.filter((language)=>language.toLowerCase() === value),
+        ...languages.filter((language)=>language.toLowerCase() === base),
+        ...base === value ? languages.filter((language)=>baseLanguage(language) === value) : []
+    ].filter((language, index, all)=>all.indexOf(language) === index);
+};
+const matchLanguage = (candidate, languages)=>compatibleLanguages(candidate, languages)[0];
+function languageFromPathname(pathname, languages, basePath) {
+    const remaining = entryPathname(pathname, basePath);
+    if (void 0 === remaining) return;
+    const first = remaining.split('/').filter(Boolean)[0];
+    if (!first) return;
+    return languages.find((language)=>language.toLowerCase() === first.toLowerCase());
+}
+const readCookie = (header, name)=>{
+    if (!header) return null;
+    for (const part of header.split(';')){
+        const separator = part.indexOf('=');
+        if (separator < 0) continue;
+        if (part.slice(0, separator).trim() !== name) continue;
+        const raw = part.slice(separator + 1).trim();
+        try {
+            return decodeURIComponent(raw);
+        } catch  {
+            return raw;
+        }
+    }
+    return null;
+};
+const QVALUE = /^(?:0(?:\.\d{0,3})?|1(?:\.0{0,3})?)$/;
+const rangeSpecificity = (range, language)=>{
+    const value = range.toLowerCase().replaceAll('_', '-');
+    const supported = language.toLowerCase().replaceAll('_', '-');
+    if ('*' === value) return 0;
+    if (value === supported) return Number.MAX_SAFE_INTEGER;
+    if (supported.startsWith(`${value}-`)) return 1 + value.split('-').length;
+    if (baseLanguage(value) === supported) return 1;
+};
+const acceptedLanguages = (header, languages)=>{
+    const items = (header ?? '').split(',').map((item, index)=>{
+        const [tag, ...parameters] = item.trim().split(';');
+        const quality = parameters.map((parameter)=>parameter.trim()).find((parameter)=>parameter.toLowerCase().startsWith('q='));
+        const value = quality?.slice(2).trim();
+        const q = void 0 === value ? 1 : QVALUE.test(value) ? Number(value) : 0 / 0;
+        return {
+            tag: tag.trim(),
+            q,
+            index
+        };
+    }).filter((item)=>item.tag && !Number.isNaN(item.q));
+    const ranked = languages.flatMap((language, position)=>{
+        let best;
+        for (const item of items){
+            const specificity = rangeSpecificity(item.tag, language);
+            if (void 0 !== specificity && (!best || specificity > best.specificity)) best = {
+                q: item.q,
+                index: item.index,
+                specificity
+            };
+        }
+        return best && best.q > 0 ? [
+            {
+                language,
+                position,
+                ...best
+            }
+        ] : [];
+    });
+    return ranked.sort((left, right)=>right.q - left.q || left.index - right.index || right.specificity - left.specificity || left.position - right.position).map((entry)=>entry.language);
+};
+function detectRequestLanguage(request, languages, detection = {}) {
+    const url = new URL(request.url);
+    for (const detector of detection.order ?? DEFAULT_ORDER){
+        let language;
+        if ('querystring' === detector) language = matchLanguage(url.searchParams.get(detection.lookupQuerystring ?? 'lng'), languages);
+        else if ('cookie' === detector) language = matchLanguage(readCookie(request.headers.get('cookie'), detection.lookupCookie ?? 'i18next'), languages);
+        else if ('header' === detector) language = acceptedLanguages(request.headers.get(detection.lookupHeader ?? 'accept-language'), languages).find(Boolean);
+        if (language) return language;
+    }
+}
+function resolveRequestLanguage(request, options) {
+    const { languages, fallbackLanguage } = options;
+    const url = new URL(request.url);
+    const fromPath = languageFromPathname(url.pathname, languages, options.basePath);
+    if (fromPath) return {
+        kind: 'language',
+        language: fromPath
+    };
+    const detected = (false === options.detect ? void 0 : detectRequestLanguage(request, languages, options.detection)) ?? fallbackLanguage;
+    const remaining = entryPathname(url.pathname, options.basePath);
+    if (void 0 === remaining || (0, localised_urls_namespaceObject.shouldSkipLocaleRedirect)(remaining, [
+        ...languages
+    ], options.ignoreRedirectRoutes)) {
+        const vary = (false === options.detect ? [] : options.detection?.order ?? DEFAULT_ORDER).flatMap((detector)=>'header' === detector ? [
+                options.detection?.lookupHeader ?? 'Accept-Language'
+            ] : 'cookie' === detector ? [
+                'Cookie'
+            ] : []);
+        return vary.length ? {
+            kind: 'language',
+            language: detected,
+            vary
+        } : {
+            kind: 'language',
+            language: detected
+        };
+    }
+    const localized = (0, localised_urls_namespaceObject.localiseTargetPathname)(remaining, detected, [
+        ...languages
+    ], options.localisedUrls);
+    return {
+        kind: 'redirect',
+        language: detected,
+        location: `${normaliseBasePath(options.basePath)}${localized}${url.search}`
+    };
+}
+function createRequestLanguageRedirect(location) {
+    return new Response(null, {
+        status: 302,
+        headers: {
+            'cache-control': 'private, no-store',
+            location,
+            vary: 'Accept-Language, Cookie'
+        }
+    });
+}
+exports.createRequestLanguageRedirect = __webpack_exports__.createRequestLanguageRedirect;
+exports.detectRequestLanguage = __webpack_exports__.detectRequestLanguage;
+exports.languageFromPathname = __webpack_exports__.languageFromPathname;
+exports.resolveRequestLanguage = __webpack_exports__.resolveRequestLanguage;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createRequestLanguageRedirect",
+    "detectRequestLanguage",
+    "languageFromPathname",
+    "resolveRequestLanguage"
+].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