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

package/dist/cjs/runtimeComposition.js

@@ -0,0 +1,60 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    composeI18nPlugin: ()=>composeI18nPlugin
+});
+const registration_js_namespaceObject = require("./federation/registration.js");
+const external_languageSynchronization_js_namespaceObject = require("./languageSynchronization.js");
+const external_navigation_js_namespaceObject = require("./navigation.js");
+const external_urlStrategy_js_namespaceObject = require("./urlStrategy.js");
+const composeI18nPlugin = (nativeI18nPlugin)=>(options = {})=>{
+        const { localisedUrls, localeDetectionByEntry: _entryOptions, ...nativeLocaleDetection } = options.localeDetection ?? {};
+        const native = nativeI18nPlugin({
+            ...options,
+            localeDetection: nativeLocaleDetection,
+            urlStrategy: options.urlStrategy ?? (0, external_urlStrategy_js_namespaceObject.createI18nUrlStrategy)(localisedUrls),
+            NavigationProvider: options.NavigationProvider ?? external_navigation_js_namespaceObject.I18nRouterNavigationProvider,
+            LanguageSynchronization: options.LanguageSynchronization ?? external_languageSynchronization_js_namespaceObject.I18nLanguageSynchronization
+        });
+        return {
+            ...native,
+            setup (api) {
+                (0, registration_js_namespaceObject.registerFederatedI18nBoundary)(api);
+                return native.setup?.(api);
+            }
+        };
+    };
+exports.composeI18nPlugin = __webpack_exports__.composeI18nPlugin;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "composeI18nPlugin"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/server.js

@@ -0,0 +1,50 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    default: ()=>server,
+    i18nServerPlugin: ()=>i18nServerPlugin
+});
+const config_namespaceObject = require("@modern-js/plugin-i18n/config");
+const server_namespaceObject = require("@modern-js/plugin-i18n/server");
+const external_urlStrategy_js_namespaceObject = require("./urlStrategy.js");
+const i18nServerPlugin = (options)=>(0, server_namespaceObject.i18nServerPlugin)({
+        ...options,
+        resolveUrlStrategy: options.resolveUrlStrategy ?? ((entryName)=>(0, external_urlStrategy_js_namespaceObject.createI18nUrlStrategy)(options.localeDetection ? (0, config_namespaceObject.getLocaleDetectionOptions)(entryName, options.localeDetection).localisedUrls : void 0))
+    });
+const server = i18nServerPlugin;
+exports["default"] = __webpack_exports__["default"];
+exports.i18nServerPlugin = __webpack_exports__.i18nServerPlugin;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "default",
+    "i18nServerPlugin"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/urlStrategy.js

@@ -0,0 +1,51 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createI18nUrlStrategy: ()=>createI18nUrlStrategy
+});
+const i18n_runtime_extensions_namespaceObject = require("@modern-js/i18n-runtime-extensions");
+const createI18nUrlStrategy = (localisedUrls)=>({
+        localizePathname: (pathname, language, languages)=>(0, i18n_runtime_extensions_namespaceObject.localiseTargetPathname)(pathname, language, [
+                ...languages
+            ], localisedUrls),
+        canonicalPathname: (pathname, languages)=>(0, i18n_runtime_extensions_namespaceObject.canonicalTargetPathname)(pathname, [
+                ...languages
+            ], localisedUrls),
+        shouldSkipRedirect: (pathname, languages)=>(0, i18n_runtime_extensions_namespaceObject.isDefaultLocaleRedirectSkipPath)(pathname, [
+                ...languages
+            ])
+    });
+exports.createI18nUrlStrategy = __webpack_exports__.createI18nUrlStrategy;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createI18nUrlStrategy"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/esm/cli.mjs

@@ -0,0 +1,57 @@
+import { applyLocalisedUrlsToRoutes, resolveLocalisedUrlsConfig } from "@modern-js/i18n-runtime-extensions";
+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());
+const ultramodernI18nIntegrationPlugin = ()=>({
+        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)=>'@modern-js/plugin-i18n/server' === plugin.name ? {
+                            ...plugin,
+                            name: '@modern-js/i18n-integration/server'
+                        } : plugin)
+                }));
+            api.modifyFileSystemRoutes(async ({ entrypoint, routes })=>{
+                const { plugins } = await api.getHooks()._internalRuntimePlugins.call({
+                    entrypoint,
+                    plugins: []
+                });
+                const descriptor = plugins.find((plugin)=>integrationRuntimePaths.has(plugin.path));
+                const config = descriptor?.config;
+                const { localePathRedirect, languages = [], localisedUrls } = config?.localeDetection ?? {};
+                const resolved = resolveLocalisedUrlsConfig(localisedUrls);
+                if (!localePathRedirect || !languages.length || !resolved.enabled) return {
+                    entrypoint,
+                    routes
+                };
+                return {
+                    entrypoint,
+                    routes: applyLocalisedUrlsToRoutes(routes, languages, resolved.map)
+                };
+            });
+        }
+    });
+const cli = ultramodernI18nIntegrationPlugin;
+export default cli;
+export { ultramodernI18nIntegrationPlugin };

package/dist/esm/federation/boundary.mjs

@@ -0,0 +1,62 @@
+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/federation/registration.mjs

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

package/dist/esm/languageSynchronization.mjs

@@ -0,0 +1,6 @@
+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/navigation.mjs

@@ -0,0 +1,182 @@
+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/runtime-no-react-i18next.mjs

@@ -0,0 +1,6 @@
+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/runtime.mjs

@@ -0,0 +1,6 @@
+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/runtimeComposition.mjs

@@ -0,0 +1,22 @@
+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/server.mjs

@@ -0,0 +1,10 @@
+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/urlStrategy.mjs

@@ -0,0 +1,13 @@
+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/esm-node/cli.mjs

@@ -0,0 +1,58 @@
+import "node:module";
+import { applyLocalisedUrlsToRoutes, resolveLocalisedUrlsConfig } from "@modern-js/i18n-runtime-extensions";
+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());
+const ultramodernI18nIntegrationPlugin = ()=>({
+        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)=>'@modern-js/plugin-i18n/server' === plugin.name ? {
+                            ...plugin,
+                            name: '@modern-js/i18n-integration/server'
+                        } : plugin)
+                }));
+            api.modifyFileSystemRoutes(async ({ entrypoint, routes })=>{
+                const { plugins } = await api.getHooks()._internalRuntimePlugins.call({
+                    entrypoint,
+                    plugins: []
+                });
+                const descriptor = plugins.find((plugin)=>integrationRuntimePaths.has(plugin.path));
+                const config = descriptor?.config;
+                const { localePathRedirect, languages = [], localisedUrls } = config?.localeDetection ?? {};
+                const resolved = resolveLocalisedUrlsConfig(localisedUrls);
+                if (!localePathRedirect || !languages.length || !resolved.enabled) return {
+                    entrypoint,
+                    routes
+                };
+                return {
+                    entrypoint,
+                    routes: applyLocalisedUrlsToRoutes(routes, languages, resolved.map)
+                };
+            });
+        }
+    });
+const cli = ultramodernI18nIntegrationPlugin;
+export default cli;
+export { ultramodernI18nIntegrationPlugin };