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

package/dist/esm-node/index.mjs

@@ -1,5 +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 "./localeRedirectPolicy.mjs";
-export * from "./localisedUrls/index.mjs";

package/dist/esm-node/localeRedirectPolicy.mjs

@@ -1,5 +1,5 @@
 import "node:module";
-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;

package/dist/esm-node/native.mjs

@@ -0,0 +1,379 @@
+import "node:module";
+import i18next from "i18next";
+import { createLatestLanguageSyncBinding } from "./language-sync/controller.mjs";
+import { createRequestLanguageRedirect, languageFromPathname, resolveRequestLanguage } from "./requestLanguage.mjs";
+import { createI18nSsrHandoffInlineData, readI18nSsrHandoff } from "./ssrLanguageHandoff.mjs";
+import { createI18nUrlRewrite } from "./urlRewrite.mjs";
+const nativeSnapshotOrigins = new WeakMap();
+function invalidateNativeI18nSnapshot(instance) {
+    if ('object' == typeof instance && null !== instance) nativeSnapshotOrigins.delete(instance);
+}
+const nativeRewriteOrigins = new WeakMap();
+function getNativeI18nRewriteSnapshot(rewrite) {
+    return 'object' == typeof rewrite && null !== rewrite ? nativeRewriteOrigins.get(rewrite)?.() : void 0;
+}
+function detachLocalisedUrls(value) {
+    if (void 0 === value || 'boolean' == typeof value) return value;
+    return Object.fromEntries(Object.entries(value).map(([path, languages])=>[
+            path,
+            Object.fromEntries(Object.entries(languages))
+        ]));
+}
+function plainRecord(value) {
+    return 'object' == typeof value && null !== value && (Object.getPrototypeOf(value) === Object.prototype || null === Object.getPrototypeOf(value));
+}
+function detachOption(value, ancestors = new Set()) {
+    if (null === value || 'object' != typeof value) return value;
+    if (ancestors.has(value) || (Array.isArray(value) ? Object.getPrototypeOf(value) !== Array.prototype : !plainRecord(value))) throw new Error('Native i18n snapshot options must be plain acyclic data');
+    ancestors.add(value);
+    const copy = Array.isArray(value) ? [] : {};
+    for (const key of Reflect.ownKeys(value)){
+        if (Array.isArray(value) && 'length' === key) continue;
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        if ('string' != typeof key || !descriptor || !('value' in descriptor)) throw new Error('Native i18n snapshot options cannot contain accessors');
+        Object.defineProperty(copy, key, {
+            value: detachOption(descriptor.value, ancestors),
+            enumerable: descriptor.enumerable,
+            writable: true,
+            configurable: true
+        });
+    }
+    ancestors.delete(value);
+    return copy;
+}
+function detachInitOptions(options) {
+    const copy = detachOption(options);
+    if (!plainRecord(copy)) throw new Error('Invalid native i18n options');
+    return copy;
+}
+function descriptorProof(object, ignore = new Set(), ancestors = new Set()) {
+    if (ancestors.has(object)) return ()=>true;
+    ancestors.add(object);
+    const keys = Reflect.ownKeys(object).filter((key)=>'string' != typeof key || !ignore.has(key));
+    const proofs = keys.map((key)=>{
+        const descriptor = Object.getOwnPropertyDescriptor(object, key);
+        if (!descriptor || !('value' in descriptor)) throw new Error('Native i18n snapshot provenance cannot contain accessors');
+        const value = descriptor.value;
+        const nested = Array.isArray(value) || plainRecord(value) ? descriptorProof(value, new Set(), ancestors) : ()=>true;
+        return ()=>{
+            const current = Object.getOwnPropertyDescriptor(object, key);
+            return void 0 !== current && 'value' in current && current.value === value && current.enumerable === descriptor.enumerable && current.configurable === descriptor.configurable && current.writable === descriptor.writable && nested();
+        };
+    });
+    ancestors.delete(object);
+    return ()=>{
+        const currentKeys = Reflect.ownKeys(object).filter((key)=>'string' != typeof key || !ignore.has(key));
+        return currentKeys.length === keys.length && currentKeys.every((key, index)=>key === keys[index]) && proofs.every((proof)=>proof());
+    };
+}
+function methodProof(object) {
+    const prototype = Object.getPrototypeOf(object);
+    const methods = new Map();
+    for(let current = object; current && current !== Object.prototype; current = Object.getPrototypeOf(current))for (const key of Reflect.ownKeys(current)){
+        const descriptor = Object.getOwnPropertyDescriptor(current, key);
+        if (descriptor && 'value' in descriptor) {
+            if ('function' == typeof descriptor.value && !methods.has(key)) methods.set(key, descriptor.value);
+        }
+    }
+    return ()=>{
+        if (Object.getPrototypeOf(object) !== prototype) return false;
+        for (const [key, method] of methods){
+            let current = object;
+            while(current){
+                const descriptor = Object.getOwnPropertyDescriptor(current, key);
+                if (descriptor) {
+                    if (!('value' in descriptor) || descriptor.value !== method) return false;
+                    break;
+                }
+                current = Object.getPrototypeOf(current);
+            }
+            if (!current) return false;
+        }
+        return true;
+    };
+}
+function ownValue(object, key) {
+    const descriptor = Object.getOwnPropertyDescriptor(object, key);
+    if (descriptor && !('value' in descriptor)) throw new Error('Native i18n snapshot provenance cannot contain accessors');
+    return descriptor?.value;
+}
+function semanticProof(object, fields) {
+    const proofs = fields.map((key)=>{
+        const value = ownValue(object, key);
+        const nested = Array.isArray(value) || plainRecord(value) ? descriptorProof(value, new Set([
+            'resources'
+        ])) : ()=>true;
+        if (value instanceof RegExp) {
+            const source = value.source;
+            const flags = value.flags;
+            return ()=>{
+                const current = ownValue(object, key);
+                return current instanceof RegExp && current.source === source && current.flags === flags;
+            };
+        }
+        return ()=>ownValue(object, key) === value && nested();
+    });
+    return ()=>proofs.every((proof)=>proof());
+}
+function recordNativeSnapshotOrigin(instance, original, seed) {
+    try {
+        const useDescriptor = Object.getOwnPropertyDescriptor(instance, 'use');
+        if (!useDescriptor || !('value' in useDescriptor)) throw new Error('Native plugin registration requires an own method');
+        const use = instance.use;
+        Object.defineProperty(instance, 'use', {
+            ...useDescriptor,
+            value: function(plugin) {
+                invalidateNativeI18nSnapshot(instance);
+                return use(plugin);
+            }
+        });
+        const services = instance.services;
+        const store = instance.store;
+        const options = instance.options;
+        const modules = instance.modules;
+        const translator = Object.getOwnPropertyDescriptor(instance, 'translator')?.value;
+        const formatter = instance.services.formatter;
+        const formats = formatter && 'object' == typeof formatter ? Object.getOwnPropertyDescriptor(formatter, 'formats')?.value : void 0;
+        const proofs = [
+            descriptorProof(instance.options, new Set([
+                'resources'
+            ])),
+            descriptorProof(instance.modules),
+            descriptorProof(services),
+            methodProof(instance),
+            methodProof(instance.store),
+            ...Object.values(instance.services).filter((value)=>'object' == typeof value && null !== value).map((value)=>methodProof(value)),
+            ...translator && 'object' == typeof translator ? [
+                methodProof(translator)
+            ] : [],
+            ...formats && 'object' == typeof formats ? [
+                descriptorProof(formats)
+            ] : []
+        ];
+        const serviceFields = {
+            languageUtils: [
+                'options',
+                'supportedLngs'
+            ],
+            pluralResolver: [
+                'languageUtils',
+                'options'
+            ],
+            interpolator: [
+                'options',
+                'escape',
+                'escapeValue',
+                'useRawValueToEscape',
+                'prefix',
+                'suffix',
+                'format',
+                'formatSeparator',
+                'unescapePrefix',
+                'unescapeSuffix',
+                'nestingPrefix',
+                'nestingSuffix',
+                'nestingOptionsSeparator',
+                'maxReplaces',
+                'alwaysFormat',
+                'regexp',
+                'regexpUnescape',
+                'nestingRegexp'
+            ],
+            formatter: [
+                'formatSeparator'
+            ],
+            resourceStore: [
+                'options'
+            ],
+            backendConnector: [
+                'backend',
+                'store',
+                'services',
+                'options'
+            ]
+        };
+        const links = Object.entries(instance.services).map(([key, value])=>{
+            if ('object' == typeof value && null !== value) proofs.push(semanticProof(value, serviceFields[key] ?? []));
+            return ()=>ownValue(services, key) === value;
+        });
+        if (translator && 'object' == typeof translator) proofs.push(semanticProof(translator, [
+            'options',
+            'resourceStore',
+            'languageUtils',
+            'pluralResolver',
+            'interpolator',
+            'backendConnector',
+            'i18nFormat',
+            'utils'
+        ]));
+        nativeSnapshotOrigins.set(instance, {
+            instance,
+            original: detachInitOptions(original),
+            seed: detachInitOptions(seed),
+            unchanged: ()=>ownValue(instance, 'services') === services && ownValue(instance, 'store') === store && ownValue(instance, 'options') === options && ownValue(instance, 'modules') === modules && ownValue(services, 'formatter') === formatter && (formatter && 'object' == typeof formatter ? ownValue(formatter, 'formats') === formats : true) && Object.getOwnPropertyDescriptor(instance, 'translator')?.value === translator && (translator && 'object' == typeof translator ? ownValue(translator, 'language') === ownValue(instance, 'language') : true) && links.every((proof)=>proof()) && proofs.every((proof)=>proof())
+        });
+    } catch  {}
+}
+function createNativeI18nInstance(initOptions) {
+    const original = detachInitOptions(initOptions);
+    const seed = {
+        ...detachInitOptions(original),
+        initAsync: false,
+        partialBundledLanguages: false,
+        interpolation: {
+            escapeValue: false,
+            ...original.interpolation
+        }
+    };
+    const instance = i18next.createInstance();
+    instance.init(detachInitOptions(seed));
+    if (!instance.isInitialized || instance.isInitializing) throw new Error('Native i18n instances require complete bundled resources');
+    recordNativeSnapshotOrigin(instance, original, seed);
+    return instance;
+}
+function getNativeI18nSnapshotSeed(instance) {
+    const origin = 'object' == typeof instance && null !== instance ? nativeSnapshotOrigins.get(instance) : void 0;
+    const services = origin ? ownValue(origin.instance, 'services') : void 0;
+    const connector = services && 'object' == typeof services ? ownValue(services, 'backendConnector') : void 0;
+    const state = connector && 'object' == typeof connector ? ownValue(connector, 'state') : void 0;
+    const pending = plainRecord(state) && Object.values(Object.getOwnPropertyDescriptors(state)).some((descriptor)=>!('value' in descriptor) || 1 === descriptor.value);
+    if (!origin || true !== ownValue(origin.instance, 'isInitialized') || true === ownValue(origin.instance, 'isInitializing') || ownValue(origin.instance, 'isLanguageChangingTo') || pending || !origin.unchanged()) throw new Error('This i18n instance requires an explicit Worker profile');
+    return detachInitOptions(origin.seed);
+}
+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 = ()=>languageFromPathname(window.location.pathname, routing.languages, routing.basePath);
+    return {
+        languages: routing.languages,
+        ...void 0 === routing.localisedUrls ? {} : {
+            localisedUrls: routing.localisedUrls
+        },
+        resolveRequest: (request)=>resolveRequestLanguage(request, routing),
+        redirect: createRequestLanguageRedirect,
+        async create (language, resources) {
+            const instance = i18next.createInstance();
+            instance.use(backend);
+            const seed = {
+                ...initOptions,
+                lng: language,
+                fallbackLng: routing.fallbackLanguage,
+                supportedLngs: [
+                    ...routing.languages
+                ],
+                ns: namespaces,
+                defaultNS: defaultNamespace,
+                partialBundledLanguages: true,
+                resources: resources ? {
+                    [language]: resources
+                } : {},
+                interpolation: {
+                    escapeValue: false,
+                    ...initOptions.interpolation
+                }
+            };
+            let original;
+            let detachedSeed;
+            try {
+                original = detachInitOptions(initOptions);
+                detachedSeed = detachInitOptions(seed);
+            } catch  {}
+            await instance.init(seed);
+            if (original && detachedSeed) recordNativeSnapshotOrigin(instance, original, detachedSeed);
+            return instance;
+        },
+        rewrite: (getLanguage)=>{
+            const languages = [
+                ...routing.languages
+            ];
+            const localisedUrls = detachLocalisedUrls(routing.localisedUrls);
+            const rewrite = createI18nUrlRewrite({
+                languages,
+                getLanguage,
+                localisedUrls
+            });
+            const unchanged = descriptorProof(rewrite);
+            nativeRewriteOrigins.set(rewrite, ()=>{
+                if (!unchanged()) throw new Error('Native i18n rewrite was modified');
+                const language = getLanguage();
+                if (!languages.includes(language)) throw new Error('Native i18n rewrite language is unsupported');
+                return {
+                    language,
+                    languages: [
+                        ...languages
+                    ],
+                    ...void 0 === localisedUrls ? {} : {
+                        localisedUrls: detachLocalisedUrls(localisedUrls)
+                    }
+                };
+            });
+            return rewrite;
+        },
+        handoff (language, instance) {
+            return createI18nSsrHandoffInlineData({
+                language,
+                ...instance ? {
+                    resources: Object.fromEntries(namespaces.map((namespace)=>[
+                            namespace,
+                            instance.getResourceBundle(language, namespace) ?? {}
+                        ]))
+                } : {}
+            });
+        },
+        clientHandoff () {
+            const handoff = readI18nSsrHandoff();
+            if (handoff && routing.languages.includes(handoff.language)) return handoff;
+            return {
+                language: currentLanguage() ?? routing.fallbackLanguage
+            };
+        },
+        syncWithRouter (router, instance) {
+            const sync = 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 = 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);
+        }
+    };
+}
+export { createNativeI18n, createNativeI18nInstance, getNativeI18nRewriteSnapshot, getNativeI18nSnapshotSeed, invalidateNativeI18nSnapshot };

package/dist/esm-node/paths.mjs

@@ -1,6 +1,11 @@
 import "node:module";
+import { canonicalTargetPathname, localiseTargetPathname } from "@modern-js/runtime-extensions/localised-urls";
 import { splitUrlTarget } from "@modern-js/runtime-utils/url";
-import { canonicalTargetPathname, localiseTargetPathname } from "./localisedUrls/index.mjs";
+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 } = splitUrlTarget(target);
     return `${localiseTargetPathname(pathname, language, languages, localisedUrls)}${search}${hash}`;
@@ -10,4 +15,4 @@ const canonicalPath = (target, config)=>{
     const { pathname, search, hash } = splitUrlTarget(target);
     return `${canonicalTargetPathname(pathname, config.languages, config.localisedUrls)}${search}${hash}`;
 };
-export { buildLocalizedUrl, canonicalPath, localizePath };
+export { buildLocalizedUrl, canonicalPath, configuredLanguage, localizePath };

package/dist/esm-node/requestLanguage.mjs

@@ -0,0 +1,149 @@
+import "node:module";
+import { localiseTargetPathname, shouldSkipLocaleRedirect } from "@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 || 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 = 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'
+        }
+    });
+}
+export { createRequestLanguageRedirect, detectRequestLanguage, languageFromPathname, resolveRequestLanguage };

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/esm-node/ssrLanguageHandoff.mjs

@@ -0,0 +1,45 @@
+import "node:module";
+import { parsePublicData, serializePublicData } from "@modern-js/renderer-core/data";
+import { serializeInlineData } from "@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: serializePublicData({
+            language: payload.language,
+            ...payload.resources ? {
+                resources: payload.resources
+            } : {}
+        })
+    };
+}
+function serializeI18nSsrHandoff(payload, options = {}) {
+    return 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 = 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);
+}
+export { I18N_SSR_HANDOFF_ELEMENT_ID, createI18nSsrHandoffInlineData, readI18nSsrHandoff, readI18nSsrHandoffFromText, serializeI18nSsrHandoff };