@bleedingdev/modern-js-i18n-runtime-extensions 3.9.0-ultramodern.9 → 3.9.3-ultramodern.10

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

package/dist/cjs/ssrLanguageHandoff.js

@@ -0,0 +1,94 @@
+"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__, {
+    I18N_SSR_HANDOFF_ELEMENT_ID: ()=>I18N_SSR_HANDOFF_ELEMENT_ID,
+    createI18nSsrHandoffInlineData: ()=>createI18nSsrHandoffInlineData,
+    readI18nSsrHandoff: ()=>readI18nSsrHandoff,
+    readI18nSsrHandoffFromText: ()=>readI18nSsrHandoffFromText,
+    serializeI18nSsrHandoff: ()=>serializeI18nSsrHandoff
+});
+const data_namespaceObject = require("@modern-js/renderer-core/data");
+const document_namespaceObject = require("@modern-js/renderer-core/document");
+const I18N_SSR_HANDOFF_ELEMENT_ID = '__modernjs_i18n_ssr__';
+function assertPayload(payload) {
+    if ('string' != typeof payload.language || 0 === payload.language.length) throw new TypeError('An i18n SSR handoff payload requires a nonempty language.');
+    if (void 0 !== payload.resources && ('object' != typeof payload.resources || null === payload.resources)) throw new TypeError('An i18n SSR handoff payload resources field must be a plain object.');
+}
+function createI18nSsrHandoffInlineData(payload, options = {}) {
+    assertPayload(payload);
+    return {
+        id: options.id ?? I18N_SSR_HANDOFF_ELEMENT_ID,
+        payload: (0, data_namespaceObject.serializePublicData)({
+            language: payload.language,
+            ...payload.resources ? {
+                resources: payload.resources
+            } : {}
+        })
+    };
+}
+function serializeI18nSsrHandoff(payload, options = {}) {
+    return (0, document_namespaceObject.serializeInlineData)({
+        ...createI18nSsrHandoffInlineData(payload, options),
+        nonce: options.nonce
+    });
+}
+function isHandoffPayload(value) {
+    return Boolean(value) && 'object' == typeof value && 'string' == typeof value.language;
+}
+function readI18nSsrHandoffFromText(text) {
+    if (!text) return;
+    try {
+        const result = (0, data_namespaceObject.parsePublicData)(text);
+        return isHandoffPayload(result) ? result : void 0;
+    } catch  {
+        return;
+    }
+}
+function readI18nSsrHandoff(options = {}) {
+    const doc = options.doc ?? ("u" < typeof document ? void 0 : document);
+    if (!doc) return;
+    const element = doc.getElementById(options.id ?? I18N_SSR_HANDOFF_ELEMENT_ID);
+    return readI18nSsrHandoffFromText(element?.textContent ?? null);
+}
+exports.I18N_SSR_HANDOFF_ELEMENT_ID = __webpack_exports__.I18N_SSR_HANDOFF_ELEMENT_ID;
+exports.createI18nSsrHandoffInlineData = __webpack_exports__.createI18nSsrHandoffInlineData;
+exports.readI18nSsrHandoff = __webpack_exports__.readI18nSsrHandoff;
+exports.readI18nSsrHandoffFromText = __webpack_exports__.readI18nSsrHandoffFromText;
+exports.serializeI18nSsrHandoff = __webpack_exports__.serializeI18nSsrHandoff;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "I18N_SSR_HANDOFF_ELEMENT_ID",
+    "createI18nSsrHandoffInlineData",
+    "readI18nSsrHandoff",
+    "readI18nSsrHandoffFromText",
+    "serializeI18nSsrHandoff"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/urlRewrite.js

@@ -0,0 +1,64 @@
+"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__, {
+    createI18nUrlRewrite: ()=>createI18nUrlRewrite
+});
+const localised_urls_namespaceObject = require("@modern-js/runtime-extensions/localised-urls");
+const external_requestLanguage_js_namespaceObject = require("./requestLanguage.js");
+const createI18nUrlRewrite = (options)=>{
+    const { languages, getLanguage, localisedUrls, onLanguageDetected } = options;
+    const languageList = [
+        ...languages
+    ];
+    return {
+        input: ({ url })=>{
+            const pathname = url.pathname;
+            if (onLanguageDetected) {
+                const segments = pathname.split('/').filter(Boolean);
+                const firstSegment = segments[0];
+                const detected = firstSegment ? languageList.find((language)=>language.toLowerCase() === firstSegment.toLowerCase()) : void 0;
+                if (detected) onLanguageDetected(detected);
+            }
+            url.pathname = (0, localised_urls_namespaceObject.canonicalTargetPathname)(pathname, languageList, localisedUrls);
+            return url;
+        },
+        output: ({ url })=>{
+            url.pathname = (0, localised_urls_namespaceObject.localiseTargetPathname)(url.pathname, (0, external_requestLanguage_js_namespaceObject.languageFromPathname)(url.pathname, languageList) ?? getLanguage(), languageList, localisedUrls);
+            return url;
+        }
+    };
+};
+exports.createI18nUrlRewrite = __webpack_exports__.createI18nUrlRewrite;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createI18nUrlRewrite"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/esm/index.mjs

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

package/dist/esm/localeRedirectPolicy.mjs

@@ -1,4 +1,4 @@
-import { isDefaultLocaleRedirectSkipPath, localiseTargetPathname, matchesPathPrefix, shouldSkipLocaleRedirect, stripLanguagePrefix } from "./localisedUrls/index.mjs";
+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;