@bleedingdev/modern-js-i18n-integration 0.0.0 → 3.9.0-ultramodern.6

package/dist/esm-node/federation/boundary.mjs

@@ -0,0 +1,63 @@
+import "node:module";
+import { jsx } from "react/jsx-runtime";
+import { ModernI18nContext, ModernI18nProvider, ReactI18nextProviderContext, getActualI18nextInstance } from "@modern-js/plugin-i18n/runtime/consumer";
+import { useContext, useMemo } from "react";
+const FederatedI18nBoundary = ({ children, defaultNamespace, fallbackLanguage, resources, supportedLanguages })=>{
+    const parent = useContext(ModernI18nContext);
+    const I18nextProvider = useContext(ReactI18nextProviderContext);
+    if (!parent) throw new Error('FederatedI18nBoundary must be used within ModernI18nProvider');
+    const languages = supportedLanguages ?? parent.languages ?? Object.keys(resources);
+    const scopedInstance = useMemo(()=>{
+        const parentInstance = getActualI18nextInstance(parent.i18nInstance);
+        const clone = parentInstance.cloneInstance?.({
+            defaultNS: defaultNamespace,
+            fallbackLng: fallbackLanguage ?? languages[0] ?? parent.language,
+            forkResourceStore: true,
+            initImmediate: false,
+            lng: parent.language,
+            ns: [
+                defaultNamespace
+            ],
+            resources,
+            supportedLngs: languages
+        });
+        if (!clone) throw new Error('FederatedI18nBoundary requires an i18n instance with cloneInstance support');
+        const resourceStore = clone.store;
+        const parentResourceStore = parentInstance.store;
+        const sharesNestedResourceState = Object.entries(resourceStore?.data ?? {}).some(([language, namespaces])=>{
+            const parentNamespaces = parentResourceStore?.data?.[language];
+            return namespaces === parentNamespaces || Object.entries(namespaces).some(([namespace, resource])=>null !== resource && 'object' == typeof resource && resource === parentNamespaces?.[namespace]);
+        });
+        if (clone === parentInstance || resourceStore === parentResourceStore || resourceStore?.data === parentResourceStore?.data || sharesNestedResourceState) throw new Error('FederatedI18nBoundary cloneInstance did not isolate the host resource store');
+        if (!resourceStore?.addResourceBundle || !clone.removeResourceBundle || !resourceStore.data) throw new Error('FederatedI18nBoundary requires an isolated mutable i18n resource store');
+        for (const [language, namespaces] of Object.entries(resourceStore.data))for (const namespace of Object.keys(namespaces))clone.removeResourceBundle(language, namespace);
+        for (const [language, namespaces] of Object.entries(resources))for (const [namespace, resource] of Object.entries(namespaces))resourceStore.addResourceBundle(language, namespace, resource, true, true);
+        return clone;
+    }, [
+        defaultNamespace,
+        fallbackLanguage,
+        languages,
+        parent.i18nInstance,
+        parent.language,
+        resources
+    ]);
+    const value = useMemo(()=>({
+            ...parent,
+            i18nInstance: scopedInstance,
+            language: parent.language,
+            languages
+        }), [
+        languages,
+        parent,
+        scopedInstance
+    ]);
+    const scopedContent = /*#__PURE__*/ jsx(ModernI18nProvider, {
+        value: value,
+        children: children
+    });
+    return I18nextProvider ? /*#__PURE__*/ jsx(I18nextProvider, {
+        i18n: scopedInstance,
+        children: scopedContent
+    }) : scopedContent;
+};
+export { FederatedI18nBoundary };

package/dist/esm-node/federation/registration.mjs

@@ -0,0 +1,6 @@
+import "node:module";
+import { FederatedI18nBoundary } from "./boundary.mjs";
+function registerFederatedI18nBoundary(api) {
+    api.resolveComponent((component, { name })=>'i18n.FederatedI18nBoundary' === name ? FederatedI18nBoundary : component);
+}
+export { registerFederatedI18nBoundary };

package/dist/esm-node/languageSynchronization.mjs

@@ -0,0 +1,7 @@
+import "node:module";
+import { useLanguageSync } from "@modern-js/i18n-runtime-extensions";
+const I18nLanguageSynchronization = ({ i18nInstance, localePathRedirect, languages, pathname, prevLangRef, setLang, children })=>{
+    const synchronizeLanguage = useLanguageSync(i18nInstance, localePathRedirect, languages, pathname, prevLangRef, setLang);
+    return children(synchronizeLanguage);
+};
+export { I18nLanguageSynchronization };

package/dist/esm-node/navigation.mjs

@@ -0,0 +1,183 @@
+import "node:module";
+import { jsx } from "react/jsx-runtime";
+import { I18nNavigationProvider, useNativeI18nRouterAdapter } from "@modern-js/plugin-i18n/runtime/no-react-i18next";
+import { RuntimeContext, isBrowser } from "@modern-js/runtime";
+import { InternalRuntimeContext } from "@modern-js/runtime/context";
+import { getRouterRuntimeState } from "@modern-js/runtime-extensions/router-state";
+import { useCallback, useContext, useSyncExternalStore } from "react";
+const normalizeUrlPart = (value, prefix)=>{
+    if ('string' != typeof value || !value) return '';
+    return value.startsWith(prefix) ? value : `${prefix}${value}`;
+};
+const normalizeLocation = (location)=>{
+    if (!location || 'object' != typeof location) return null;
+    const locationValue = location;
+    if ('string' != typeof locationValue.pathname) return null;
+    return {
+        pathname: locationValue.pathname,
+        search: normalizeUrlPart('string' == typeof locationValue.search ? locationValue.search : locationValue.searchStr, '?'),
+        hash: normalizeUrlPart(locationValue.hash, '#')
+    };
+};
+const getWindowLocation = ()=>{
+    if (!isBrowser()) return null;
+    return {
+        pathname: window.location.pathname,
+        search: window.location.search,
+        hash: window.location.hash
+    };
+};
+const getRouterFramework = (runtimeContext, internalContext, inReactRouter)=>{
+    const framework = getRouterRuntimeState(internalContext)?.framework || getRouterRuntimeState(runtimeContext)?.framework;
+    if (framework) return framework;
+    if (internalContext.router?.useRouter || runtimeContext.router?.useRouter) return 'tanstack';
+    if (internalContext.router?.useLocation || internalContext.router?.useHref || runtimeContext.router?.useLocation || runtimeContext.router?.useHref) return 'react-router';
+    if (inReactRouter) return 'react-router';
+};
+const getRouterInstance = (internalContext, contextRouter)=>{
+    if (contextRouter) return contextRouter;
+    const router = getRouterRuntimeState(internalContext)?.instance;
+    if (!router || 'object' != typeof router) return null;
+    return router;
+};
+const getRouterStateLocation = (internalContext, contextRouter)=>{
+    const router = getRouterInstance(internalContext, contextRouter);
+    return normalizeLocation(router?.stores?.location?.get?.()) || normalizeLocation(router?.state?.location);
+};
+const getRouterParams = (internalContext, contextRouter)=>{
+    const router = getRouterInstance(internalContext, contextRouter);
+    const matches = router?.stores?.matches?.get?.() || router?.state?.matches;
+    if (!Array.isArray(matches)) return {};
+    return matches.reduce((params, match)=>{
+        if (match?.params) Object.assign(params, match.params);
+        return params;
+    }, {});
+};
+const getRouterSnapshot = (internalContext, contextRouter)=>{
+    const location = getRouterStateLocation(internalContext, contextRouter);
+    const params = getRouterParams(internalContext, contextRouter);
+    return JSON.stringify([
+        location?.pathname ?? '',
+        location?.search ?? '',
+        location?.hash ?? '',
+        Object.entries(params).sort(([left], [right])=>left.localeCompare(right))
+    ]);
+};
+const useIntegratedRouterAdapter = ()=>{
+    const runtimeContext = useContext(RuntimeContext);
+    const internalContext = useContext(InternalRuntimeContext);
+    const routerApi = internalContext.router || runtimeContext.router;
+    const native = useNativeI18nRouterAdapter();
+    const inReactRouter = native.hasRouter;
+    const reactRouterNavigate = native.navigate;
+    const reactRouterLocation = inReactRouter ? native.location : null;
+    const reactRouterParams = native.params;
+    const framework = getRouterFramework(runtimeContext, internalContext, inReactRouter);
+    const contextUseRouter = inReactRouter || 'tanstack' !== framework ? void 0 : internalContext.router?.useRouter || runtimeContext.router?.useRouter;
+    const contextRouter = contextUseRouter ? contextUseRouter({
+        warn: false
+    }) : null;
+    const hasRouter = 'tanstack' === framework || 'react-router' === framework || Boolean(reactRouterNavigate);
+    const subscribeToRouter = useCallback((update)=>{
+        const router = getRouterInstance(internalContext, contextRouter);
+        if (!router) return ()=>void 0;
+        const unsubscribers = [];
+        if ('react-router' === framework && !inReactRouter && 'function' == typeof router.subscribe) {
+            const subscribe = router.subscribe;
+            const unsubscribe = subscribe.call(router, update);
+            if ('function' == typeof unsubscribe) unsubscribers.push(unsubscribe);
+        }
+        if ('tanstack' === framework && 'function' == typeof router.stores?.location?.subscribe) {
+            const unsubscribe = router.stores.location.subscribe(update);
+            if ('function' == typeof unsubscribe) unsubscribers.push(unsubscribe);
+        }
+        if ('tanstack' === framework && 'function' == typeof router.subscribe) {
+            const subscribe = router.subscribe;
+            for (const eventType of [
+                'onBeforeNavigate',
+                'onBeforeLoad'
+            ]){
+                const unsubscribe = subscribe.call(router, eventType, update);
+                if ('function' == typeof unsubscribe) unsubscribers.push(unsubscribe);
+            }
+        }
+        return ()=>{
+            for (const unsubscribe of unsubscribers)unsubscribe();
+        };
+    }, [
+        contextRouter,
+        framework,
+        inReactRouter,
+        internalContext
+    ]);
+    const getSnapshot = useCallback(()=>getRouterSnapshot(internalContext, contextRouter), [
+        contextRouter,
+        internalContext
+    ]);
+    useSyncExternalStore(subscribeToRouter, getSnapshot, getSnapshot);
+    const navigate = useCallback((href, options)=>{
+        const router = getRouterInstance(internalContext, contextRouter);
+        const activeFramework = getRouterFramework(runtimeContext, internalContext, inReactRouter);
+        if ('tanstack' === activeFramework) {
+            if ('function' == typeof router?.navigate) return router.navigate({
+                to: href,
+                replace: options?.replace,
+                ...options?.state === void 0 ? {} : {
+                    state: options.state
+                }
+            });
+            throw new Error('TanStack router instance is not available.');
+        }
+        if (reactRouterNavigate) return reactRouterNavigate(href, options);
+        if ('react-router' === activeFramework) {
+            if ('function' == typeof router?.navigate) return router.navigate(href, options);
+            throw new Error('React Router instance is not available.');
+        }
+    }, [
+        contextRouter,
+        internalContext,
+        inReactRouter,
+        reactRouterNavigate,
+        runtimeContext
+    ]);
+    const location = (reactRouterLocation ? normalizeLocation(reactRouterLocation) : getRouterStateLocation(internalContext, contextRouter)) || getWindowLocation();
+    const params = inReactRouter ? reactRouterParams : getRouterParams(internalContext, contextRouter);
+    const Link = 'tanstack' === framework ? internalContext.router?.Link || runtimeContext.router?.Link || null : 'react-router' === framework || inReactRouter ? routerApi?.Link ?? null : null;
+    return {
+        framework,
+        hasRouter,
+        location,
+        navigate: hasRouter ? navigate : null,
+        Link,
+        params,
+        ...'tanstack' === framework ? {
+            createLinkProps: createTanstackLinkProps
+        } : {}
+    };
+};
+const createTanstackLinkProps = (target)=>{
+    const preload = void 0 !== target.preload ? target.preload : 'none' === target.prefetch ? false : target.prefetch;
+    return {
+        to: target.pathname,
+        ...target.search ? {
+            search: target.search
+        } : {},
+        ...target.hash ? {
+            hash: target.hash
+        } : {},
+        ...void 0 === target.hashScrollIntoView ? {} : {
+            hashScrollIntoView: target.hashScrollIntoView
+        },
+        ...void 0 === preload ? {} : {
+            preload
+        }
+    };
+};
+const I18nRouterNavigationProvider = ({ children })=>{
+    const value = useIntegratedRouterAdapter();
+    return /*#__PURE__*/ jsx(I18nNavigationProvider, {
+        value: value,
+        children: children
+    });
+};
+export { I18nRouterNavigationProvider };

package/dist/esm-node/options.mjs

@@ -0,0 +1 @@
+import "node:module";

package/dist/esm-node/runtime-no-react-i18next.mjs

@@ -0,0 +1,7 @@
+import "node:module";
+import { i18nPlugin } from "@modern-js/plugin-i18n/runtime/no-react-i18next";
+import { composeI18nPlugin } from "./runtimeComposition.mjs";
+const runtime_no_react_i18next_i18nPlugin = composeI18nPlugin(i18nPlugin);
+const runtime_no_react_i18next = runtime_no_react_i18next_i18nPlugin;
+export default runtime_no_react_i18next;
+export { runtime_no_react_i18next_i18nPlugin as i18nPlugin };

package/dist/esm-node/runtime.mjs

@@ -0,0 +1,7 @@
+import "node:module";
+import { i18nPlugin } from "@modern-js/plugin-i18n/runtime";
+import { composeI18nPlugin } from "./runtimeComposition.mjs";
+const runtime_i18nPlugin = composeI18nPlugin(i18nPlugin);
+const runtime = runtime_i18nPlugin;
+export default runtime;
+export { runtime_i18nPlugin as i18nPlugin };

package/dist/esm-node/runtimeComposition.mjs

@@ -0,0 +1,23 @@
+import "node:module";
+import { registerFederatedI18nBoundary } from "./federation/registration.mjs";
+import { I18nLanguageSynchronization } from "./languageSynchronization.mjs";
+import { I18nRouterNavigationProvider } from "./navigation.mjs";
+import { createI18nUrlStrategy } from "./urlStrategy.mjs";
+const composeI18nPlugin = (nativeI18nPlugin)=>(options = {})=>{
+        const { localisedUrls, localeDetectionByEntry: _entryOptions, ...nativeLocaleDetection } = options.localeDetection ?? {};
+        const native = nativeI18nPlugin({
+            ...options,
+            localeDetection: nativeLocaleDetection,
+            urlStrategy: options.urlStrategy ?? createI18nUrlStrategy(localisedUrls),
+            NavigationProvider: options.NavigationProvider ?? I18nRouterNavigationProvider,
+            LanguageSynchronization: options.LanguageSynchronization ?? I18nLanguageSynchronization
+        });
+        return {
+            ...native,
+            setup (api) {
+                registerFederatedI18nBoundary(api);
+                return native.setup?.(api);
+            }
+        };
+    };
+export { composeI18nPlugin };

package/dist/esm-node/server.mjs

@@ -0,0 +1,11 @@
+import "node:module";
+import { getLocaleDetectionOptions } from "@modern-js/plugin-i18n/config";
+import { i18nServerPlugin } from "@modern-js/plugin-i18n/server";
+import { createI18nUrlStrategy } from "./urlStrategy.mjs";
+const server_i18nServerPlugin = (options)=>i18nServerPlugin({
+        ...options,
+        resolveUrlStrategy: options.resolveUrlStrategy ?? ((entryName)=>createI18nUrlStrategy(options.localeDetection ? getLocaleDetectionOptions(entryName, options.localeDetection).localisedUrls : void 0))
+    });
+const server = server_i18nServerPlugin;
+export default server;
+export { server_i18nServerPlugin as i18nServerPlugin };

package/dist/esm-node/urlStrategy.mjs

@@ -0,0 +1,14 @@
+import "node:module";
+import { canonicalTargetPathname, isDefaultLocaleRedirectSkipPath, localiseTargetPathname } from "@modern-js/i18n-runtime-extensions";
+const createI18nUrlStrategy = (localisedUrls)=>({
+        localizePathname: (pathname, language, languages)=>localiseTargetPathname(pathname, language, [
+                ...languages
+            ], localisedUrls),
+        canonicalPathname: (pathname, languages)=>canonicalTargetPathname(pathname, [
+                ...languages
+            ], localisedUrls),
+        shouldSkipRedirect: (pathname, languages)=>isDefaultLocaleRedirectSkipPath(pathname, [
+                ...languages
+            ])
+    });
+export { createI18nUrlStrategy };

package/dist/types/cli.d.ts

@@ -0,0 +1,4 @@
+import type { AppTools, CliPlugin } from '@modern-js/app-tools';
+/** Compose fork policy with the native plugin's own descriptor generation. */
+export declare const ultramodernI18nIntegrationPlugin: () => CliPlugin<AppTools>;
+export default ultramodernI18nIntegrationPlugin;

package/dist/types/federation/boundary.d.ts

@@ -0,0 +1,9 @@
+import { type FederatedI18nBoundaryProps } from '@modern-js/plugin-i18n/runtime/consumer';
+import { type FC } from 'react';
+export type { FederatedI18nBoundaryProps } from '@modern-js/plugin-i18n/runtime/consumer';
+/**
+ * Keeps a federated surface's translation resources inside its delivery unit.
+ * The host supplies only the active language; the remote owns and versions the
+ * resources used below this boundary.
+ */
+export declare const FederatedI18nBoundary: FC<FederatedI18nBoundaryProps>;

package/dist/types/federation/registration.d.ts

@@ -0,0 +1,2 @@
+import type { RuntimePluginAPI } from '@modern-js/plugin/runtime';
+export declare function registerFederatedI18nBoundary(api: RuntimePluginAPI<{}>): void;

package/dist/types/languageSynchronization.d.ts

@@ -0,0 +1,3 @@
+import type { I18nLanguageSynchronizationProps } from '@modern-js/plugin-i18n/runtime/no-react-i18next';
+/** Bind the shared controller to this native provider's instance and state. */
+export declare const I18nLanguageSynchronization: ({ i18nInstance, localePathRedirect, languages, pathname, prevLangRef, setLang, children, }: I18nLanguageSynchronizationProps) => import("react").ReactNode;

package/dist/types/navigation.d.ts

@@ -0,0 +1,3 @@
+import type React from 'react';
+/** Supplies the actual selected router; native links still render its Link. */
+export declare const I18nRouterNavigationProvider: ({ children, }: React.PropsWithChildren) => React.JSX.Element;

package/dist/types/options.d.ts

@@ -0,0 +1,13 @@
+import type { LocalisedUrlsOption } from '@modern-js/i18n-runtime-extensions';
+import type { I18nPluginOptions as NativeRuntimeOptions } from '@modern-js/plugin-i18n/runtime/no-react-i18next';
+import type { I18nPluginOptions as NativeServerOptions } from '@modern-js/plugin-i18n/server';
+export type IntegratedLocaleDetectionOptions = NonNullable<NativeRuntimeOptions['localeDetection']> & {
+    localisedUrls?: LocalisedUrlsOption;
+    localeDetectionByEntry?: Record<string, IntegratedLocaleDetectionOptions>;
+};
+export type I18nPluginOptions = NativeRuntimeOptions & {
+    localeDetection?: IntegratedLocaleDetectionOptions;
+};
+export type I18nServerPluginOptions = NativeServerOptions & {
+    localeDetection: IntegratedLocaleDetectionOptions;
+};

package/dist/types/runtime-no-react-i18next.d.ts

@@ -0,0 +1,2 @@
+export declare const i18nPlugin: (options?: import("./options.js").I18nPluginOptions) => import("@modern-js/runtime").RuntimePlugin;
+export default i18nPlugin;

package/dist/types/runtime.d.ts

@@ -0,0 +1,2 @@
+export declare const i18nPlugin: (options?: import("./options.js").I18nPluginOptions) => import("@modern-js/runtime").RuntimePlugin;
+export default i18nPlugin;

package/dist/types/runtimeComposition.d.ts

@@ -0,0 +1,4 @@
+import type { I18nPluginOptions as NativeI18nPluginOptions } from '@modern-js/plugin-i18n/runtime/no-react-i18next';
+import type { RuntimePlugin } from '@modern-js/runtime';
+import type { I18nPluginOptions } from './options.js';
+export declare const composeI18nPlugin: (nativeI18nPlugin: (options: NativeI18nPluginOptions) => RuntimePlugin) => (options?: I18nPluginOptions) => RuntimePlugin;

package/dist/types/server.d.ts

@@ -0,0 +1,3 @@
+import type { I18nServerPluginOptions } from './options.js';
+export declare const i18nServerPlugin: (options: I18nServerPluginOptions) => import("@modern-js/server-core").ServerPlugin;
+export default i18nServerPlugin;

package/dist/types/urlStrategy.d.ts

@@ -0,0 +1,4 @@
+import { type LocalisedUrlsOption } from '@modern-js/i18n-runtime-extensions';
+import type { I18nUrlStrategy } from '@modern-js/plugin-i18n/runtime/no-react-i18next';
+/** Each integration owns its map; no process-wide configuration is installed. */
+export declare const createI18nUrlStrategy: (localisedUrls?: LocalisedUrlsOption) => I18nUrlStrategy;

package/package.json

@@ -1,16 +1,150 @@
 {
   "name": "@bleedingdev/modern-js-i18n-integration",
-  "version": "0.0.0",
-  "description": "Package-name registration for the forthcoming UltraModern.js release. This setup version contains no runtime implementation.",
-  "license": "MIT",
+  "description": "UltraModern.js localized routing and federated resource integration through native Modern.js i18n plugins.",
+  "homepage": "https://github.com/BleedingDev/ultramodern.js#readme",
+  "bugs": {
+    "url": "https://github.com/BleedingDev/ultramodern.js/issues"
+  },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/BleedingDev/ultramodern.js.git"
+    "url": "git+https://github.com/BleedingDev/ultramodern.js.git",
+    "directory": "packages/runtime/i18n-integration"
   },
+  "license": "MIT",
+  "version": "3.9.0-ultramodern.6",
   "files": [
-    "README.md"
+    "dist",
+    "src"
   ],
+  "engines": {
+    "node": ">=26.7.0"
+  },
+  "types": "./dist/types/cli.d.ts",
+  "main": "./dist/cjs/cli.js",
+  "exports": {
+    ".": {
+      "types": "./dist/types/cli.d.ts",
+      "node": {
+        "import": "./dist/esm-node/cli.mjs",
+        "require": "./dist/cjs/cli.js"
+      },
+      "default": "./dist/cjs/cli.js"
+    },
+    "./cli": {
+      "types": "./dist/types/cli.d.ts",
+      "node": {
+        "import": "./dist/esm-node/cli.mjs",
+        "require": "./dist/cjs/cli.js"
+      },
+      "default": "./dist/cjs/cli.js"
+    },
+    "./runtime": {
+      "types": "./dist/types/runtime.d.ts",
+      "node": {
+        "import": "./dist/esm-node/runtime.mjs",
+        "require": "./dist/cjs/runtime.js"
+      },
+      "default": "./dist/esm/runtime.mjs"
+    },
+    "./runtime/no-react-i18next": {
+      "types": "./dist/types/runtime-no-react-i18next.d.ts",
+      "node": {
+        "import": "./dist/esm-node/runtime-no-react-i18next.mjs",
+        "require": "./dist/cjs/runtime-no-react-i18next.js"
+      },
+      "default": "./dist/esm/runtime-no-react-i18next.mjs"
+    },
+    "./server": {
+      "types": "./dist/types/server.d.ts",
+      "node": {
+        "import": "./dist/esm-node/server.mjs",
+        "require": "./dist/cjs/server.js"
+      },
+      "default": "./dist/cjs/server.js"
+    },
+    "./federation": {
+      "types": "./dist/types/federation/boundary.d.ts",
+      "node": {
+        "import": "./dist/esm-node/federation/boundary.mjs",
+        "require": "./dist/cjs/federation/boundary.js"
+      },
+      "default": "./dist/esm/federation/boundary.mjs"
+    },
+    "./package.json": "./package.json",
+    "./options": {
+      "types": "./dist/types/options.d.ts",
+      "node": {
+        "import": "./dist/esm-node/options.mjs",
+        "require": "./dist/cjs/options.js"
+      },
+      "default": "./dist/esm/options.mjs"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      ".": [
+        "./dist/types/cli.d.ts"
+      ],
+      "cli": [
+        "./dist/types/cli.d.ts"
+      ],
+      "runtime": [
+        "./dist/types/runtime.d.ts"
+      ],
+      "runtime/no-react-i18next": [
+        "./dist/types/runtime-no-react-i18next.d.ts"
+      ],
+      "server": [
+        "./dist/types/server.d.ts"
+      ],
+      "federation": [
+        "./dist/types/federation/boundary.d.ts"
+      ],
+      "options": [
+        "./dist/types/options.d.ts"
+      ]
+    }
+  },
+  "dependencies": {
+    "@modern-js/i18n-runtime-extensions": "npm:@bleedingdev/modern-js-i18n-runtime-extensions@3.9.0-ultramodern.6",
+    "@modern-js/plugin": "npm:@bleedingdev/modern-js-plugin@3.9.0-ultramodern.6",
+    "@modern-js/plugin-i18n": "npm:@bleedingdev/modern-js-plugin-i18n@3.9.0-ultramodern.6",
+    "@modern-js/runtime-extensions": "npm:@bleedingdev/modern-js-runtime-extensions@3.9.0-ultramodern.6",
+    "@modern-js/server-runtime": "npm:@bleedingdev/modern-js-server-runtime@3.9.0-ultramodern.6",
+    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.9.0-ultramodern.6"
+  },
+  "peerDependencies": {
+    "@modern-js/app-tools": "3.9.0-ultramodern.6",
+    "@modern-js/runtime": "3.9.0-ultramodern.6",
+    "react": "^19.2.8"
+  },
+  "peerDependenciesMeta": {},
+  "optionalDependencies": {},
+  "devDependencies": {
+    "@modern-js/app-tools": "npm:@bleedingdev/modern-js-app-tools@3.9.0-ultramodern.6",
+    "@modern-js/runtime": "npm:@bleedingdev/modern-js-runtime@3.9.0-ultramodern.6",
+    "@modern-js/tsconfig": "npm:@bleedingdev/modern-js-tsconfig@3.9.0-ultramodern.6",
+    "@rslib/core": "1.0.0",
+    "@rstest/core": "0.11.12",
+    "@scripts/rstest-config": "2.66.0",
+    "@types/node": "^26.4.1",
+    "@types/react": "^19.2.18",
+    "@types/react-dom": "^19.2.7",
+    "@typescript/native-preview": "7.0.0-dev.20260707.2",
+    "esbuild": "^0.28.2",
+    "i18next": "26.4.2",
+    "react": "^19.2.8",
+    "react-dom": "^19.2.8",
+    "react-i18next": "17.0.13",
+    "typescript": "^7.0.2"
+  },
+  "sideEffects": false,
   "publishConfig": {
     "access": "public"
+  },
+  "scripts": {
+    "dev": "rslib build --watch",
+    "build": "rslib build",
+    "test": "rstest"
   }
 }

package/src/cli.ts

@@ -0,0 +1,72 @@
+import type { AppTools, CliPlugin } from '@modern-js/app-tools';
+import {
+  applyLocalisedUrlsToRoutes,
+  resolveLocalisedUrlsConfig,
+} from '@modern-js/i18n-runtime-extensions';
+import type { NestedRouteForCli, PageRoute } from '@modern-js/types';
+import type { I18nPluginOptions } from './options';
+
+const runtimePaths = new Map([
+  ['@modern-js/plugin-i18n/runtime', '@modern-js/i18n-integration/runtime'],
+  [
+    '@modern-js/plugin-i18n/runtime/no-react-i18next',
+    '@modern-js/i18n-integration/runtime/no-react-i18next',
+  ],
+]);
+const integrationRuntimePaths = new Set(runtimePaths.values());
+
+/** Compose fork policy with the native plugin's own descriptor generation. */
+export const ultramodernI18nIntegrationPlugin = (): CliPlugin<AppTools> => ({
+  name: '@modern-js/i18n-integration',
+  pre: ['@modern-js/plugin-i18n'],
+  setup(api) {
+    api._internalRuntimePlugins(({ entrypoint, plugins }) => ({
+      entrypoint,
+      plugins: plugins.map(plugin => {
+        const path = runtimePaths.get(plugin.path);
+        return path ? { ...plugin, path } : plugin;
+      }),
+    }));
+
+    api._internalServerPlugins(({ plugins }) => ({
+      plugins: plugins.map(plugin =>
+        plugin.name === '@modern-js/plugin-i18n/server'
+          ? { ...plugin, name: '@modern-js/i18n-integration/server' }
+          : plugin,
+      ),
+    }));
+
+    api.modifyFileSystemRoutes(async ({ entrypoint, routes }) => {
+      // Route generation may precede runtime module generation. Resolve the
+      // native descriptor with a fresh local output list; this hook never calls
+      // route generation and cannot append to a later emitted descriptor list.
+      const { plugins } = await api.getHooks()._internalRuntimePlugins.call({
+        entrypoint,
+        plugins: [],
+      });
+      const descriptor = plugins.find(plugin =>
+        integrationRuntimePaths.has(plugin.path),
+      );
+      const config = descriptor?.config as I18nPluginOptions | undefined;
+      const {
+        localePathRedirect,
+        languages = [],
+        localisedUrls,
+      } = config?.localeDetection ?? {};
+      const resolved = resolveLocalisedUrlsConfig(localisedUrls);
+      if (!localePathRedirect || !languages.length || !resolved.enabled) {
+        return { entrypoint, routes };
+      }
+      return {
+        entrypoint,
+        routes: applyLocalisedUrlsToRoutes(
+          routes as (NestedRouteForCli | PageRoute)[],
+          languages,
+          resolved.map,
+        ) as (NestedRouteForCli | PageRoute)[],
+      };
+    });
+  },
+});
+
+export default ultramodernI18nIntegrationPlugin;