@modern-js/runtime 2.69.4 → 3.0.0-alpha.0

package/dist/cjs/router/runtime/withRouter.js

@@ -1,42 +1,48 @@
 "use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var withRouter_exports = {};
-__export(withRouter_exports, {
-  withRouter: () => withRouter
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __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__, {
+    withRouter: ()=>withRouter
 });
-module.exports = __toCommonJS(withRouter_exports);
-var import_jsx_runtime = require("react/jsx-runtime");
-var import_router = require("@modern-js/runtime-utils/router");
-const withRouter = (Component) => {
-  return (props) => {
-    const location = (0, import_router.useLocation)();
-    const params = (0, import_router.useParams)();
-    const navigate = (0, import_router.useNavigate)();
-    return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Component, {
-      ...props,
-      location,
-      params,
-      navigate
-    });
-  };
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  withRouter
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const router_namespaceObject = require("@modern-js/runtime-utils/router");
+const withRouter = (Component)=>(props)=>{
+        const location = (0, router_namespaceObject.useLocation)();
+        const params = (0, router_namespaceObject.useParams)();
+        const navigate = (0, router_namespaceObject.useNavigate)();
+        return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(Component, {
+            ...props,
+            location: location,
+            params: params,
+            navigate: navigate
+        });
+    };
+exports.withRouter = __webpack_exports__.withRouter;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "withRouter"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
 });

package/dist/cjs/rsc/client.js

@@ -1,33 +1,68 @@
 "use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+var __webpack_modules__ = {
+    "@modern-js/render/client" (module) {
+        module.exports = require("@modern-js/render/client");
+    }
 };
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var client_exports = {};
-__export(client_exports, {
-  isRedirectResponse: () => isRedirectResponse
-});
-module.exports = __toCommonJS(client_exports);
-__reExport(client_exports, require("@modern-js/render/client"), module.exports);
-const isRedirectResponse = (res) => {
-  return res.headers.get("X-Modernjs-Redirect") != null;
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  isRedirectResponse,
-  ...require("@modern-js/render/client")
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __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__, {
+        isRedirectResponse: ()=>isRedirectResponse
+    });
+    var _modern_js_render_client__rspack_import_0 = __webpack_require__("@modern-js/render/client");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _modern_js_render_client__rspack_import_0)if ([
+        "default",
+        "isRedirectResponse"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_modern_js_render_client__rspack_import_0[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    const isRedirectResponse = (res)=>null != res.headers.get('X-Modernjs-Redirect');
+})();
+exports.isRedirectResponse = __webpack_exports__.isRedirectResponse;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "isRedirectResponse"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
 });

package/dist/cjs/rsc/server.js

@@ -1,62 +1,98 @@
 "use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
+var __webpack_modules__ = {
+    "@modern-js/render/rsc" (module) {
+        module.exports = require("@modern-js/render/rsc");
+    }
 };
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var server_exports = {};
-__export(server_exports, {
-  processRSCStream: () => processRSCStream
-});
-module.exports = __toCommonJS(server_exports);
-__reExport(server_exports, require("@modern-js/render/rsc"), module.exports);
-async function processRSCStream(rscStream, controller, encoder) {
-  try {
-    const reader = rscStream.getReader();
-    const decoder = new TextDecoder("utf-8", {
-      fatal: true
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __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__, {
+        processRSCStream: ()=>processRSCStream
     });
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done)
-        break;
-      try {
-        const chunk = JSON.stringify(decoder.decode(value, {
-          stream: true
-        }));
-        const scriptTag = `<script>(self.__FLIGHT_DATA||=[]).push(${chunk})</script>`;
-        controller.enqueue(encoder.encode(scriptTag));
-      } catch (err) {
-        const base64 = JSON.stringify(btoa(String.fromCodePoint(...value)));
-        const scriptTag = `<script>(self.__FLIGHT_DATA||=[]).push(Uint8Array.from(atob(${base64}), m => m.codePointAt(0)))</script>`;
-        controller.enqueue(encoder.encode(scriptTag));
-      }
-    }
-    const remaining = decoder.decode();
-    if (remaining.length) {
-      const scriptTag = `<script>(self.__FLIGHT_DATA||=[]).push(${JSON.stringify(remaining)})</script>`;
-      controller.enqueue(encoder.encode(scriptTag));
+    var _modern_js_render_rsc__rspack_import_0 = __webpack_require__("@modern-js/render/rsc");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _modern_js_render_rsc__rspack_import_0)if ([
+        "processRSCStream",
+        "default"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_modern_js_render_rsc__rspack_import_0[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    async function processRSCStream(rscStream, controller, encoder) {
+        try {
+            const reader = rscStream.getReader();
+            const decoder = new TextDecoder('utf-8', {
+                fatal: true
+            });
+            while(true){
+                const { done, value } = await reader.read();
+                if (done) break;
+                try {
+                    const chunk = JSON.stringify(decoder.decode(value, {
+                        stream: true
+                    }));
+                    const scriptTag = `<script>(self.__FLIGHT_DATA||=[]).push(${chunk})</script>`;
+                    controller.enqueue(encoder.encode(scriptTag));
+                } catch (err) {
+                    const base64 = JSON.stringify(btoa(String.fromCodePoint(...value)));
+                    const scriptTag = `<script>(self.__FLIGHT_DATA||=[]).push(Uint8Array.from(atob(${base64}), m => m.codePointAt(0)))</script>`;
+                    controller.enqueue(encoder.encode(scriptTag));
+                }
+            }
+            const remaining = decoder.decode();
+            if (remaining.length) {
+                const scriptTag = `<script>(self.__FLIGHT_DATA||=[]).push(${JSON.stringify(remaining)})</script>`;
+                controller.enqueue(encoder.encode(scriptTag));
+            }
+            controller.close();
+        } catch (error) {
+            controller.error(error);
+        }
     }
-    controller.close();
-  } catch (error) {
-    controller.error(error);
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  processRSCStream,
-  ...require("@modern-js/render/rsc")
+})();
+exports.processRSCStream = __webpack_exports__.processRSCStream;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "processRSCStream"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
 });

package/dist/esm/cli/alias.mjs

@@ -0,0 +1,24 @@
+import path from "path";
+import { ENTRY_POINT_REGISTER_FILE_NAME } from "./constants";
+const builderPluginAlias = ({ entrypoints, internalDirectory, metaName })=>({
+        name: 'runtime:alias',
+        setup (api) {
+            api.modifyRsbuildConfig((userConfig, { mergeRsbuildConfig })=>{
+                const entrypointsAlias = {};
+                const mainEntrypointsAlias = {};
+                entrypoints.forEach((entrypoint)=>{
+                    entrypointsAlias[`@${metaName}/runtime/registry/${entrypoint.entryName}$`] = path.join(internalDirectory, entrypoint.entryName, ENTRY_POINT_REGISTER_FILE_NAME);
+                    if (entrypoint.isMainEntry) mainEntrypointsAlias[`@${metaName}/runtime/registry`] = path.join(internalDirectory, entrypoint.entryName, ENTRY_POINT_REGISTER_FILE_NAME);
+                });
+                return mergeRsbuildConfig(userConfig, {
+                    resolve: {
+                        alias: {
+                            ...entrypointsAlias,
+                            ...mainEntrypointsAlias
+                        }
+                    }
+                });
+            });
+        }
+    });
+export { builderPluginAlias };

package/dist/esm/cli/code.mjs

@@ -0,0 +1,119 @@
+import path from "path";
+import { fs } from "@modern-js/utils";
+import { ENTRY_BOOTSTRAP_FILE_NAME, ENTRY_POINT_FILE_NAME, ENTRY_POINT_REGISTER_FILE_NAME, ENTRY_POINT_RUNTIME_GLOBAL_CONTEXT_FILE_NAME, ENTRY_POINT_RUNTIME_REGISTER_FILE_NAME, ENTRY_SERVER_BOOTSTRAP_FILE_NAME, INDEX_FILE_NAME, SERVER_ENTRY_POINT_FILE_NAME } from "./constants";
+import { resolveSSRMode } from "./ssr/mode";
+import { AppProxyForRSC, entryForCSRWithRSC, index, register, runtimeGlobalContext, runtimeGlobalContextForRSCClient, runtimeGlobalContextForRSCServer, runtimeRegister } from "./template";
+import { entryForCSRWithRSC as external_template_server_mjs_entryForCSRWithRSC, serverIndex } from "./template.server.mjs";
+const generateCode = async (entrypoints, appContext, config, hooks)=>{
+    const { mountId } = config.html;
+    const { enableAsyncEntry } = config.source;
+    const { runtimeConfigFile, internalDirectory, internalSrcAlias, metaName, srcDirectory, serverRoutes } = appContext;
+    await Promise.all(entrypoints.map(async (entrypoint)=>{
+        const { entryName, isAutoMount, entry, customEntry, customServerEntry, nestedRoutesEntry } = entrypoint;
+        const { plugins: runtimePlugins } = await hooks._internalRuntimePlugins.call({
+            entrypoint,
+            plugins: []
+        });
+        if (isAutoMount) {
+            const ssrMode = resolveSSRMode({
+                entry: entryName,
+                config,
+                nestedRoutesEntry
+            });
+            let indexCode = '';
+            indexCode = !ssrMode && config.server.rsc ? entryForCSRWithRSC({
+                metaName,
+                entryName,
+                mountId,
+                urlPath: serverRoutes.find((route)=>route.entryName === entryName)?.urlPath,
+                isNestedRouter: entrypoint.nestedRoutesEntry
+            }) : index({
+                srcDirectory,
+                internalSrcAlias,
+                metaName,
+                entry,
+                entryName,
+                customEntry,
+                mountId,
+                enableRsc: config.server.rsc,
+                isNestedRouter: !!entrypoint.nestedRoutesEntry
+            });
+            const indexFile = path.resolve(internalDirectory, `./${entryName}/${ENTRY_POINT_FILE_NAME}`);
+            await fs.outputFile(indexFile, indexCode, 'utf8');
+            if (enableAsyncEntry) {
+                const bootstrapFile = path.resolve(internalDirectory, `./${entryName}/${ENTRY_BOOTSTRAP_FILE_NAME}`);
+                await fs.outputFile(bootstrapFile, `import(/* webpackChunkName: "async-${entryName}" */ './${INDEX_FILE_NAME}');`, 'utf8');
+                const bootstrapServerFile = path.resolve(internalDirectory, `./${entryName}/${ENTRY_SERVER_BOOTSTRAP_FILE_NAME}`);
+                if (ssrMode) await fs.outputFile(bootstrapServerFile, `export const requestHandler = import('./${SERVER_ENTRY_POINT_FILE_NAME}').then((m) => m.requestHandler)`, 'utf8');
+            }
+            if (ssrMode) {
+                const indexServerCode = serverIndex({
+                    entry,
+                    entryName,
+                    internalSrcAlias,
+                    metaName,
+                    mode: ssrMode,
+                    customServerEntry,
+                    srcDirectory,
+                    enableRsc: config.server.rsc
+                });
+                const indexServerFile = path.resolve(internalDirectory, `./${entryName}/${SERVER_ENTRY_POINT_FILE_NAME}`);
+                await fs.outputFile(indexServerFile, indexServerCode, 'utf8');
+            } else if (config.server.rsc) {
+                const indexServerFile = path.resolve(internalDirectory, `./${entryName}/${SERVER_ENTRY_POINT_FILE_NAME}`);
+                const indexServerCode = external_template_server_mjs_entryForCSRWithRSC({
+                    entryName,
+                    metaName
+                });
+                await fs.outputFile(indexServerFile, indexServerCode, 'utf8');
+            }
+            const registerCode = register();
+            const registerFile = path.resolve(internalDirectory, `./${entryName}/${ENTRY_POINT_REGISTER_FILE_NAME}`);
+            await fs.outputFile(registerFile, registerCode, 'utf8');
+            const registerRuntimeCode = runtimeRegister({
+                entryName,
+                srcDirectory,
+                internalSrcAlias,
+                metaName,
+                runtimeConfigFile,
+                runtimePlugins
+            });
+            const registerRuntimeFile = path.resolve(internalDirectory, `./${entryName}/${ENTRY_POINT_RUNTIME_REGISTER_FILE_NAME}`);
+            await fs.outputFile(registerRuntimeFile, registerRuntimeCode, 'utf8');
+            let contextCode = '';
+            if (!config.server.rsc || entrypoint.nestedRoutesEntry) {
+                const route = serverRoutes.find((r)=>r.entryName === entryName);
+                const basename = route?.urlPath || '/';
+                contextCode = runtimeGlobalContext({
+                    entryName,
+                    srcDirectory,
+                    internalSrcAlias,
+                    metaName,
+                    entry,
+                    customEntry,
+                    basename
+                });
+            } else {
+                const AppProxyPath = path.join(internalDirectory, entryName, './AppProxy.jsx');
+                const appProxyCode = AppProxyForRSC({
+                    srcDirectory,
+                    internalSrcAlias,
+                    entry,
+                    customEntry
+                });
+                await fs.outputFile(AppProxyPath, appProxyCode);
+                contextCode = runtimeGlobalContextForRSCClient({
+                    metaName
+                });
+                const contextServerCode = runtimeGlobalContextForRSCServer({
+                    metaName
+                });
+                const contextFile = path.resolve(internalDirectory, `./${entryName}/${ENTRY_POINT_RUNTIME_GLOBAL_CONTEXT_FILE_NAME}.server.js`);
+                await fs.outputFile(contextFile, contextServerCode, 'utf8');
+            }
+            const contextFile = path.resolve(internalDirectory, `./${entryName}/${ENTRY_POINT_RUNTIME_GLOBAL_CONTEXT_FILE_NAME}.js`);
+            await fs.outputFile(contextFile, contextCode, 'utf8');
+        }
+    }));
+};
+export { generateCode };

package/dist/esm/cli/constants.mjs

@@ -0,0 +1,10 @@
+const APP_FILE_NAME = 'App';
+const ENTRY_POINT_FILE_NAME = 'index.jsx';
+const SERVER_ENTRY_POINT_FILE_NAME = 'index.server.jsx';
+const INDEX_FILE_NAME = 'index';
+const ENTRY_BOOTSTRAP_FILE_NAME = 'bootstrap.jsx';
+const ENTRY_SERVER_BOOTSTRAP_FILE_NAME = 'bootstrap.server.jsx';
+const ENTRY_POINT_RUNTIME_REGISTER_FILE_NAME = 'runtime-register.js';
+const ENTRY_POINT_RUNTIME_GLOBAL_CONTEXT_FILE_NAME = 'runtime-global-context';
+const ENTRY_POINT_REGISTER_FILE_NAME = 'register.js';
+export { APP_FILE_NAME, ENTRY_BOOTSTRAP_FILE_NAME, ENTRY_POINT_FILE_NAME, ENTRY_POINT_REGISTER_FILE_NAME, ENTRY_POINT_RUNTIME_GLOBAL_CONTEXT_FILE_NAME, ENTRY_POINT_RUNTIME_REGISTER_FILE_NAME, ENTRY_SERVER_BOOTSTRAP_FILE_NAME, INDEX_FILE_NAME, SERVER_ENTRY_POINT_FILE_NAME };

package/dist/esm/cli/entry.mjs

@@ -0,0 +1,6 @@
+import path from "path";
+import { JS_EXTENSIONS, findExists } from "@modern-js/utils";
+import { APP_FILE_NAME } from "./constants";
+const hasApp = (dir)=>findExists(JS_EXTENSIONS.map((ext)=>path.resolve(dir, `${APP_FILE_NAME}${ext}`)));
+const isRuntimeEntry = (dir)=>hasApp(dir);
+export { hasApp, isRuntimeEntry };

package/dist/esm/cli/index.mjs

@@ -0,0 +1,89 @@
+import path_0 from "path";
+import { cleanRequireCache, isReact18 as utils_isReact18 } from "@modern-js/utils";
+import { documentPlugin } from "../document/cli";
+import { routerPlugin } from "../router/cli";
+import { builderPluginAlias } from "./alias";
+import { generateCode } from "./code";
+import { ENTRY_BOOTSTRAP_FILE_NAME, ENTRY_POINT_FILE_NAME } from "./constants";
+import { isRuntimeEntry } from "./entry";
+import { ssrPlugin } from "./ssr";
+const runtimePlugin = (params)=>({
+        name: '@modern-js/runtime',
+        post: [
+            '@modern-js/plugin-ssr',
+            '@modern-js/plugin-router',
+            '@modern-js/plugin-document',
+            '@modern-js/plugin-design-token'
+        ],
+        usePlugins: params?.plugins || [
+            ssrPlugin(),
+            routerPlugin(),
+            documentPlugin()
+        ],
+        setup: (api)=>{
+            api.checkEntryPoint(({ path, entry })=>({
+                    path,
+                    entry: entry || isRuntimeEntry(path)
+                }));
+            api.modifyEntrypoints(({ entrypoints })=>{
+                const { internalDirectory } = api.getAppContext();
+                const { source: { enableAsyncEntry } } = api.getNormalizedConfig();
+                const newEntryPoints = entrypoints.map((entrypoint)=>{
+                    if (entrypoint.isAutoMount) entrypoint.internalEntry = path_0.resolve(internalDirectory, `./${entrypoint.entryName}/${enableAsyncEntry ? ENTRY_BOOTSTRAP_FILE_NAME : ENTRY_POINT_FILE_NAME}`);
+                    return entrypoint;
+                });
+                return {
+                    entrypoints: newEntryPoints
+                };
+            });
+            api.generateEntryCode(async ({ entrypoints })=>{
+                const appContext = api.getAppContext();
+                const resolvedConfig = api.getNormalizedConfig();
+                const hooks = api.getHooks();
+                await generateCode(entrypoints, appContext, resolvedConfig, hooks);
+            });
+            api.onPrepare(()=>{
+                const { builder, entrypoints, internalDirectory, metaName } = api.getAppContext();
+                builder?.addPlugins([
+                    builderPluginAlias({
+                        entrypoints,
+                        internalDirectory,
+                        metaName
+                    })
+                ]);
+            });
+            api.config(()=>{
+                const { appDirectory, metaName } = api.getAppContext();
+                const isReact18 = utils_isReact18(appDirectory);
+                process.env.IS_REACT18 = isReact18.toString();
+                return {
+                    source: {
+                        globalVars: {
+                            'process.env.IS_REACT18': process.env.IS_REACT18
+                        }
+                    },
+                    tools: {
+                        bundlerChain: (chain)=>{
+                            chain.module.rule('modern-entry').test(/\.jsx?$/).include.add(path_0.resolve(appDirectory, 'node_modules', `.${metaName}`)).end().sideEffects(true);
+                        },
+                        rspack: (_config, { appendPlugins, rspack })=>{
+                            if (!isReact18) appendPlugins([
+                                new rspack.IgnorePlugin({
+                                    resourceRegExp: /^react-dom\/client$/,
+                                    contextRegExp: /@modern-js\/runtime/
+                                })
+                            ]);
+                        }
+                    }
+                };
+            });
+            api.onBeforeRestart(()=>{
+                cleanRequireCache([
+                    require.resolve('../router/cli'),
+                    require.resolve('./ssr')
+                ]);
+            });
+        }
+    });
+const cli = runtimePlugin;
+export { cli as default, documentPlugin, isRuntimeEntry, routerPlugin, runtimePlugin, ssrPlugin };