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

package/dist/esm-node/native.mjs

@@ -0,0 +1,113 @@
+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";
+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);
+            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)=>createI18nUrlRewrite({
+                languages: routing.languages,
+                getLanguage,
+                localisedUrls: routing.localisedUrls
+            }),
+        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 };

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 };

package/dist/esm-node/urlRewrite.mjs

@@ -0,0 +1,27 @@
+import "node:module";
+import { canonicalTargetPathname, localiseTargetPathname } from "@modern-js/runtime-extensions/localised-urls";
+import { languageFromPathname } from "./requestLanguage.mjs";
+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 = canonicalTargetPathname(pathname, languageList, localisedUrls);
+            return url;
+        },
+        output: ({ url })=>{
+            url.pathname = localiseTargetPathname(url.pathname, languageFromPathname(url.pathname, languageList) ?? getLanguage(), languageList, localisedUrls);
+            return url;
+        }
+    };
+};
+export { createI18nUrlRewrite };

package/dist/types/index.d.ts

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

package/dist/types/localeRedirectPolicy.d.ts

@@ -1,4 +1,4 @@
-import type { LocalisedUrlsOption } from './localisedUrls/index.js';
+import type { LocalisedUrlsOption } from '@modern-js/runtime-extensions/localised-urls';
 interface LocaleRedirectRequest {
     url: string;
     header: () => {

package/dist/types/native.d.ts

@@ -0,0 +1,21 @@
+import type { NativeEntryI18n } from '@modern-js/renderer-core/entry-server';
+import type { LocalisedUrlsOption } from '@modern-js/runtime-extensions/localised-urls';
+import { type i18n as I18nInstance, type InitOptions } from 'i18next';
+import { type ResolveRequestLanguageOptions } from './requestLanguage.js';
+export type { I18nInstance };
+export interface NativeI18nOptions extends ResolveRequestLanguageOptions {
+    /**
+     * JSON-serializable i18next `init` options. `lng`, `fallbackLng`,
+     * `supportedLngs`, `resources` and `ns` are owned by the native entry.
+     */
+    initOptions?: InitOptions;
+}
+/** language -> namespace -> lazily imported translation bundle. */
+export type NativeI18nLoaders = Readonly<Record<string, Readonly<Record<string, () => Promise<unknown>>>>>;
+export type NativeI18n = NativeEntryI18n<I18nInstance, LocalisedUrlsOption>;
+/**
+ * The localized routing and per-request i18next instances of a native
+ * Solid or Octane entry. Each language's bundles load on demand; an instance
+ * is never a module singleton.
+ */
+export declare function createNativeI18n(options: NativeI18nOptions, loaders: NativeI18nLoaders): NativeI18n;

package/dist/types/paths.d.ts

@@ -1,8 +1,15 @@
-import { type LocalisedUrlsOption } from './localisedUrls/index.js';
+import { type LocalisedUrlsOption } from '@modern-js/runtime-extensions/localised-urls';
+export type { LocalisedUrlsOption };
 export interface LocalizedPathsConfig {
     languages: string[];
     localisedUrls?: LocalisedUrlsOption;
 }
+/**
+ * The configured spelling of a requested language, matched case-insensitively.
+ * Only a configured language has a locale prefix, so anything else throws
+ * rather than becoming an unknown path segment.
+ */
+export declare const configuredLanguage: (requested: string, languages: readonly string[]) => string;
 /** 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;

package/dist/types/requestLanguage.d.ts

@@ -0,0 +1,60 @@
+import { type LocalisedUrlsOption } from '@modern-js/runtime-extensions/localised-urls';
+/**
+ * Renderer-neutral request language resolution for path-prefixed locales.
+ * It is the Fetch-native counterpart of `@modern-js/plugin-i18n`'s Hono
+ * language-detector + redirect middleware pair: a native renderer's request
+ * handler calls it with the standard `Request`, so it needs neither Hono nor
+ * React and runs unchanged on Node and in workers.
+ */
+export type RequestLanguageDetector = 'querystring' | 'cookie' | 'header';
+export interface RequestLanguageDetection {
+    /** @default ['querystring', 'cookie', 'header'] */
+    order?: readonly RequestLanguageDetector[];
+    /** @default 'lng' */
+    lookupQuerystring?: string;
+    /** @default 'i18next' */
+    lookupCookie?: string;
+    /** @default 'accept-language' */
+    lookupHeader?: string;
+}
+export interface ResolveRequestLanguageOptions {
+    languages: readonly string[];
+    fallbackLanguage: string;
+    /** Public path the entry is mounted under. @default '/' */
+    basePath?: string;
+    localisedUrls?: LocalisedUrlsOption;
+    /**
+     * Detect the language of an unprefixed URL from the query string, cookie
+     * and `Accept-Language`. When false the fallback language is used.
+     * @default true
+     */
+    detect?: boolean;
+    detection?: RequestLanguageDetection;
+    /** Canonical paths that are served without a language prefix. */
+    ignoreRedirectRoutes?: readonly string[] | ((pathname: string) => boolean);
+}
+export type ResolvedRequestLanguage = {
+    kind: 'language';
+    language: string;
+    vary?: readonly string[];
+} | {
+    kind: 'redirect';
+    language: string;
+    location: string;
+};
+/** The supported language carried by a public pathname's first segment. */
+export declare function languageFromPathname(pathname: string, languages: readonly string[], basePath?: string): string | undefined;
+/**
+ * Detect a supported language from the request alone (no path), in the
+ * configured detector order. Returns `undefined` when nothing matches.
+ */
+export declare function detectRequestLanguage(request: Request, languages: readonly string[], detection?: RequestLanguageDetection): string | undefined;
+/**
+ * Resolve the language a request renders in. A URL that already carries a
+ * supported language prefix renders in it; an unprefixed page URL is
+ * redirected to the detected (or fallback) language's localized URL, keeping
+ * search and the base path, unless it is an ignored or framework-owned path.
+ */
+export declare function resolveRequestLanguage(request: Request, options: ResolveRequestLanguageOptions): ResolvedRequestLanguage;
+/** The same uncacheable 302 the React server middleware answers with. */
+export declare function createRequestLanguageRedirect(location: string): Response;

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';

package/dist/types/ssrLanguageHandoff.d.ts

@@ -0,0 +1,60 @@
+import { serializePublicData } from '@modern-js/renderer-core/data';
+/**
+ * Renderer-neutral replacement for React's `window._SSR_DATA.data.i18nData`
+ * handoff (see `plugin-i18n/src/runtime/i18n/detection/ssr.ts` and
+ * `pluginSetup.ts`'s `exportServerLngToWindow`). That path only exists
+ * because the React renderer serializes its own `_SSR_DATA` global; native
+ * renderers have no equivalent global, so the language (and an optional
+ * resource subset, for first-paint translation without a network round
+ * trip) travels in its own inline `<script type="application/json">`
+ * element instead, using renderer-core's public-data codec — the same
+ * XSS-safe escaping and size/depth limits used for loader/action data.
+ */
+export declare const I18N_SSR_HANDOFF_ELEMENT_ID = "__modernjs_i18n_ssr__";
+/** `{ [namespace]: { [key]: value } }`, scoped to a single language. */
+export type I18nSsrHandoffResources = Record<string, Record<string, unknown>>;
+export interface I18nSsrHandoffPayload {
+    /** The language the server resolved for this request. */
+    language: string;
+    /** Optional subset of resources for `language`, keyed by namespace. */
+    resources?: I18nSsrHandoffResources;
+}
+export interface SerializeI18nSsrHandoffOptions {
+    /** @default I18N_SSR_HANDOFF_ELEMENT_ID */
+    id?: string;
+    nonce?: string;
+}
+/** An inline data element a native document serializes with its own nonce. */
+export interface I18nSsrHandoffInlineData {
+    readonly id: string;
+    readonly payload: ReturnType<typeof serializePublicData>;
+}
+/**
+ * Encode the handoff as `{ id, payload }` for a native document's
+ * `inlineData` option, which places it before the client modules and stamps
+ * it with the document's CSP nonce.
+ */
+export declare function createI18nSsrHandoffInlineData(payload: I18nSsrHandoffPayload, options?: Pick<SerializeI18nSsrHandoffOptions, 'id'>): I18nSsrHandoffInlineData;
+/**
+ * Serialize the language/resources handoff into a complete, inert
+ * `<script type="application/json">` element string. The native renderer's
+ * document composition decides where to place it (before any module that
+ * reads it on the client).
+ */
+export declare function serializeI18nSsrHandoff(payload: I18nSsrHandoffPayload, options?: SerializeI18nSsrHandoffOptions): string;
+/**
+ * Decode a handoff payload from the raw text content of the element
+ * `serializeI18nSsrHandoff` produced. Pure — no DOM access — so it can be
+ * unit tested or used from a non-browser client runtime directly.
+ * Returns `undefined` for missing, malformed or oversized input rather than
+ * throwing, since a corrupted handoff should fall back to client detection.
+ */
+export declare function readI18nSsrHandoffFromText(text: string | null | undefined): I18nSsrHandoffPayload | undefined;
+/**
+ * Browser convenience wrapper: reads the handoff element from `document` (or
+ * a supplied document-like object) by id and decodes it.
+ */
+export declare function readI18nSsrHandoff(options?: {
+    id?: string;
+    doc?: Pick<Document, 'getElementById'>;
+}): I18nSsrHandoffPayload | undefined;