@modern-js/runtime 2.54.6 → 2.55.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,27 @@ 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_core = require("@rsbuild/core");
 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 +59,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 +121,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 +137,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 }) => {
+              if (!isReact18) {
+                appendPlugins([
+                  new import_core.rspack.IgnorePlugin({
+                    resourceRegExp: /^react-dom\/client$/,
+                    contextRegExp: /./
+                  })
+                ]);
+              }
             }
           }
         };
@@ -97,7 +168,7 @@ const runtimePlugin = () => ({
         (0, import_utils.cleanRequireCache)([
           require.resolve("../state/cli"),
           require.resolve("../router/cli"),
-          require.resolve("../ssr/cli")
+          require.resolve("./ssr")
         ]);
       }
     };
@@ -106,6 +177,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/{ssr/cli → cli/ssr}/index.js

@@ -26,15 +26,14 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var cli_exports = {};
-__export(cli_exports, {
-  default: () => cli_default,
+var ssr_exports = {};
+__export(ssr_exports, {
+  default: () => ssr_default,
   ssrPlugin: () => ssrPlugin
 });
-module.exports = __toCommonJS(cli_exports);
+module.exports = __toCommonJS(ssr_exports);
 var import_path = __toESM(require("path"));
 var import_utils = require("@modern-js/utils");
-const PLUGIN_IDENTIFIER = "ssr";
 const hasStringSSREntry = (userConfig) => {
   const isStreaming = (ssr) => ssr && typeof ssr === "object" && ssr.mode === "stream";
   const { server, output } = userConfig;
@@ -60,12 +59,9 @@ const ssrPlugin = () => ({
     "@modern-js/runtime"
   ],
   setup: (api) => {
-    const ssrConfigMap = /* @__PURE__ */ new Map();
-    let pluginsExportsUtils;
     return {
+      // for bundle
       config() {
-        const appContext = api.useAppContext();
-        pluginsExportsUtils = (0, import_utils.createRuntimeExportsUtils)(appContext.internalDirectory, "plugins");
         const { bundlerType = "webpack" } = api.useAppContext();
         const babelHandler = (() => {
           if (bundlerType === "webpack") {
@@ -93,8 +89,7 @@ const ssrPlugin = () => ({
           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"),
-              "@modern-js/runtime/plugins": pluginsExportsUtils.getPath()
+              "@modern-js/runtime-utils/node$": require.resolve("@modern-js/runtime-utils/node")
             },
             globalVars: (values, { target }) => {
               values["process.env.MODERN_TARGET"] = target === "node" || target === "service-worker" ? "node" : "browser";
@@ -115,85 +110,11 @@ const ssrPlugin = () => ({
             babel: babelHandler
           }
         };
-      },
-      modifyEntryImports({ entrypoint, imports }) {
-        const { entryName, isMainEntry, fileSystemRoutes } = entrypoint;
-        const userConfig = api.useResolvedConfigContext();
-        const { packageName, entrypoints } = api.useAppContext();
-        pluginsExportsUtils.addExport(`export { default as ssr } from '@modern-js/runtime/ssr'`);
-        const ssrConfig = (0, import_utils.getEntryOptions)(entryName, isMainEntry, userConfig.server.ssr, userConfig.server.ssrByEntries, packageName);
-        if (typeof ssrConfig === "object" && ssrConfig.mode === "stream") {
-          var _this;
-          const runtimeConfig = (0, import_utils.getEntryOptions)(entryName, isMainEntry, userConfig.runtime, userConfig.runtimeByEntries, packageName);
-          if (((_this = runtimeConfig === null || runtimeConfig === void 0 ? void 0 : runtimeConfig.router) === null || _this === void 0 ? void 0 : _this.mode) === "react-router-5") {
-            throw new Error(`router v5 plugin doesn't support streaming SSR, check your config 'runtime.router'`);
-          }
-          if (fileSystemRoutes && !entrypoint.nestedRoutesEntry) {
-            throw new Error("You should switch to file-system based router to support streaming SSR.");
-          }
-        }
-        const useSSG = (0, import_utils.isSSGEntry)(userConfig, entryName, entrypoints);
-        ssrConfigMap.set(entryName, ssrConfig || useSSG);
-        if (ssrConfig || useSSG) {
-          imports.push({
-            value: "@modern-js/runtime/plugins",
-            specifiers: [
-              {
-                imported: PLUGIN_IDENTIFIER
-              }
-            ]
-          });
-        }
-        return {
-          entrypoint,
-          imports
-        };
-      },
-      modifyEntryRuntimePlugins({ entrypoint, plugins, bundlerConfigs }) {
-        if (ssrConfigMap.get(entrypoint.entryName)) {
-          var _bundlerConfigs_find_output, _bundlerConfigs_find;
-          const chunkLoadingGlobal = bundlerConfigs === null || bundlerConfigs === void 0 ? void 0 : (_bundlerConfigs_find = bundlerConfigs.find((config2) => config2.name === "client")) === null || _bundlerConfigs_find === void 0 ? void 0 : (_bundlerConfigs_find_output = _bundlerConfigs_find.output) === null || _bundlerConfigs_find_output === void 0 ? void 0 : _bundlerConfigs_find_output.chunkLoadingGlobal;
-          const config = api.useResolvedConfigContext();
-          const { enableInlineScripts, enableInlineStyles } = config.output;
-          const { crossorigin, scriptLoading } = config.html;
-          plugins.push({
-            name: PLUGIN_IDENTIFIER,
-            options: JSON.stringify({
-              scriptLoading,
-              ...ssrConfigMap.get(entrypoint.entryName) || {},
-              crossorigin,
-              chunkLoadingGlobal,
-              enableInlineScripts: typeof enableInlineScripts === "function" ? void 0 : enableInlineScripts,
-              enableInlineStyles: typeof enableInlineStyles === "function" ? void 0 : enableInlineStyles
-            })
-          });
-        }
-        return {
-          entrypoint,
-          plugins
-        };
-      },
-      modifyEntryExport({ entrypoint, exportStatement }) {
-        if (ssrConfigMap.get(entrypoint.entryName)) {
-          return {
-            entrypoint,
-            exportStatement: [
-              `export function ${import_utils.SERVER_RENDER_FUNCTION_NAME}(context) {
-              return bootstrap(AppWrapper, context)
-            }`,
-              exportStatement
-            ].join("\n")
-          };
-        }
-        return {
-          entrypoint,
-          exportStatement
-        };
       }
     };
   }
 });
-var cli_default = ssrPlugin;
+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
+});