@modern-js/runtime 2.54.6 → 2.55.0

package/dist/esm/router/runtime/plugin.js

@@ -4,8 +4,8 @@ import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
 import { jsx as _jsx } from "react/jsx-runtime";
 import { useContext, useMemo } from "react";
 import { createBrowserRouter, createHashRouter, RouterProvider, createRoutesFromElements, useMatches, useLocation, useHref } from "@modern-js/runtime-utils/router";
-import hoistNonReactStatics from "hoist-non-react-statics";
 import { parsedJSONFromElement } from "@modern-js/runtime-utils/parsed";
+import { getGlobalLayoutApp, getGlobalRoutes } from "../../core/context";
 import { RuntimeReactContext } from "../../core";
 import { modifyRoutes as modifyRoutesHook } from "./hooks";
 import { deserializeErrors, renderRoutes, urlJoin } from "./utils";
@@ -23,14 +23,17 @@ function modifyRoutes(modifyFunction) {
   }
 }
 var routerPlugin = function(param) {
-  var _param_serverBase = param.serverBase, serverBase = _param_serverBase === void 0 ? [] : _param_serverBase, _param_supportHtml5History = param.supportHtml5History, supportHtml5History = _param_supportHtml5History === void 0 ? true : _param_supportHtml5History, _param_basename = param.basename, basename = _param_basename === void 0 ? "" : _param_basename, _param_originalBaseUrl = param.originalBaseUrl, originalBaseUrl = _param_originalBaseUrl === void 0 ? "" : _param_originalBaseUrl, routesConfig = param.routesConfig, createRoutes = param.createRoutes;
+  var _param_serverBase = param.serverBase, serverBase = _param_serverBase === void 0 ? [] : _param_serverBase, _param_supportHtml5History = param.supportHtml5History, supportHtml5History = _param_supportHtml5History === void 0 ? true : _param_supportHtml5History, _param_basename = param.basename, basename = _param_basename === void 0 ? "" : _param_basename, routesConfig = param.routesConfig, createRoutes = param.createRoutes;
   var select = function(pathname) {
     return serverBase.find(function(baseUrl) {
       return pathname.search(baseUrl) === 0;
     }) || "/";
   };
   var routes = [];
-  finalRouteConfig = routesConfig;
+  finalRouteConfig = _object_spread({
+    routes: getGlobalRoutes(),
+    globalApp: getGlobalLayoutApp()
+  }, routesConfig);
   window._SERVER_DATA = parsedJSONFromElement("__MODERN_SERVER_DATA__");
   return {
     name: "@modern-js/plugin-router",
@@ -57,7 +60,7 @@ var routerPlugin = function(param) {
         },
         hoc: function(param2, next) {
           var App = param2.App, config = param2.config;
-          if (!finalRouteConfig && !createRoutes) {
+          if (!finalRouteConfig.routes && !createRoutes) {
             return next({
               App,
               config
@@ -65,8 +68,8 @@ var routerPlugin = function(param) {
           }
           var getRouteApp = function() {
             var useCreateRouter = function(props) {
-              var _window__SERVER_DATA;
-              var baseUrl = originalBaseUrl || ((_window__SERVER_DATA = window._SERVER_DATA) === null || _window__SERVER_DATA === void 0 ? void 0 : _window__SERVER_DATA.router.baseUrl) || select(location.pathname);
+              var _config_router, _window__SERVER_DATA;
+              var baseUrl = ((config === null || config === void 0 ? void 0 : (_config_router = config.router) === null || _config_router === void 0 ? void 0 : _config_router.basename) || ((_window__SERVER_DATA = window._SERVER_DATA) === null || _window__SERVER_DATA === void 0 ? void 0 : _window__SERVER_DATA.router.baseUrl) || select(location.pathname)).replace(/^\/*/, "/");
               var _basename = baseUrl === "/" ? urlJoin(baseUrl, basename) : baseUrl;
               var hydrationData = window._ROUTER_DATA;
               var runtimeContext = useContext(RuntimeReactContext);
@@ -122,23 +125,12 @@ var routerPlugin = function(param) {
             return function(props) {
               beforeCreateRouter = false;
               var router = useCreateRouter(props);
-              return /* @__PURE__ */ _jsx(App, _object_spread_props(_object_spread({}, props), {
-                children: /* @__PURE__ */ _jsx(RouterProvider, {
-                  router
-                })
-              }));
+              return /* @__PURE__ */ _jsx(RouterProvider, {
+                router
+              });
             };
           };
           var RouteApp = getRouteApp();
-          if (App) {
-            RouteApp = hoistNonReactStatics(RouteApp, App);
-          }
-          if (routesConfig === null || routesConfig === void 0 ? void 0 : routesConfig.globalApp) {
-            return next({
-              App: hoistNonReactStatics(RouteApp, routesConfig.globalApp),
-              config
-            });
-          }
           return next({
             App: RouteApp,
             config

package/dist/esm/router/runtime/plugin.node.js

@@ -4,31 +4,20 @@ import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
 import { _ as _object_spread_props } from "@swc/helpers/_/_object_spread_props";
 import { _ as _sliced_to_array } from "@swc/helpers/_/_sliced_to_array";
 import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { useContext } from "react";
 import { createStaticHandler } from "@modern-js/runtime-utils/remix-router";
 import { createStaticRouter, StaticRouterProvider } from "@modern-js/runtime-utils/node/router";
-import hoistNonReactStatics from "hoist-non-react-statics";
 import { createRoutesFromElements } from "@modern-js/runtime-utils/router";
 import { reporterCtx, createRequestContext } from "@modern-js/runtime-utils/node";
 import { time } from "@modern-js/runtime-utils/time";
 import { LOADER_REPORTER_NAME } from "@modern-js/utils/universal/constants";
 import { JSX_SHELL_STREAM_END_MARK } from "../../common";
 import { RuntimeReactContext } from "../../core";
+import { getGlobalLayoutApp, getGlobalRoutes } from "../../core/context";
 import { renderRoutes, urlJoin } from "./utils";
 import { modifyRoutes as modifyRoutesHook } from "./hooks";
 import DeferredDataScripts from "./DeferredDataScripts.node";
-function createFetchRequest(req) {
-  var origin = "".concat(req.protocol, "://").concat(req.host);
-  var url = new URL(req.originalUrl || req.url, origin);
-  var controller = new AbortController();
-  var init = {
-    method: req.method,
-    headers: createFetchHeaders(req.headers),
-    signal: controller.signal
-  };
-  return new Request(url.href, init);
-}
 function createFetchHeaders(requestHeaders) {
   var headers = new Headers();
   var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
@@ -79,22 +68,26 @@ function createFetchHeaders(requestHeaders) {
   return headers;
 }
 var routerPlugin = function(param) {
-  var _param_basename = param.basename, basename = _param_basename === void 0 ? "" : _param_basename, _param_originalBaseUrl = param.originalBaseUrl, originalBaseUrl = _param_originalBaseUrl === void 0 ? "" : _param_originalBaseUrl, routesConfig = param.routesConfig, createRoutes = param.createRoutes;
+  var _param_basename = param.basename, basename = _param_basename === void 0 ? "" : _param_basename, routesConfig = param.routesConfig, createRoutes = param.createRoutes;
   return {
     name: "@modern-js/plugin-router",
     registerHook: {
       modifyRoutes: modifyRoutesHook
     },
     setup: function(api) {
+      var finalRouteConfig = _object_spread({
+        routes: getGlobalRoutes(),
+        globalApp: getGlobalLayoutApp()
+      }, routesConfig);
       return {
         init: function init(param2, next) {
           var context = param2.context;
           return _async_to_generator(function() {
-            var _context_ssrContext, _context_ssrContext1, request, ssrMode, nonce, _context_ssrContext_loaderFailureMode, loaderFailureMode, baseUrl, _basename, _context_ssrContext2, reporter, serverTiming, requestContext, routes, runner, query, remixRequest, end, routerContext, cost, router;
+            var _context_ssrContext, _context_ssrContext_onTiming, _context_ssrContext1, _context_ssrContext2, request, ssrMode, nonce, _context_ssrContext_loaderFailureMode, loaderFailureMode, baseUrl, _basename, reporter, requestContext, routes, runner, query, remixRequest, end, routerContext, cost, router;
             return _ts_generator(this, function(_state) {
               switch (_state.label) {
                 case 0:
-                  if (!routesConfig && !createRoutes) {
+                  if (!finalRouteConfig.routes && !createRoutes) {
                     return [
                       2,
                       next({
@@ -102,14 +95,14 @@ var routerPlugin = function(param) {
                       })
                     ];
                   }
-                  _context_ssrContext1 = context.ssrContext, request = _context_ssrContext1.request, ssrMode = _context_ssrContext1.mode, nonce = _context_ssrContext1.nonce, _context_ssrContext_loaderFailureMode = _context_ssrContext1.loaderFailureMode, loaderFailureMode = _context_ssrContext_loaderFailureMode === void 0 ? "errorBoundary" : _context_ssrContext_loaderFailureMode;
-                  baseUrl = originalBaseUrl || request.baseUrl;
+                  _context_ssrContext2 = context.ssrContext, request = _context_ssrContext2.request, ssrMode = _context_ssrContext2.mode, nonce = _context_ssrContext2.nonce, _context_ssrContext_loaderFailureMode = _context_ssrContext2.loaderFailureMode, loaderFailureMode = _context_ssrContext_loaderFailureMode === void 0 ? "errorBoundary" : _context_ssrContext_loaderFailureMode;
+                  baseUrl = request.baseUrl;
                   _basename = baseUrl === "/" ? urlJoin(baseUrl, basename) : baseUrl;
-                  _context_ssrContext2 = context.ssrContext, reporter = _context_ssrContext2.reporter, serverTiming = _context_ssrContext2.serverTiming;
+                  reporter = context.ssrContext.reporter;
                   requestContext = createRequestContext((_context_ssrContext = context.ssrContext) === null || _context_ssrContext === void 0 ? void 0 : _context_ssrContext.loaderContext);
                   requestContext.set(reporterCtx, reporter);
                   routes = createRoutes ? createRoutes() : createRoutesFromElements(renderRoutes({
-                    routesConfig,
+                    routesConfig: finalRouteConfig,
                     ssrMode,
                     props: {
                       nonce
@@ -121,7 +114,7 @@ var routerPlugin = function(param) {
                   query = createStaticHandler(routes, {
                     basename: _basename
                   }).query;
-                  remixRequest = createFetchRequest(request);
+                  remixRequest = context.ssrContext.request.raw;
                   end = time();
                   return [
                     4,
@@ -132,8 +125,7 @@ var routerPlugin = function(param) {
                 case 1:
                   routerContext = _state.sent();
                   cost = end();
-                  reporter === null || reporter === void 0 ? void 0 : reporter.reportTiming(LOADER_REPORTER_NAME, cost);
-                  serverTiming.addServeTiming(LOADER_REPORTER_NAME, cost);
+                  (_context_ssrContext1 = context.ssrContext) === null || _context_ssrContext1 === void 0 ? void 0 : (_context_ssrContext_onTiming = _context_ssrContext1.onTiming) === null || _context_ssrContext_onTiming === void 0 ? void 0 : _context_ssrContext_onTiming.call(_context_ssrContext1, LOADER_REPORTER_NAME, cost);
                   if (_instanceof(routerContext, Response)) {
                     return [
                       2,
@@ -148,7 +140,6 @@ var routerPlugin = function(param) {
                   context.remixRouter = router;
                   context.routerContext = routerContext;
                   context.routes = routes;
-                  context.routeManifest = context.ssrContext.routeManifest;
                   return [
                     2,
                     next({
@@ -161,17 +152,17 @@ var routerPlugin = function(param) {
         },
         hoc: function(param2, next) {
           var App = param2.App, config = param2.config;
-          if (!routesConfig) {
+          if (!finalRouteConfig) {
             return next({
               App,
               config
             });
           }
           var getRouteApp = function() {
-            return function(props) {
+            return function() {
               var _useContext = useContext(RuntimeReactContext), remixRouter = _useContext.remixRouter, routerContext = _useContext.routerContext, ssrContext = _useContext.ssrContext;
               var nonce = ssrContext.nonce, mode = ssrContext.mode;
-              return /* @__PURE__ */ _jsxs(App, _object_spread_props(_object_spread({}, props), {
+              return /* @__PURE__ */ _jsxs(_Fragment, {
                 children: [
                   /* @__PURE__ */ _jsx(StaticRouterProvider, {
                     router: remixRouter,
@@ -184,16 +175,10 @@ var routerPlugin = function(param) {
                   }),
                   mode === "stream" && JSX_SHELL_STREAM_END_MARK
                 ]
-              }));
+              });
             };
           };
           var RouteApp = getRouteApp();
-          if (routesConfig === null || routesConfig === void 0 ? void 0 : routesConfig.globalApp) {
-            return next({
-              App: hoistNonReactStatics(RouteApp, routesConfig.globalApp),
-              config
-            });
-          }
           return next({
             App: RouteApp,
             config

package/dist/esm/state/cli/index.js

@@ -1,4 +1,4 @@
-import { getEntryOptions, createRuntimeExportsUtils } from "@modern-js/utils";
+import { createRuntimeExportsUtils, getEntryOptions } from "@modern-js/utils";
 var PLUGIN_IDENTIFIER = "state";
 var statePlugin = function() {
   return {
@@ -7,50 +7,19 @@ var statePlugin = function() {
       "@modern-js/runtime"
     ],
     setup: function(api) {
-      var stateConfigMap = /* @__PURE__ */ new Map();
-      var pluginsExportsUtils;
       return {
-        config: function config() {
-          var appContext = api.useAppContext();
-          pluginsExportsUtils = createRuntimeExportsUtils(appContext.internalDirectory, "plugins");
-          return {
-            source: {
-              alias: {
-                "@modern-js/runtime/plugins": pluginsExportsUtils.getPath()
-              }
-            }
-          };
-        },
-        modifyEntryImports: function modifyEntryImports(param) {
-          var entrypoint = param.entrypoint, imports = param.imports;
+        _internalRuntimePlugins: function _internalRuntimePlugins(param) {
+          var entrypoint = param.entrypoint, plugins = param.plugins;
           var _getEntryOptions;
           var entryName = entrypoint.entryName, isMainEntry = entrypoint.isMainEntry;
           var userConfig = api.useResolvedConfigContext();
-          var packageName = api.useAppContext().packageName;
+          var _api_useAppContext = api.useAppContext(), packageName = _api_useAppContext.packageName, metaName = _api_useAppContext.metaName;
           var stateConfig = (_getEntryOptions = getEntryOptions(entryName, isMainEntry, userConfig.runtime, userConfig.runtimeByEntries, packageName)) === null || _getEntryOptions === void 0 ? void 0 : _getEntryOptions.state;
-          stateConfigMap.set(entryName, stateConfig);
           if (stateConfig) {
-            imports.push({
-              value: "@modern-js/runtime/plugins",
-              specifiers: [
-                {
-                  imported: PLUGIN_IDENTIFIER
-                }
-              ]
-            });
-          }
-          return {
-            entrypoint,
-            imports
-          };
-        },
-        modifyEntryRuntimePlugins: function modifyEntryRuntimePlugins(param) {
-          var entrypoint = param.entrypoint, plugins = param.plugins;
-          var stateOptions = stateConfigMap.get(entrypoint.entryName);
-          if (stateOptions) {
             plugins.push({
               name: PLUGIN_IDENTIFIER,
-              options: "".concat(JSON.stringify(stateConfigMap.get(entrypoint.entryName)))
+              path: "@".concat(metaName, "/runtime/model"),
+              config: typeof stateConfig === "boolean" ? {} : stateConfig
             });
           }
           return {
@@ -59,7 +28,9 @@ var statePlugin = function() {
           };
         },
         addRuntimeExports: function addRuntimeExports() {
-          pluginsExportsUtils.addExport("export { default as state } from '@modern-js/runtime/model'");
+          var _api_useAppContext = api.useAppContext(), internalDirectory = _api_useAppContext.internalDirectory, metaName = _api_useAppContext.metaName;
+          var pluginsExportsUtils = createRuntimeExportsUtils(internalDirectory, "plugins");
+          pluginsExportsUtils.addExport("export { default as state } from '@".concat(metaName, "/runtime/model'"));
         }
       };
     }

package/dist/esm/state/runtime/plugin.js

@@ -5,7 +5,6 @@ import { jsx as _jsx } from "react/jsx-runtime";
 import { useContext } from "react";
 import { createStore } from "@modern-js-reduck/store";
 import { Provider } from "@modern-js-reduck/react";
-import hoistNonReactStatics from "hoist-non-react-statics";
 import { immer, effects, autoActions, devtools } from "../plugins";
 import { RuntimeReactContext } from "../../core";
 import { isBrowser } from "../../common";
@@ -54,7 +53,7 @@ var getStoreConfig = function(config) {
   storeConfig.plugins = plugins;
   return storeConfig;
 };
-var state = function(config) {
+var statePlugin = function(config) {
   return {
     name: "@modern-js/plugin-state",
     setup: function() {
@@ -71,7 +70,7 @@ var state = function(config) {
             });
           };
           return next({
-            App: hoistNonReactStatics(getStateApp, App),
+            App: getStateApp,
             config: _$config
           });
         },
@@ -99,8 +98,9 @@ var state = function(config) {
     }
   };
 };
-var plugin_default = state;
+var plugin_default = statePlugin;
 export * from "../plugins";
 export {
-  plugin_default as default
+  plugin_default as default,
+  statePlugin
 };

package/dist/esm-node/cli/alias.js

@@ -0,0 +1,28 @@
+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, {
+        source: {
+          alias: {
+            ...entrypointsAlias,
+            ...mainEntrypointsAlias
+          }
+        }
+      });
+    });
+  }
+});
+export {
+  builderPluginAlias
+};

package/dist/esm-node/cli/code.js

@@ -0,0 +1,90 @@
+import path from "path";
+import { MAIN_ENTRY_NAME, fs } from "@modern-js/utils";
+import { INDEX_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, SERVER_ENTRY_POINT_FILE_NAME } from "./constants";
+import * as template from "./template";
+import * as serverTemplate from "./template.server";
+function getSSRMode(entry = 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 = path.resolve(internalDirectory, `./${entryName}/${ENTRY_POINT_FILE_NAME}`);
+      fs.outputFileSync(indexFile, indexCode, "utf8");
+      if (enableAsyncEntry) {
+        const bootstrapFile = path.resolve(internalDirectory, `./${entryName}/${ENTRY_BOOTSTRAP_FILE_NAME}`);
+        fs.outputFileSync(bootstrapFile, `import('./${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 = path.resolve(internalDirectory, `./${entryName}/${SERVER_ENTRY_POINT_FILE_NAME}`);
+        fs.outputFileSync(indexServerFile, indexServerCode, "utf8");
+      }
+      const registerCode = template.register();
+      const registerFile = path.resolve(internalDirectory, `./${entryName}/${ENTRY_POINT_REGISTER_FILE_NAME}`);
+      fs.outputFileSync(registerFile, registerCode, "utf8");
+      const registerRuntimeCode = template.runtimeRegister({
+        entryName,
+        srcDirectory,
+        internalSrcAlias,
+        metaName,
+        runtimeConfigFile,
+        runtimePlugins
+      });
+      const registerRuntimeFile = path.resolve(internalDirectory, `./${entryName}/${ENTRY_POINT_RUNTIME_REGISTER_FILE_NAME}`);
+      fs.outputFileSync(registerRuntimeFile, registerRuntimeCode, "utf8");
+      const contextCode = template.runtimeGlobalContext({
+        srcDirectory,
+        internalSrcAlias,
+        metaName,
+        entry,
+        customEntry
+      });
+      const contextFile = path.resolve(internalDirectory, `./${entryName}/${ENTRY_POINT_RUNTIME_GLOBAL_CONTEXT_FILE_NAME}`);
+      fs.outputFileSync(contextFile, contextCode, "utf8");
+    }
+  }));
+};
+export {
+  generateCode
+};

package/dist/esm-node/cli/constants.js

@@ -1,4 +1,18 @@
 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";
 export {
-  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/esm-node/cli/index.js

@@ -1,11 +1,16 @@
-import { isReact18, cleanRequireCache } from "@modern-js/utils";
+import path from "path";
+import { isReact18 as checkIsReact18, cleanRequireCache, createRuntimeExportsUtils } from "@modern-js/utils";
+import { rspack } from "@rsbuild/core";
 import { statePlugin } from "../state/cli";
-import { ssrPlugin } from "../ssr/cli";
 import { routerPlugin } from "../router/cli";
 import { documentPlugin } from "../document/cli";
+import { ssrPlugin } from "./ssr";
 import { isRuntimeEntry } from "./entry";
+import { ENTRY_BOOTSTRAP_FILE_NAME, ENTRY_POINT_FILE_NAME } from "./constants";
+import { generateCode } from "./code";
+import { builderPluginAlias } from "./alias";
 import { isRuntimeEntry as isRuntimeEntry2 } from "./entry";
-const runtimePlugin = () => ({
+const runtimePlugin = (params) => ({
   name: "@modern-js/runtime",
   post: [
     "@modern-js/plugin-ssr",
@@ -15,23 +20,58 @@ const runtimePlugin = () => ({
     "@modern-js/plugin-design-token"
   ],
   // the order of runtime plugins is affected by runtime hooks, mainly `init` and `hoc` hooks
-  usePlugins: [
+  usePlugins: (params === null || params === void 0 ? void 0 : params.plugins) || [
     ssrPlugin(),
-    statePlugin(),
     routerPlugin(),
+    statePlugin(),
     documentPlugin()
   ],
   setup: (api) => {
     return {
-      checkEntryPoint({ path, entry }) {
+      checkEntryPoint({ path: path2, entry }) {
         return {
-          path,
-          entry: entry || isRuntimeEntry(path)
+          path: path2,
+          entry: entry || isRuntimeEntry(path2)
         };
       },
+      modifyEntrypoints({ entrypoints }) {
+        const { internalDirectory } = api.useAppContext();
+        const { source: { enableAsyncEntry } } = api.useResolvedConfigContext();
+        const newEntryPoints = entrypoints.map((entrypoint) => {
+          if (entrypoint.isAutoMount) {
+            entrypoint.internalEntry = path.resolve(internalDirectory, `./${entrypoint.entryName}/${enableAsyncEntry ? ENTRY_BOOTSTRAP_FILE_NAME : 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 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([
+          builderPluginAlias({
+            entrypoints,
+            internalDirectory,
+            metaName
+          })
+        ]);
+      },
       config() {
-        const appDir = api.useAppContext().appDirectory;
-        process.env.IS_REACT18 = isReact18(appDir).toString();
+        const { appDirectory, metaName, internalDirectory } = api.useAppContext();
+        const isReact18 = checkIsReact18(appDirectory);
+        process.env.IS_REACT18 = isReact18.toString();
+        const pluginsExportsUtils = createRuntimeExportsUtils(internalDirectory, "plugins");
         return {
           runtime: {},
           runtimeByEntries: {},
@@ -42,7 +82,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
@@ -54,6 +98,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 rspack.IgnorePlugin({
+                    resourceRegExp: /^react-dom\/client$/,
+                    contextRegExp: /./
+                  })
+                ]);
+              }
             }
           }
         };
@@ -62,7 +129,7 @@ const runtimePlugin = () => ({
         cleanRequireCache([
           require.resolve("../state/cli"),
           require.resolve("../router/cli"),
-          require.resolve("../ssr/cli")
+          require.resolve("./ssr")
         ]);
       }
     };
@@ -71,6 +138,10 @@ const runtimePlugin = () => ({
 var cli_default = runtimePlugin;
 export {
   cli_default as default,
+  documentPlugin,
   isRuntimeEntry2 as isRuntimeEntry,
-  runtimePlugin
+  routerPlugin,
+  runtimePlugin,
+  ssrPlugin,
+  statePlugin
 };

package/dist/esm-node/{ssr/cli → cli/ssr}/babel-plugin-ssr-loader-id.js

@@ -7,7 +7,7 @@ import { Buffer as Buffer2 } from "buffer";
 import * as t from "@babel/types";
 import { get } from "@modern-js/utils/lodash";
 var require_babel_plugin_ssr_loader_id = __commonJS({
-  "src/ssr/cli/babel-plugin-ssr-loader-id.ts"(exports, module) {
+  "src/cli/ssr/babel-plugin-ssr-loader-id.ts"(exports, module) {
     const RUNTIME_PACKAGE_NAMES = [
       "@modern-js/runtime"
     ];