@modern-js/runtime 2.54.6 → 2.56.0

package/dist/cjs/{ssr/serverRender/renderToString/index.js → cli/alias.js}

@@ -26,26 +26,37 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var renderToString_exports = {};
-__export(renderToString_exports, {
-  render: () => render
+var alias_exports = {};
+__export(alias_exports, {
+  builderPluginAlias: () => builderPluginAlias
 });
-module.exports = __toCommonJS(renderToString_exports);
-var import_node = require("@modern-js/runtime-utils/node");
-var import_entry = __toESM(require("./entry"));
-const render = ({ App, context, config }) => {
-  const ssrContext = context.ssrContext;
-  return (0, import_node.run)(ssrContext.request.headers, async () => {
-    const entry = new import_entry.default({
-      ctx: ssrContext,
-      App,
-      config
+module.exports = __toCommonJS(alias_exports);
+var import_path = __toESM(require("path"));
+var import_constants = require("./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}`] = import_path.default.join(internalDirectory, entrypoint.entryName, import_constants.ENTRY_POINT_REGISTER_FILE_NAME);
+        if (entrypoint.isMainEntry) {
+          mainEntrypointsAlias[`@${metaName}/runtime/registry`] = import_path.default.join(internalDirectory, entrypoint.entryName, import_constants.ENTRY_POINT_REGISTER_FILE_NAME);
+        }
+      });
+      return mergeRsbuildConfig(userConfig, {
+        source: {
+          alias: {
+            ...entrypointsAlias,
+            ...mainEntrypointsAlias
+          }
+        }
+      });
     });
-    const html = await entry.renderToHtml(context);
-    return html;
-  });
-};
+  }
+});
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  render
+  builderPluginAlias
 });

package/dist/cjs/cli/code.js

@@ -0,0 +1,124 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var code_exports = {};
+__export(code_exports, {
+  generateCode: () => generateCode
+});
+module.exports = __toCommonJS(code_exports);
+var import_path = __toESM(require("path"));
+var import_utils = require("@modern-js/utils");
+var import_constants = require("./constants");
+var template = __toESM(require("./template"));
+var serverTemplate = __toESM(require("./template.server"));
+function getSSRMode(entry = import_utils.MAIN_ENTRY_NAME, config) {
+  const { ssr, ssrByEntries } = config.server;
+  if (config.output.ssg) {
+    return "string";
+  }
+  return checkSSRMode((ssrByEntries === null || ssrByEntries === void 0 ? void 0 : ssrByEntries[entry]) || ssr);
+  function checkSSRMode(ssr2) {
+    if (!ssr2) {
+      return false;
+    }
+    if (typeof ssr2 === "boolean") {
+      return ssr2 ? "string" : false;
+    }
+    return ssr2.mode === "stream" ? "stream" : "string";
+  }
+}
+const generateCode = async (entrypoints, appContext, config, onCollectRuntimePlugins) => {
+  const { mountId } = config.html;
+  const { enableAsyncEntry } = config.source;
+  const { runtimeConfigFile, internalDirectory, internalSrcAlias, metaName, srcDirectory } = appContext;
+  await Promise.all(entrypoints.map(async (entrypoint) => {
+    const { entryName, isAutoMount, entry, customEntry, customBootstrap, customServerEntry } = entrypoint;
+    const { plugins: runtimePlugins } = await onCollectRuntimePlugins({
+      entrypoint,
+      plugins: []
+    });
+    if (isAutoMount) {
+      const indexCode = template.index({
+        srcDirectory,
+        internalSrcAlias,
+        metaName,
+        entry,
+        entryName,
+        customEntry,
+        customBootstrap,
+        mountId
+      });
+      const indexFile = import_path.default.resolve(internalDirectory, `./${entryName}/${import_constants.ENTRY_POINT_FILE_NAME}`);
+      import_utils.fs.outputFileSync(indexFile, indexCode, "utf8");
+      if (enableAsyncEntry) {
+        const bootstrapFile = import_path.default.resolve(internalDirectory, `./${entryName}/${import_constants.ENTRY_BOOTSTRAP_FILE_NAME}`);
+        import_utils.fs.outputFileSync(bootstrapFile, `import('./${import_constants.INDEX_FILE_NAME}');`, "utf8");
+      }
+      const ssrMode = getSSRMode(entryName, config);
+      if (ssrMode) {
+        const indexServerCode = serverTemplate.serverIndex({
+          entry,
+          entryName,
+          internalSrcAlias,
+          metaName,
+          mode: ssrMode,
+          customServerEntry,
+          srcDirectory
+        });
+        const indexServerFile = import_path.default.resolve(internalDirectory, `./${entryName}/${import_constants.SERVER_ENTRY_POINT_FILE_NAME}`);
+        import_utils.fs.outputFileSync(indexServerFile, indexServerCode, "utf8");
+      }
+      const registerCode = template.register();
+      const registerFile = import_path.default.resolve(internalDirectory, `./${entryName}/${import_constants.ENTRY_POINT_REGISTER_FILE_NAME}`);
+      import_utils.fs.outputFileSync(registerFile, registerCode, "utf8");
+      const registerRuntimeCode = template.runtimeRegister({
+        entryName,
+        srcDirectory,
+        internalSrcAlias,
+        metaName,
+        runtimeConfigFile,
+        runtimePlugins
+      });
+      const registerRuntimeFile = import_path.default.resolve(internalDirectory, `./${entryName}/${import_constants.ENTRY_POINT_RUNTIME_REGISTER_FILE_NAME}`);
+      import_utils.fs.outputFileSync(registerRuntimeFile, registerRuntimeCode, "utf8");
+      const contextCode = template.runtimeGlobalContext({
+        srcDirectory,
+        internalSrcAlias,
+        metaName,
+        entry,
+        customEntry
+      });
+      const contextFile = import_path.default.resolve(internalDirectory, `./${entryName}/${import_constants.ENTRY_POINT_RUNTIME_GLOBAL_CONTEXT_FILE_NAME}`);
+      import_utils.fs.outputFileSync(contextFile, contextCode, "utf8");
+    }
+  }));
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  generateCode
+});

package/dist/cjs/cli/constants.js

@@ -18,11 +18,32 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var constants_exports = {};
 __export(constants_exports, {
-  APP_FILE_NAME: () => APP_FILE_NAME
+  APP_FILE_NAME: () => APP_FILE_NAME,
+  ENTRY_BOOTSTRAP_FILE_NAME: () => ENTRY_BOOTSTRAP_FILE_NAME,
+  ENTRY_POINT_FILE_NAME: () => ENTRY_POINT_FILE_NAME,
+  ENTRY_POINT_REGISTER_FILE_NAME: () => ENTRY_POINT_REGISTER_FILE_NAME,
+  ENTRY_POINT_RUNTIME_GLOBAL_CONTEXT_FILE_NAME: () => ENTRY_POINT_RUNTIME_GLOBAL_CONTEXT_FILE_NAME,
+  ENTRY_POINT_RUNTIME_REGISTER_FILE_NAME: () => ENTRY_POINT_RUNTIME_REGISTER_FILE_NAME,
+  INDEX_FILE_NAME: () => INDEX_FILE_NAME,
+  SERVER_ENTRY_POINT_FILE_NAME: () => SERVER_ENTRY_POINT_FILE_NAME
 });
 module.exports = __toCommonJS(constants_exports);
 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_POINT_RUNTIME_REGISTER_FILE_NAME = "runtime-register.js";
+const ENTRY_POINT_RUNTIME_GLOBAL_CONTEXT_FILE_NAME = "runtime-global-context.js";
+const ENTRY_POINT_REGISTER_FILE_NAME = "register.js";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  APP_FILE_NAME
+  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,
+  INDEX_FILE_NAME,
+  SERVER_ENTRY_POINT_FILE_NAME
 });

package/dist/cjs/cli/index.js

@@ -29,18 +29,26 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var cli_exports = {};
 __export(cli_exports, {
   default: () => cli_default,
+  documentPlugin: () => import_cli3.documentPlugin,
   isRuntimeEntry: () => import_entry2.isRuntimeEntry,
-  runtimePlugin: () => runtimePlugin
+  routerPlugin: () => import_cli2.routerPlugin,
+  runtimePlugin: () => runtimePlugin,
+  ssrPlugin: () => import_ssr.ssrPlugin,
+  statePlugin: () => import_cli.statePlugin
 });
 module.exports = __toCommonJS(cli_exports);
+var import_path = __toESM(require("path"));
 var import_utils = require("@modern-js/utils");
 var import_cli = require("../state/cli");
-var import_cli2 = require("../ssr/cli");
-var import_cli3 = require("../router/cli");
-var import_cli4 = require("../document/cli");
+var import_cli2 = require("../router/cli");
+var import_cli3 = require("../document/cli");
+var import_ssr = require("./ssr");
 var import_entry = require("./entry");
+var import_constants = require("./constants");
+var import_code = require("./code");
+var import_alias = require("./alias");
 var import_entry2 = require("./entry");
-const runtimePlugin = () => ({
+const runtimePlugin = (params) => ({
   name: "@modern-js/runtime",
   post: [
     "@modern-js/plugin-ssr",
@@ -50,23 +58,58 @@ const runtimePlugin = () => ({
     "@modern-js/plugin-design-token"
   ],
   // the order of runtime plugins is affected by runtime hooks, mainly `init` and `hoc` hooks
-  usePlugins: [
-    (0, import_cli2.ssrPlugin)(),
+  usePlugins: (params === null || params === void 0 ? void 0 : params.plugins) || [
+    (0, import_ssr.ssrPlugin)(),
+    (0, import_cli2.routerPlugin)(),
     (0, import_cli.statePlugin)(),
-    (0, import_cli3.routerPlugin)(),
-    (0, import_cli4.documentPlugin)()
+    (0, import_cli3.documentPlugin)()
   ],
   setup: (api) => {
     return {
-      checkEntryPoint({ path, entry }) {
+      checkEntryPoint({ path: path2, entry }) {
         return {
-          path,
-          entry: entry || (0, import_entry.isRuntimeEntry)(path)
+          path: path2,
+          entry: entry || (0, import_entry.isRuntimeEntry)(path2)
         };
       },
+      modifyEntrypoints({ entrypoints }) {
+        const { internalDirectory } = api.useAppContext();
+        const { source: { enableAsyncEntry } } = api.useResolvedConfigContext();
+        const newEntryPoints = entrypoints.map((entrypoint) => {
+          if (entrypoint.isAutoMount) {
+            entrypoint.internalEntry = import_path.default.resolve(internalDirectory, `./${entrypoint.entryName}/${enableAsyncEntry ? import_constants.ENTRY_BOOTSTRAP_FILE_NAME : import_constants.ENTRY_POINT_FILE_NAME}`);
+          }
+          return entrypoint;
+        });
+        return {
+          entrypoints: newEntryPoints
+        };
+      },
+      async generateEntryCode({ entrypoints }) {
+        const appContext = api.useAppContext();
+        const resolvedConfig = api.useResolvedConfigContext();
+        const runners = api.useHookRunners();
+        await (0, import_code.generateCode)(entrypoints, appContext, resolvedConfig, runners._internalRuntimePlugins);
+      },
+      /* Note that the execution time of the config hook is before prepare.
+      /* This means that the entry information cannot be obtained in the config hook.
+      /* Therefore, aliases cannot be set directly in the config.
+      */
+      prepare() {
+        const { builder, entrypoints, internalDirectory, metaName } = api.useAppContext();
+        builder === null || builder === void 0 ? void 0 : builder.addPlugins([
+          (0, import_alias.builderPluginAlias)({
+            entrypoints,
+            internalDirectory,
+            metaName
+          })
+        ]);
+      },
       config() {
-        const appDir = api.useAppContext().appDirectory;
-        process.env.IS_REACT18 = (0, import_utils.isReact18)(appDir).toString();
+        const { appDirectory, metaName, internalDirectory } = api.useAppContext();
+        const isReact18 = (0, import_utils.isReact18)(appDirectory);
+        process.env.IS_REACT18 = isReact18.toString();
+        const pluginsExportsUtils = (0, import_utils.createRuntimeExportsUtils)(internalDirectory, "plugins");
         return {
           runtime: {},
           runtimeByEntries: {},
@@ -77,7 +120,11 @@ const runtimePlugin = () => ({
               * But it will not be installed under the user project.
               * So need to add alias
               */
-              "styled-components": require.resolve("styled-components")
+              "styled-components": require.resolve("styled-components"),
+              /**
+              * Compatible with the reference path of the old version of the plugin.
+              */
+              [`@${metaName}/runtime/plugins`]: pluginsExportsUtils.getPath()
             },
             globalVars: {
               "process.env.IS_REACT18": process.env.IS_REACT18
@@ -89,6 +136,29 @@ const runtimePlugin = () => ({
               topLevelImportPaths: [
                 "@modern-js/runtime/styled"
               ]
+            },
+            /**
+            * Add IgnorePlugin to fix react-dom/client import error when use react17
+            */
+            webpackChain: (chain, { webpack }) => {
+              if (!isReact18) {
+                chain.plugin("ignore-plugin").use(webpack.IgnorePlugin, [
+                  {
+                    resourceRegExp: /^react-dom\/client$/,
+                    contextRegExp: /./
+                  }
+                ]);
+              }
+            },
+            rspack: (_config, { appendPlugins, rspack }) => {
+              if (!isReact18) {
+                appendPlugins([
+                  new rspack.IgnorePlugin({
+                    resourceRegExp: /^react-dom\/client$/,
+                    contextRegExp: /./
+                  })
+                ]);
+              }
             }
           }
         };
@@ -97,7 +167,7 @@ const runtimePlugin = () => ({
         (0, import_utils.cleanRequireCache)([
           require.resolve("../state/cli"),
           require.resolve("../router/cli"),
-          require.resolve("../ssr/cli")
+          require.resolve("./ssr")
         ]);
       }
     };
@@ -106,6 +176,10 @@ const runtimePlugin = () => ({
 var cli_default = runtimePlugin;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  documentPlugin,
   isRuntimeEntry,
-  runtimePlugin
+  routerPlugin,
+  runtimePlugin,
+  ssrPlugin,
+  statePlugin
 });

package/dist/cjs/cli/ssr/index.js

@@ -0,0 +1,137 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ssr_exports = {};
+__export(ssr_exports, {
+  default: () => ssr_default,
+  ssrPlugin: () => ssrPlugin
+});
+module.exports = __toCommonJS(ssr_exports);
+var import_path = __toESM(require("path"));
+var import_utils = require("@modern-js/utils");
+const hasStringSSREntry = (userConfig) => {
+  const isStreaming = (ssr) => ssr && typeof ssr === "object" && ssr.mode === "stream";
+  const { server, output } = userConfig;
+  if (((server === null || server === void 0 ? void 0 : server.ssr) || output.ssg) && !isStreaming(server.ssr)) {
+    return true;
+  }
+  if ((server === null || server === void 0 ? void 0 : server.ssrByEntries) && typeof server.ssrByEntries === "object") {
+    for (const name of Object.keys(server.ssrByEntries)) {
+      if (server.ssrByEntries[name] && !isStreaming(server.ssrByEntries[name])) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+const checkUseStringSSR = (config) => {
+  const { output } = config;
+  return Boolean(output === null || output === void 0 ? void 0 : output.ssg) || hasStringSSREntry(config);
+};
+const ssrBuilderPlugin = (modernAPI) => ({
+  name: "@modern-js/builder-plugin-ssr",
+  setup(api) {
+    api.modifyEnvironmentConfig((config, { name, mergeEnvironmentConfig }) => {
+      const isServerEnvironment = config.output.target === "node" || name === "serviceWorker";
+      const userConfig = modernAPI.useResolvedConfigContext();
+      const useLoadablePlugin = (0, import_utils.isUseSSRBundle)(userConfig) && !isServerEnvironment && checkUseStringSSR(userConfig);
+      return mergeEnvironmentConfig(config, {
+        source: {
+          define: {
+            "process.env.MODERN_TARGET": isServerEnvironment ? JSON.stringify("node") : JSON.stringify("browser")
+          }
+        },
+        tools: {
+          bundlerChain: useLoadablePlugin ? (chain) => {
+            const LoadableBundlerPlugin = require("./loadable-bundler-plugin.js");
+            chain.plugin("loadable").use(LoadableBundlerPlugin, [
+              {
+                filename: import_utils.LOADABLE_STATS_FILE
+              }
+            ]);
+          } : void 0
+        }
+      });
+    });
+  }
+});
+const ssrPlugin = () => ({
+  name: "@modern-js/plugin-ssr",
+  required: [
+    "@modern-js/runtime"
+  ],
+  setup: (api) => {
+    return {
+      // for bundle
+      config() {
+        const { bundlerType = "webpack" } = api.useAppContext();
+        const babelHandler = (() => {
+          if (bundlerType === "webpack") {
+            return (config) => {
+              var _config_plugins;
+              const userConfig = api.useResolvedConfigContext();
+              (_config_plugins = config.plugins) === null || _config_plugins === void 0 ? void 0 : _config_plugins.push(import_path.default.join(__dirname, "./babel-plugin-ssr-loader-id"));
+              if ((0, import_utils.isUseSSRBundle)(userConfig) && checkUseStringSSR(userConfig)) {
+                var _config_plugins1;
+                (_config_plugins1 = config.plugins) === null || _config_plugins1 === void 0 ? void 0 : _config_plugins1.push(require.resolve("@loadable/babel-plugin"));
+              }
+            };
+          } else if (bundlerType === "rspack") {
+            return (config) => {
+              const userConfig = api.useResolvedConfigContext();
+              if ((0, import_utils.isUseSSRBundle)(userConfig) && checkUseStringSSR(userConfig)) {
+                var _config_plugins, _config_plugins1;
+                (_config_plugins = config.plugins) === null || _config_plugins === void 0 ? void 0 : _config_plugins.push(import_path.default.join(__dirname, "./babel-plugin-ssr-loader-id"));
+                (_config_plugins1 = config.plugins) === null || _config_plugins1 === void 0 ? void 0 : _config_plugins1.push(require.resolve("@loadable/babel-plugin"));
+              }
+            };
+          }
+        })();
+        return {
+          builderPlugins: [
+            ssrBuilderPlugin(api)
+          ],
+          source: {
+            alias: {
+              // ensure that all packages use the same storage in @modern-js/runtime-utils/node
+              "@modern-js/runtime-utils/node$": require.resolve("@modern-js/runtime-utils/node")
+            }
+          },
+          tools: {
+            babel: babelHandler
+          }
+        };
+      }
+    };
+  }
+});
+var ssr_default = ssrPlugin;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ssrPlugin
+});

package/dist/cjs/cli/template.js

@@ -0,0 +1,101 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var template_exports = {};
+__export(template_exports, {
+  index: () => index,
+  register: () => register,
+  runtimeGlobalContext: () => runtimeGlobalContext,
+  runtimeRegister: () => runtimeRegister
+});
+module.exports = __toCommonJS(template_exports);
+var import_path = __toESM(require("path"));
+var import_utils = require("@modern-js/utils");
+var import_constants = require("./constants");
+const genRenderCode = ({ srcDirectory, internalSrcAlias, metaName, entry, customEntry, customBootstrap, mountId }) => {
+  if (customEntry) {
+    return `import '${(0, import_utils.formatImportPath)(entry.replace(srcDirectory, internalSrcAlias))}'`;
+  }
+  return `import { createRoot } from '@${metaName}/runtime/react';
+import { render } from '@${metaName}/runtime/browser';
+${customBootstrap ? `import customBootstrap from '${(0, import_utils.formatImportPath)(customBootstrap.replace(srcDirectory, internalSrcAlias))}';` : ""}
+
+const ModernRoot = createRoot();
+
+${customBootstrap ? `customBootstrap(ModernRoot, () => render(<ModernRoot />, '${mountId || "root"}'));` : `render(<ModernRoot />, '${mountId || "root"}');`}`;
+};
+const index = ({ srcDirectory, internalSrcAlias, metaName, entry, entryName, customEntry, customBootstrap, mountId }) => `import '@${metaName}/runtime/registry/${entryName}';
+${genRenderCode({
+  srcDirectory,
+  internalSrcAlias,
+  metaName,
+  entry,
+  customEntry,
+  customBootstrap,
+  mountId
+})}
+`;
+const register = () => `import './${import_constants.ENTRY_POINT_RUNTIME_GLOBAL_CONTEXT_FILE_NAME}';
+import './${import_constants.ENTRY_POINT_RUNTIME_REGISTER_FILE_NAME}';
+`;
+const getImportRuntimeConfigCode = (srcDirectory, internalSrcAlias, runtimeConfigFile) => {
+  if (runtimeConfigFile && (0, import_utils.findExists)(import_utils.JS_EXTENSIONS.map((ext) => import_path.default.resolve(srcDirectory, `${runtimeConfigFile}${ext}`)))) {
+    return `import runtimeConfig from '${internalSrcAlias}/${runtimeConfigFile}';`;
+  }
+  return `let runtimeConfig;`;
+};
+const getRegisterRuntimePluginCode = (entryName, name, config) => `plugins.push(${name}Plugin(mergeConfig(${JSON.stringify(config)}, (runtimeConfig || {})['${name}'], ((runtimeConfig || {})['${name}ByEntries'] || {})['${entryName}'], (getGlobalAppConfig() || {})['${name}'])));`;
+const runtimeRegister = ({ entryName, srcDirectory, internalSrcAlias, metaName, runtimeConfigFile, runtimePlugins }) => `import { registerPlugin, mergeConfig } from '@${metaName}/runtime/plugin';
+import { getGlobalAppConfig, getGlobalLayoutApp } from '@${metaName}/runtime/context';
+${getImportRuntimeConfigCode(srcDirectory, internalSrcAlias, runtimeConfigFile)}
+
+const plugins = [];
+
+${runtimePlugins.map(({ name, path: path2, config }) => `import { ${name}Plugin } from '${path2}';
+
+${getRegisterRuntimePluginCode(entryName, name, config)}
+`).join("\n")}
+registerPlugin(plugins, runtimeConfig);
+`;
+const runtimeGlobalContext = ({ srcDirectory, internalSrcAlias, metaName, entry, customEntry }) => {
+  return `import { setGlobalContext } from '@${metaName}/runtime/context'
+
+import App from '${// We need to get the path of App.tsx here, but the entry is `src/entry.tsx`
+  (0, import_utils.formatImportPath)(customEntry ? entry.replace("entry.tsx", "App.tsx").replace(srcDirectory, internalSrcAlias) : entry.replace(srcDirectory, internalSrcAlias))}';
+
+setGlobalContext({
+  App,
+});`;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  index,
+  register,
+  runtimeGlobalContext,
+  runtimeRegister
+});