@modern-js/server-core 2.58.1 → 2.58.2-alpha.0

package/dist/cjs/adapters/node/helper/loadCache.js

@@ -34,9 +34,9 @@ module.exports = __toCommonJS(loadCache_exports);
 var import_path = __toESM(require("path"));
 var import_utils = require("@modern-js/utils");
 const CACHE_FILENAME = "cache";
-function loadCacheConfig(pwd) {
+async function loadCacheConfig(pwd) {
   const serverCacheFilepath = import_path.default.resolve(pwd, import_utils.SERVER_DIR, CACHE_FILENAME);
-  const mod = (0, import_utils.requireExistModule)(serverCacheFilepath, {
+  const mod = await (0, import_utils.requireExistModule)(serverCacheFilepath, {
     interop: false
   });
   if (mod === null || mod === void 0 ? void 0 : mod.cacheOption) {

package/dist/cjs/adapters/node/helper/loadConfig.js

@@ -35,30 +35,30 @@ module.exports = __toCommonJS(loadConfig_exports);
 var import_path = __toESM(require("path"));
 var import_utils = require("@modern-js/utils");
 var import_flatted = require("flatted");
-const requireConfig = (serverConfigPath) => {
+const requireConfig = async (serverConfigPath) => {
   if (import_utils.fs.pathExistsSync(serverConfigPath)) {
-    return (0, import_utils.compatRequire)(serverConfigPath);
+    return (0, import_utils.compatibleRequire)(serverConfigPath);
   }
   return void 0;
 };
-function loadServerConfigNew(serverConfigPath) {
-  const mod = (0, import_utils.requireExistModule)(serverConfigPath);
+async function loadServerConfigNew(serverConfigPath) {
+  const mod = await (0, import_utils.requireExistModule)(serverConfigPath);
   if (mod) {
     return mod;
   }
   return void 0;
 }
-function loadServerConfigOld(pwd, configFile) {
-  const serverConfigPath = import_path.default.join(pwd, `${configFile}.js`);
-  const serverConfig = requireConfig(serverConfigPath);
+async function loadServerConfigOld(pwd, configFile) {
+  const serverConfigPath = import_path.default.join(pwd, `${configFile}.cjs`);
+  const serverConfig = await requireConfig(serverConfigPath);
   return serverConfig;
 }
-function loadServerRuntimeConfig(pwd, oldServerFile = import_utils.DEFAULT_SERVER_CONFIG, newServerConfigPath) {
-  const newServerConfig = newServerConfigPath && loadServerConfigNew(newServerConfigPath);
+async function loadServerRuntimeConfig(pwd, oldServerFile = import_utils.DEFAULT_SERVER_CONFIG, newServerConfigPath) {
+  const newServerConfig = newServerConfigPath && await loadServerConfigNew(newServerConfigPath);
   if (newServerConfig) {
     return newServerConfig;
   }
-  const oldServerConfig = loadServerConfigOld(pwd, oldServerFile);
+  const oldServerConfig = await loadServerConfigOld(pwd, oldServerFile);
   return oldServerConfig;
 }
 function loadServerCliConfig(pwd, defaultConfig = {}) {

package/dist/cjs/adapters/node/helper/loadPlugin.js

@@ -22,15 +22,15 @@ __export(loadPlugin_exports, {
 });
 module.exports = __toCommonJS(loadPlugin_exports);
 var import_utils = require("@modern-js/utils");
-function resolveServerPlugin(plugin, appDirectory) {
+async function resolveServerPlugin(plugin, appDirectory) {
   const { name, options } = plugin;
   const pluginPath = (0, import_utils.tryResolve)(name, appDirectory);
-  const module2 = (0, import_utils.compatRequire)(pluginPath);
+  const module2 = await (0, import_utils.compatibleRequire)(pluginPath);
   const pluginInstance = module2(options);
   return pluginInstance;
 }
-function loadServerPlugins(serverPlugins, appDirectory) {
-  const instances = serverPlugins.map((plugin) => resolveServerPlugin(plugin, appDirectory));
+async function loadServerPlugins(serverPlugins, appDirectory) {
+  const instances = await Promise.all(serverPlugins.map((plugin) => resolveServerPlugin(plugin, appDirectory)));
   return instances;
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/cjs/adapters/node/node.js

@@ -128,10 +128,10 @@ const createNodeServer = async (requestHandler, httpsOptions) => {
   const requestListener = getRequestListener(requestHandler);
   let nodeServer;
   if (httpsOptions) {
-    const { createServer } = await Promise.resolve().then(() => __toESM(require("node:https")));
+    const { createServer } = await import("node:https");
     nodeServer = createServer(httpsOptions, requestListener);
   } else {
-    const { createServer } = await Promise.resolve().then(() => __toESM(require("node:http")));
+    const { createServer } = await import("node:http");
     nodeServer = createServer(requestListener);
   }
   nodeServer.getRequestListener = () => requestListener;

package/dist/cjs/adapters/node/plugins/resource.js

@@ -64,22 +64,17 @@ function injectTemplates(pwd, routes) {
     await next();
   };
 }
-const dynamicImport = (filePath) => {
-  try {
-    const module2 = require(filePath);
-    return Promise.resolve(module2);
-  } catch (e) {
-    return Promise.reject(e);
-  }
-};
 const loadBundle = async (filepath, logger) => {
   if (!await import_utils.fs.pathExists(filepath)) {
     return void 0;
   }
-  return dynamicImport(filepath).catch((e) => {
-    logger === null || logger === void 0 ? void 0 : logger.error(`Load ${filepath} bundle failed, error = %s`, e instanceof Error ? e.stack || e.message : e);
+  try {
+    const module2 = await (0, import_utils.compatibleRequire)(filepath, false);
+    return module2;
+  } catch (e) {
+    logger.error(`Load ${filepath} bundle failed, error = %s`, e instanceof Error ? e.stack || e.message : e);
     return void 0;
-  });
+  }
 };
 async function getServerManifest(pwd, routes, logger) {
   const loaderBundles = {};
@@ -94,11 +89,11 @@ async function getServerManifest(pwd, routes, logger) {
     loaderBundle && (loaderBundles[entryName] = loaderBundle);
   }));
   const loadableUri = import_path.default.join(pwd, import_utils.LOADABLE_STATS_FILE);
-  const loadableStats = await Promise.resolve().then(() => __toESM(require(loadableUri))).catch((_) => ({}));
+  const loadableStats = await (0, import_utils.compatibleRequire)(loadableUri).catch((_) => ({}));
   const routesManifestUri = import_path.default.join(pwd, import_utils.ROUTE_MANIFEST_FILE);
-  const routeManifest = await Promise.resolve().then(() => __toESM(require(routesManifestUri))).catch((_) => ({}));
+  const routeManifest = await (0, import_utils.compatibleRequire)(routesManifestUri).catch((_) => ({}));
   const nestedRoutesJsonPath = import_path.default.join(pwd, import_utils.NESTED_ROUTE_SPEC_FILE);
-  const nestedRoutesJson = await Promise.resolve().then(() => __toESM(require(nestedRoutesJsonPath))).catch((_) => ({}));
+  const nestedRoutesJson = await import(nestedRoutesJsonPath).catch((_) => ({}));
   return {
     loaderBundles,
     renderBundles,

package/dist/cjs/plugins/customServer/index.js

@@ -1,9 +1,7 @@
 "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)
@@ -17,14 +15,6 @@ var __copyProps = (to, from, except, desc) => {
   }
   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 customServer_exports = {};
 __export(customServer_exports, {
@@ -176,7 +166,7 @@ async function createMiddlewareContextFromHono(c) {
     "HEAD"
   ].includes(method) && !rawRequest.body && c.env.node.req) {
     const streamPath = "../../adapters/node/polyfills/stream";
-    const { createReadableStreamFromReadable } = await Promise.resolve().then(() => __toESM(require(streamPath)));
+    const { createReadableStreamFromReadable } = await import(streamPath);
     const init = {
       body: createReadableStreamFromReadable(c.env.node.req),
       headers: rawRequest.headers,

package/dist/cjs/plugins/render/render.js

@@ -164,7 +164,7 @@ async function renderHandler(request, options, mode, onError) {
     const { nestedRoutesJson } = serverManifest;
     const routes = nestedRoutesJson === null || nestedRoutesJson === void 0 ? void 0 : nestedRoutesJson[options.routeInfo.entryName];
     if (routes) {
-      const { matchRoutes } = await Promise.resolve().then(() => __toESM(require("@modern-js/runtime-utils/remix-router")));
+      const { matchRoutes } = await import("@modern-js/runtime-utils/remix-router");
       const url = new URL(request.url);
       const matchedRoutes = matchRoutes(routes, url.pathname, options.routeInfo.urlPath);
       if (!matchedRoutes) {

package/dist/cjs/utils/warmup.js

@@ -1,9 +1,7 @@
 "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)
@@ -17,14 +15,6 @@ var __copyProps = (to, from, except, desc) => {
   }
   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 warmup_exports = {};
 __export(warmup_exports, {
@@ -33,7 +23,7 @@ __export(warmup_exports, {
 module.exports = __toCommonJS(warmup_exports);
 function warmup(bundles) {
   bundles.forEach((bundle) => {
-    bundle && Promise.resolve().then(() => __toESM(require(bundle))).catch((_) => {
+    bundle && import(bundle).catch((_) => {
     });
   });
 }

package/dist/esm/adapters/node/helper/loadCache.js

@@ -1,18 +1,43 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
 import path from "path";
 import { SERVER_DIR, requireExistModule } from "@modern-js/utils";
 var CACHE_FILENAME = "cache";
 function loadCacheConfig(pwd) {
-  var serverCacheFilepath = path.resolve(pwd, SERVER_DIR, CACHE_FILENAME);
-  var mod = requireExistModule(serverCacheFilepath, {
-    interop: false
+  return _loadCacheConfig.apply(this, arguments);
+}
+function _loadCacheConfig() {
+  _loadCacheConfig = _async_to_generator(function(pwd) {
+    var serverCacheFilepath, mod;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          serverCacheFilepath = path.resolve(pwd, SERVER_DIR, CACHE_FILENAME);
+          return [
+            4,
+            requireExistModule(serverCacheFilepath, {
+              interop: false
+            })
+          ];
+        case 1:
+          mod = _state.sent();
+          if (mod === null || mod === void 0 ? void 0 : mod.cacheOption) {
+            return [
+              2,
+              {
+                strategy: mod.cacheOption,
+                container: mod.customContainer
+              }
+            ];
+          }
+          return [
+            2,
+            void 0
+          ];
+      }
+    });
   });
-  if (mod === null || mod === void 0 ? void 0 : mod.cacheOption) {
-    return {
-      strategy: mod.cacheOption,
-      container: mod.customContainer
-    };
-  }
-  return void 0;
+  return _loadCacheConfig.apply(this, arguments);
 }
 export {
   loadCacheConfig

package/dist/esm/adapters/node/helper/loadConfig.js

@@ -1,32 +1,128 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
 import path from "path";
-import { compatRequire, fs, DEFAULT_SERVER_CONFIG, requireExistModule, ensureAbsolutePath, OUTPUT_CONFIG_FILE, lodash as _ } from "@modern-js/utils";
+import { fs, DEFAULT_SERVER_CONFIG, requireExistModule, ensureAbsolutePath, OUTPUT_CONFIG_FILE, lodash as _, compatibleRequire } from "@modern-js/utils";
 import { parse } from "flatted";
-var requireConfig = function(serverConfigPath) {
-  if (fs.pathExistsSync(serverConfigPath)) {
-    return compatRequire(serverConfigPath);
-  }
-  return void 0;
-};
+var requireConfig = function() {
+  var _ref = _async_to_generator(function(serverConfigPath) {
+    return _ts_generator(this, function(_state) {
+      if (fs.pathExistsSync(serverConfigPath)) {
+        return [
+          2,
+          compatibleRequire(serverConfigPath)
+        ];
+      }
+      return [
+        2,
+        void 0
+      ];
+    });
+  });
+  return function requireConfig2(serverConfigPath) {
+    return _ref.apply(this, arguments);
+  };
+}();
 function loadServerConfigNew(serverConfigPath) {
-  var mod = requireExistModule(serverConfigPath);
-  if (mod) {
-    return mod;
-  }
-  return void 0;
+  return _loadServerConfigNew.apply(this, arguments);
+}
+function _loadServerConfigNew() {
+  _loadServerConfigNew = _async_to_generator(function(serverConfigPath) {
+    var mod;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          return [
+            4,
+            requireExistModule(serverConfigPath)
+          ];
+        case 1:
+          mod = _state.sent();
+          if (mod) {
+            return [
+              2,
+              mod
+            ];
+          }
+          return [
+            2,
+            void 0
+          ];
+      }
+    });
+  });
+  return _loadServerConfigNew.apply(this, arguments);
 }
 function loadServerConfigOld(pwd, configFile) {
-  var serverConfigPath = path.join(pwd, "".concat(configFile, ".js"));
-  var serverConfig = requireConfig(serverConfigPath);
-  return serverConfig;
+  return _loadServerConfigOld.apply(this, arguments);
+}
+function _loadServerConfigOld() {
+  _loadServerConfigOld = _async_to_generator(function(pwd, configFile) {
+    var serverConfigPath, serverConfig;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          serverConfigPath = path.join(pwd, "".concat(configFile, ".cjs"));
+          return [
+            4,
+            requireConfig(serverConfigPath)
+          ];
+        case 1:
+          serverConfig = _state.sent();
+          return [
+            2,
+            serverConfig
+          ];
+      }
+    });
+  });
+  return _loadServerConfigOld.apply(this, arguments);
 }
 function loadServerRuntimeConfig(pwd) {
-  var oldServerFile = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : DEFAULT_SERVER_CONFIG, newServerConfigPath = arguments.length > 2 ? arguments[2] : void 0;
-  var newServerConfig = newServerConfigPath && loadServerConfigNew(newServerConfigPath);
-  if (newServerConfig) {
-    return newServerConfig;
-  }
-  var oldServerConfig = loadServerConfigOld(pwd, oldServerFile);
-  return oldServerConfig;
+  return _loadServerRuntimeConfig.apply(this, arguments);
+}
+function _loadServerRuntimeConfig() {
+  _loadServerRuntimeConfig = _async_to_generator(function(pwd) {
+    var oldServerFile, newServerConfigPath, newServerConfig, _tmp, oldServerConfig;
+    var _arguments = arguments;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          oldServerFile = _arguments.length > 1 && _arguments[1] !== void 0 ? _arguments[1] : DEFAULT_SERVER_CONFIG, newServerConfigPath = _arguments.length > 2 ? _arguments[2] : void 0;
+          _tmp = newServerConfigPath;
+          if (!_tmp)
+            return [
+              3,
+              2
+            ];
+          return [
+            4,
+            loadServerConfigNew(newServerConfigPath)
+          ];
+        case 1:
+          _tmp = _state.sent();
+          _state.label = 2;
+        case 2:
+          newServerConfig = _tmp;
+          if (newServerConfig) {
+            return [
+              2,
+              newServerConfig
+            ];
+          }
+          return [
+            4,
+            loadServerConfigOld(pwd, oldServerFile)
+          ];
+        case 3:
+          oldServerConfig = _state.sent();
+          return [
+            2,
+            oldServerConfig
+          ];
+      }
+    });
+  });
+  return _loadServerRuntimeConfig.apply(this, arguments);
 }
 function loadServerCliConfig(pwd) {
   var defaultConfig = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};

package/dist/esm/adapters/node/helper/loadPlugin.js

@@ -1,16 +1,58 @@
-import { compatRequire, tryResolve } from "@modern-js/utils";
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { compatibleRequire, tryResolve } from "@modern-js/utils";
 function resolveServerPlugin(plugin, appDirectory) {
-  var name = plugin.name, options = plugin.options;
-  var pluginPath = tryResolve(name, appDirectory);
-  var module = compatRequire(pluginPath);
-  var pluginInstance = module(options);
-  return pluginInstance;
+  return _resolveServerPlugin.apply(this, arguments);
+}
+function _resolveServerPlugin() {
+  _resolveServerPlugin = _async_to_generator(function(plugin, appDirectory) {
+    var name, options, pluginPath, module, pluginInstance;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          name = plugin.name, options = plugin.options;
+          pluginPath = tryResolve(name, appDirectory);
+          return [
+            4,
+            compatibleRequire(pluginPath)
+          ];
+        case 1:
+          module = _state.sent();
+          pluginInstance = module(options);
+          return [
+            2,
+            pluginInstance
+          ];
+      }
+    });
+  });
+  return _resolveServerPlugin.apply(this, arguments);
 }
 function loadServerPlugins(serverPlugins, appDirectory) {
-  var instances = serverPlugins.map(function(plugin) {
-    return resolveServerPlugin(plugin, appDirectory);
+  return _loadServerPlugins.apply(this, arguments);
+}
+function _loadServerPlugins() {
+  _loadServerPlugins = _async_to_generator(function(serverPlugins, appDirectory) {
+    var instances;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          return [
+            4,
+            Promise.all(serverPlugins.map(function(plugin) {
+              return resolveServerPlugin(plugin, appDirectory);
+            }))
+          ];
+        case 1:
+          instances = _state.sent();
+          return [
+            2,
+            instances
+          ];
+      }
+    });
   });
-  return instances;
+  return _loadServerPlugins.apply(this, arguments);
 }
 export {
   loadServerPlugins

package/dist/esm/adapters/node/plugins/resource.js

@@ -3,7 +3,7 @@ import { _ as _instanceof } from "@swc/helpers/_/_instanceof";
 import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
 import path from "path";
 import { fileReader } from "@modern-js/runtime-utils/fileReader";
-import { LOADABLE_STATS_FILE, MAIN_ENTRY_NAME, NESTED_ROUTE_SPEC_FILE, ROUTE_MANIFEST_FILE, SERVER_BUNDLE_DIRECTORY, fs } from "@modern-js/utils";
+import { LOADABLE_STATS_FILE, MAIN_ENTRY_NAME, NESTED_ROUTE_SPEC_FILE, ROUTE_MANIFEST_FILE, SERVER_BUNDLE_DIRECTORY, fs, compatibleRequire } from "@modern-js/utils";
 function getHtmlTemplates(pwd, routes) {
   return _getHtmlTemplates.apply(this, arguments);
 }
@@ -110,16 +110,9 @@ function injectTemplates(pwd, routes) {
     };
   }();
 }
-var dynamicImport = function(filePath) {
-  try {
-    var module = require(filePath);
-    return Promise.resolve(module);
-  } catch (e) {
-    return Promise.reject(e);
-  }
-};
 var loadBundle = function() {
   var _ref = _async_to_generator(function(filepath, logger) {
+    var module, e;
     return _ts_generator(this, function(_state) {
       switch (_state.label) {
         case 0:
@@ -134,12 +127,34 @@ var loadBundle = function() {
               void 0
             ];
           }
+          _state.label = 2;
+        case 2:
+          _state.trys.push([
+            2,
+            4,
+            ,
+            5
+          ]);
+          return [
+            4,
+            compatibleRequire(filepath, false)
+          ];
+        case 3:
+          module = _state.sent();
           return [
             2,
-            dynamicImport(filepath).catch(function(e) {
-              logger === null || logger === void 0 ? void 0 : logger.error("Load ".concat(filepath, " bundle failed, error = %s"), _instanceof(e, Error) ? e.stack || e.message : e);
-              return void 0;
-            })
+            module
+          ];
+        case 4:
+          e = _state.sent();
+          logger.error("Load ".concat(filepath, " bundle failed, error = %s"), _instanceof(e, Error) ? e.stack || e.message : e);
+          return [
+            2,
+            void 0
+          ];
+        case 5:
+          return [
+            2
           ];
       }
     });
@@ -202,7 +217,7 @@ function _getServerManifest() {
           loadableUri = path.join(pwd, LOADABLE_STATS_FILE);
           return [
             4,
-            import(loadableUri).catch(function(_) {
+            compatibleRequire(loadableUri).catch(function(_) {
               return {};
             })
           ];
@@ -211,7 +226,7 @@ function _getServerManifest() {
           routesManifestUri = path.join(pwd, ROUTE_MANIFEST_FILE);
           return [
             4,
-            import(routesManifestUri).catch(function(_) {
+            compatibleRequire(routesManifestUri).catch(function(_) {
               return {};
             })
           ];

package/dist/esm-node/adapters/node/helper/loadCache.js

@@ -1,9 +1,9 @@
 import path from "path";
 import { SERVER_DIR, requireExistModule } from "@modern-js/utils";
 const CACHE_FILENAME = "cache";
-function loadCacheConfig(pwd) {
+async function loadCacheConfig(pwd) {
   const serverCacheFilepath = path.resolve(pwd, SERVER_DIR, CACHE_FILENAME);
-  const mod = requireExistModule(serverCacheFilepath, {
+  const mod = await requireExistModule(serverCacheFilepath, {
     interop: false
   });
   if (mod === null || mod === void 0 ? void 0 : mod.cacheOption) {

package/dist/esm-node/adapters/node/helper/loadConfig.js

@@ -1,30 +1,30 @@
 import path from "path";
-import { compatRequire, fs, DEFAULT_SERVER_CONFIG, requireExistModule, ensureAbsolutePath, OUTPUT_CONFIG_FILE, lodash as _ } from "@modern-js/utils";
+import { fs, DEFAULT_SERVER_CONFIG, requireExistModule, ensureAbsolutePath, OUTPUT_CONFIG_FILE, lodash as _, compatibleRequire } from "@modern-js/utils";
 import { parse } from "flatted";
-const requireConfig = (serverConfigPath) => {
+const requireConfig = async (serverConfigPath) => {
   if (fs.pathExistsSync(serverConfigPath)) {
-    return compatRequire(serverConfigPath);
+    return compatibleRequire(serverConfigPath);
   }
   return void 0;
 };
-function loadServerConfigNew(serverConfigPath) {
-  const mod = requireExistModule(serverConfigPath);
+async function loadServerConfigNew(serverConfigPath) {
+  const mod = await requireExistModule(serverConfigPath);
   if (mod) {
     return mod;
   }
   return void 0;
 }
-function loadServerConfigOld(pwd, configFile) {
-  const serverConfigPath = path.join(pwd, `${configFile}.js`);
-  const serverConfig = requireConfig(serverConfigPath);
+async function loadServerConfigOld(pwd, configFile) {
+  const serverConfigPath = path.join(pwd, `${configFile}.cjs`);
+  const serverConfig = await requireConfig(serverConfigPath);
   return serverConfig;
 }
-function loadServerRuntimeConfig(pwd, oldServerFile = DEFAULT_SERVER_CONFIG, newServerConfigPath) {
-  const newServerConfig = newServerConfigPath && loadServerConfigNew(newServerConfigPath);
+async function loadServerRuntimeConfig(pwd, oldServerFile = DEFAULT_SERVER_CONFIG, newServerConfigPath) {
+  const newServerConfig = newServerConfigPath && await loadServerConfigNew(newServerConfigPath);
   if (newServerConfig) {
     return newServerConfig;
   }
-  const oldServerConfig = loadServerConfigOld(pwd, oldServerFile);
+  const oldServerConfig = await loadServerConfigOld(pwd, oldServerFile);
   return oldServerConfig;
 }
 function loadServerCliConfig(pwd, defaultConfig = {}) {

package/dist/esm-node/adapters/node/helper/loadPlugin.js

@@ -1,13 +1,13 @@
-import { compatRequire, tryResolve } from "@modern-js/utils";
-function resolveServerPlugin(plugin, appDirectory) {
+import { compatibleRequire, tryResolve } from "@modern-js/utils";
+async function resolveServerPlugin(plugin, appDirectory) {
   const { name, options } = plugin;
   const pluginPath = tryResolve(name, appDirectory);
-  const module = compatRequire(pluginPath);
+  const module = await compatibleRequire(pluginPath);
   const pluginInstance = module(options);
   return pluginInstance;
 }
-function loadServerPlugins(serverPlugins, appDirectory) {
-  const instances = serverPlugins.map((plugin) => resolveServerPlugin(plugin, appDirectory));
+async function loadServerPlugins(serverPlugins, appDirectory) {
+  const instances = await Promise.all(serverPlugins.map((plugin) => resolveServerPlugin(plugin, appDirectory)));
   return instances;
 }
 export {

package/dist/esm-node/adapters/node/plugins/resource.js

@@ -1,6 +1,6 @@
 import path from "path";
 import { fileReader } from "@modern-js/runtime-utils/fileReader";
-import { LOADABLE_STATS_FILE, MAIN_ENTRY_NAME, NESTED_ROUTE_SPEC_FILE, ROUTE_MANIFEST_FILE, SERVER_BUNDLE_DIRECTORY, fs } from "@modern-js/utils";
+import { LOADABLE_STATS_FILE, MAIN_ENTRY_NAME, NESTED_ROUTE_SPEC_FILE, ROUTE_MANIFEST_FILE, SERVER_BUNDLE_DIRECTORY, fs, compatibleRequire } from "@modern-js/utils";
 async function getHtmlTemplates(pwd, routes) {
   const htmls = await Promise.all(routes.map(async (route) => {
     let html;
@@ -27,22 +27,17 @@ function injectTemplates(pwd, routes) {
     await next();
   };
 }
-const dynamicImport = (filePath) => {
-  try {
-    const module = require(filePath);
-    return Promise.resolve(module);
-  } catch (e) {
-    return Promise.reject(e);
-  }
-};
 const loadBundle = async (filepath, logger) => {
   if (!await fs.pathExists(filepath)) {
     return void 0;
   }
-  return dynamicImport(filepath).catch((e) => {
-    logger === null || logger === void 0 ? void 0 : logger.error(`Load ${filepath} bundle failed, error = %s`, e instanceof Error ? e.stack || e.message : e);
+  try {
+    const module = await compatibleRequire(filepath, false);
+    return module;
+  } catch (e) {
+    logger.error(`Load ${filepath} bundle failed, error = %s`, e instanceof Error ? e.stack || e.message : e);
     return void 0;
-  });
+  }
 };
 async function getServerManifest(pwd, routes, logger) {
   const loaderBundles = {};
@@ -57,9 +52,9 @@ async function getServerManifest(pwd, routes, logger) {
     loaderBundle && (loaderBundles[entryName] = loaderBundle);
   }));
   const loadableUri = path.join(pwd, LOADABLE_STATS_FILE);
-  const loadableStats = await import(loadableUri).catch((_) => ({}));
+  const loadableStats = await compatibleRequire(loadableUri).catch((_) => ({}));
   const routesManifestUri = path.join(pwd, ROUTE_MANIFEST_FILE);
-  const routeManifest = await import(routesManifestUri).catch((_) => ({}));
+  const routeManifest = await compatibleRequire(routesManifestUri).catch((_) => ({}));
   const nestedRoutesJsonPath = path.join(pwd, NESTED_ROUTE_SPEC_FILE);
   const nestedRoutesJson = await import(nestedRoutesJsonPath).catch((_) => ({}));
   return {

package/dist/types/adapters/node/helper/loadCache.d.ts

@@ -1,2 +1,2 @@
 import { CacheConfig } from '../../../types';
-export declare function loadCacheConfig(pwd: string): CacheConfig | undefined;
+export declare function loadCacheConfig(pwd: string): Promise<CacheConfig | undefined>;

package/dist/types/adapters/node/helper/loadConfig.d.ts

@@ -1,3 +1,3 @@
 import { CliConfig, ServerConfig, UserConfig } from '../../../types';
-export declare function loadServerRuntimeConfig(pwd: string, oldServerFile?: string, newServerConfigPath?: string): ServerConfig | undefined;
+export declare function loadServerRuntimeConfig(pwd: string, oldServerFile?: string, newServerConfigPath?: string): Promise<ServerConfig | undefined>;
 export declare function loadServerCliConfig(pwd: string, defaultConfig?: UserConfig): CliConfig;

package/dist/types/adapters/node/helper/loadPlugin.d.ts

@@ -1,3 +1,3 @@
 import { ServerPlugin } from '@modern-js/types';
 import { ServerPlugin as ServerPluginInstance } from '../../../types';
-export declare function loadServerPlugins(serverPlugins: ServerPlugin[], appDirectory: string): ServerPluginInstance[];
+export declare function loadServerPlugins(serverPlugins: ServerPlugin[], appDirectory: string): Promise<ServerPluginInstance[]>;

package/package.json

@@ -15,7 +15,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "2.58.1",
+  "version": "2.58.2-alpha.0",
   "jsnext:source": "./src/index.ts",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/cjs/index.js",
@@ -54,8 +54,8 @@
     "hono": "^3.12.2",
     "ts-deepmerge": "7.0.0",
     "@modern-js/plugin": "2.58.1",
-    "@modern-js/runtime-utils": "2.58.1",
-    "@modern-js/utils": "2.58.1"
+    "@modern-js/utils": "2.58.1",
+    "@modern-js/runtime-utils": "2.58.1"
   },
   "devDependencies": {
     "@types/jest": "^29",