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

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,34 @@
+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 };
+/** Retire the native proof when its owning request or plugin contract ends. */
+export declare function invalidateNativeI18nSnapshot(instance: unknown): void;
+export interface NativeI18nRewriteSnapshot {
+    language: string;
+    languages: readonly string[];
+    localisedUrls?: LocalisedUrlsOption;
+}
+/** Only rewrites created by the native entry have a portable routing profile. */
+export declare function getNativeI18nRewriteSnapshot(rewrite: unknown): NativeI18nRewriteSnapshot | undefined;
+/** A real fully bundled instance for request-local synchronous providers. */
+export declare function createNativeI18nInstance(initOptions: InitOptions): I18nInstance;
+/** The original effective seed, only while the initialized native proof holds. */
+export declare function getNativeI18nSnapshotSeed(instance: unknown): InitOptions;
+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;

package/dist/types/urlRewrite.d.ts

@@ -0,0 +1,60 @@
+import { type LocalisedUrlsOption } from '@modern-js/runtime-extensions/localised-urls';
+/**
+ * Structurally identical to `@tanstack/router-core`'s `LocationRewriteFunction`.
+ * Defined locally so this module has no runtime dependency on router-core —
+ * any router built on that contract (TanStack Router, `@octanejs/tanstack-router`,
+ * which re-exports it verbatim) can consume the rewrite this module builds.
+ */
+export type I18nLocationRewriteFunction = (args: {
+    url: URL;
+}) => undefined | string | URL;
+/** Structurally identical to `@tanstack/router-core`'s `LocationRewrite`. */
+export interface I18nLocationRewrite {
+    input?: I18nLocationRewriteFunction;
+    output?: I18nLocationRewriteFunction;
+}
+export interface CreateI18nUrlRewriteOptions {
+    /** Supported language codes, e.g. `['en', 'cs']`. */
+    languages: readonly string[];
+    /**
+     * The language an outgoing (internal -> public) location is localized to
+     * when its pathname does not already start with a supported language.
+     */
+    getLanguage: () => string;
+    /**
+     * Canonical-path -> per-language path map; mirrors
+     * `localeDetection.localisedUrls`. Omit for the plain language-prefix policy.
+     */
+    localisedUrls?: LocalisedUrlsOption;
+    /**
+     * Called with the language segment found in an incoming public pathname,
+     * before it is stripped to its canonical form. Not called when the
+     * pathname carries no recognizable language segment.
+     */
+    onLanguageDetected?: (language: string) => void;
+}
+/**
+ * Build a TanStack router-core `LocationRewrite` from the fork's localized-URL
+ * pathname helpers: the router matches against canonical (language-agnostic)
+ * paths internally, while every public href it produces carries the current
+ * language prefix (and any mapped locale slug). An outgoing pathname that
+ * already starts with a supported language keeps that language, which is how
+ * a route mask such as `LocalizedLink`'s publishes another language's URL.
+ *
+ * Pass the result directly as a router's `rewrite` option:
+ *
+ * ```ts
+ * createRouter({ routeTree, rewrite: createI18nUrlRewrite({ languages, getLanguage }) })
+ * ```
+ *
+ * If the router also configures a `basepath`, router-core composes the two
+ * for you — its constructor internally does
+ * `this.rewrite = rewriteBasepath(basepath, caseSensitive, options.rewrite)`
+ * (that helper is an internal, not part of router-core's public exports; the
+ * composition happens automatically, nothing extra to call here). It strips
+ * the basepath before this rewrite's `input` runs, and applies this
+ * rewrite's `output` before the basepath is re-added, so the public URL
+ * shape is `${basepath}${languagePrefix}${canonicalPath}` — e.g.
+ * `/app/en/dashboard` while the router itself only ever sees `/dashboard`.
+ */
+export declare const createI18nUrlRewrite: (options: CreateI18nUrlRewriteOptions) => I18nLocationRewrite;

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@bleedingdev/modern-js-i18n-runtime-extensions",
   "description": "Fork-owned UltraModern.js i18n runtime coordination and localized-route extensions.",
-  "homepage": "https://github.com/BleedingDev/ultramodern.js#readme",
+  "homepage": "https://github.com/ultramodernjs/ultramodern.js#readme",
   "bugs": {
-    "url": "https://github.com/BleedingDev/ultramodern.js/issues"
+    "url": "https://github.com/ultramodernjs/ultramodern.js/issues"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/BleedingDev/ultramodern.js.git",
+    "url": "git+https://github.com/ultramodernjs/ultramodern.js.git",
     "directory": "packages/runtime/i18n-extensions"
   },
   "license": "MIT",
@@ -17,7 +17,7 @@
     "modern.js",
     "i18n"
   ],
-  "version": "3.9.0-ultramodern.9",
+  "version": "3.9.3-ultramodern.10",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.mjs",
@@ -30,6 +30,14 @@
       },
       "default": "./dist/esm/index.mjs"
     },
+    "./router-navigation": {
+      "types": "./dist/types/router-navigation/index.d.ts",
+      "node": {
+        "import": "./dist/esm-node/router-navigation/index.mjs",
+        "require": "./dist/cjs/router-navigation/index.js"
+      },
+      "default": "./dist/esm/router-navigation/index.mjs"
+    },
     "./package.json": "./package.json",
     "./paths": {
       "types": "./dist/types/paths.d.ts",
@@ -38,6 +46,46 @@
         "require": "./dist/cjs/paths.js"
       },
       "default": "./dist/esm/paths.mjs"
+    },
+    "./urlRewrite": {
+      "types": "./dist/types/urlRewrite.d.ts",
+      "node": {
+        "import": "./dist/esm-node/urlRewrite.mjs",
+        "require": "./dist/cjs/urlRewrite.js"
+      },
+      "default": "./dist/esm/urlRewrite.mjs"
+    },
+    "./ssrLanguageHandoff": {
+      "types": "./dist/types/ssrLanguageHandoff.d.ts",
+      "node": {
+        "import": "./dist/esm-node/ssrLanguageHandoff.mjs",
+        "require": "./dist/cjs/ssrLanguageHandoff.js"
+      },
+      "default": "./dist/esm/ssrLanguageHandoff.mjs"
+    },
+    "./language-sync/controller": {
+      "types": "./dist/types/language-sync/controller.d.ts",
+      "node": {
+        "import": "./dist/esm-node/language-sync/controller.mjs",
+        "require": "./dist/cjs/language-sync/controller.js"
+      },
+      "default": "./dist/esm/language-sync/controller.mjs"
+    },
+    "./request-language": {
+      "types": "./dist/types/requestLanguage.d.ts",
+      "node": {
+        "import": "./dist/esm-node/requestLanguage.mjs",
+        "require": "./dist/cjs/requestLanguage.js"
+      },
+      "default": "./dist/esm/requestLanguage.mjs"
+    },
+    "./native": {
+      "types": "./dist/types/native.d.ts",
+      "node": {
+        "import": "./dist/esm-node/native.mjs",
+        "require": "./dist/cjs/native.js"
+      },
+      "default": "./dist/esm/native.mjs"
     }
   },
   "typesVersions": {
@@ -48,36 +96,75 @@
       ],
       "paths": [
         "./dist/types/paths.d.ts"
+      ],
+      "router-navigation": [
+        "./dist/types/router-navigation/index.d.ts"
+      ],
+      "urlRewrite": [
+        "./dist/types/urlRewrite.d.ts"
+      ],
+      "ssrLanguageHandoff": [
+        "./dist/types/ssrLanguageHandoff.d.ts"
+      ],
+      "language-sync/controller": [
+        "./dist/types/language-sync/controller.d.ts"
+      ],
+      "request-language": [
+        "./dist/types/requestLanguage.d.ts"
+      ],
+      "native": [
+        "./dist/types/native.d.ts"
       ]
     }
   },
   "engines": {
-    "node": ">=26.7.0"
+    "node": ">=26.12.0"
   },
   "dependencies": {
-    "@modern-js/runtime-utils": "npm:@bleedingdev/modern-js-runtime-utils@3.9.0-ultramodern.9",
+    "@modern-js/renderer-core": "npm:@bleedingdev/modern-js-renderer-core@3.9.3-ultramodern.10",
+    "@modern-js/runtime-extensions": "npm:@bleedingdev/modern-js-runtime-extensions@3.9.3-ultramodern.10",
+    "@modern-js/runtime-utils": "npm:@bleedingdev/modern-js-runtime-utils@3.9.3-ultramodern.10",
     "i18next-browser-languagedetector": "^8.2.1"
   },
   "peerDependencies": {
-    "@modern-js/runtime": "3.9.0-ultramodern.9",
-    "react": "^19.2.8"
+    "@modern-js/runtime": "3.9.3-ultramodern.10",
+    "i18next": ">=25.7.4",
+    "react": "^19.3.1"
+  },
+  "peerDependenciesMeta": {
+    "@modern-js/runtime": {
+      "optional": true
+    },
+    "i18next": {
+      "optional": true
+    },
+    "react": {
+      "optional": true
+    }
   },
   "devDependencies": {
-    "@modern-js/runtime": "npm:@bleedingdev/modern-js-runtime@3.9.0-ultramodern.9",
-    "@rslib/core": "1.0.0",
+    "@modern-js/runtime": "npm:@bleedingdev/modern-js-runtime@3.9.3-ultramodern.10",
+    "@rslib/core": "1.0.3",
     "@scripts/rstest-config": "2.66.0",
-    "@types/node": "^26.4.1",
-    "@typescript/native-preview": "7.0.0-dev.20260707.2",
-    "react": "^19.2.8",
-    "react-dom": "^19.2.8"
+    "@types/node": "^26.6.5",
+    "i18next": "26.4.6",
+    "react": "^19.3.1",
+    "react-dom": "^19.3.1"
   },
   "sideEffects": false,
   "publishConfig": {
     "access": "public"
   },
+  "files": [
+    "dist",
+    "src"
+  ],
   "scripts": {
     "dev": "rslib build --watch",
     "build": "rslib build",
-    "test": "rstest --passWithNoTests"
+    "test": "rstest"
+  },
+  "ultramodern": {
+    "sourceName": "@modern-js/i18n-runtime-extensions"
   }
 }

package/src/index.ts

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

package/src/localeRedirectPolicy.ts

@@ -1,11 +1,11 @@
-import type { LocalisedUrlsOption } from './localisedUrls/index';
+import type { LocalisedUrlsOption } from '@modern-js/runtime-extensions/localised-urls';
 import {
   isDefaultLocaleRedirectSkipPath,
   localiseTargetPathname,
   matchesPathPrefix,
   shouldSkipLocaleRedirect,
   stripLanguagePrefix,
-} from './localisedUrls/index';
+} from '@modern-js/runtime-extensions/localised-urls';
 
 interface LocaleRedirectRequest {
   url: string;