@modern-js/server-core 2.48.6 → 2.49.1-alpha.0

package/dist/cjs/base/middlewares/renderHandler/ssrRender.js

@@ -0,0 +1,212 @@
+"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 ssrRender_exports = {};
+__export(ssrRender_exports, {
+  getPathnameFromNodeReq: () => getPathnameFromNodeReq,
+  ssrRender: () => ssrRender
+});
+module.exports = __toCommonJS(ssrRender_exports);
+var import_constants = require("@modern-js/utils/universal/constants");
+var isbot = __toESM(require("isbot"));
+var import_utils = require("../../utils");
+var import_constants2 = require("../../constants");
+var import_serverTiming = require("./serverTiming");
+const defaultReporter = {
+  init() {
+  },
+  reportError() {
+  },
+  reportTiming() {
+  },
+  reportInfo() {
+  },
+  reportWarn() {
+  }
+};
+async function ssrRender(request, { routeInfo, html, staticGenerate, nonce, metaName, reporter, logger, nodeReq, serverManifest, locals, metrics }) {
+  var _serverManifest_renderBundles;
+  const { entryName } = routeInfo;
+  const loadableStats = serverManifest.loadableStats || {};
+  const routeManifest = serverManifest.routeManifest || {};
+  const host = (0, import_utils.getHost)(request);
+  const isSpider = isbot.default(request.headers.get("user-agent"));
+  const responseProxy = new ResponseProxy();
+  const query = (0, import_utils.parseQuery)(request);
+  const headers = (0, import_utils.parseHeaders)(request);
+  if (nodeReq) {
+    for (const key in nodeReq.headers) {
+      if (!headers[key]) {
+        headers[key] = nodeReq.headers[key];
+      }
+    }
+  }
+  const ssrContext = {
+    request: {
+      baseUrl: routeInfo.urlPath,
+      params: {},
+      pathname: nodeReq ? getPathnameFromNodeReq(nodeReq) : (0, import_utils.getPathname)(request),
+      host,
+      query,
+      url: nodeReq ? getHrefFromNodeReq(nodeReq) : request.url,
+      headers
+    },
+    response: {
+      setHeader(key, value) {
+        responseProxy.headers.set(key, value);
+      },
+      status(code) {
+        responseProxy.status = code;
+      },
+      locals: locals || {}
+    },
+    redirection: {},
+    template: html,
+    loadableStats,
+    routeManifest,
+    entryName,
+    staticGenerate,
+    logger,
+    metrics,
+    serverTiming: new import_serverTiming.ServerTiming(responseProxy.headers, metaName),
+    reporter: reporter || defaultReporter,
+    /** @deprecated node req */
+    req: nodeReq || request,
+    /** @deprecated node res  */
+    res: void 0,
+    isSpider,
+    nonce
+  };
+  const renderBundle = (_serverManifest_renderBundles = serverManifest.renderBundles) === null || _serverManifest_renderBundles === void 0 ? void 0 : _serverManifest_renderBundles[entryName || import_constants.MAIN_ENTRY_NAME];
+  if (!renderBundle) {
+    throw new Error(`Can't found renderBundle ${entryName || import_constants.MAIN_ENTRY_NAME}`);
+  }
+  const runtimeEnv = (0, import_utils.getRuntimeEnv)();
+  let ssrResult;
+  let cacheStatus;
+  const render = renderBundle[import_constants.SERVER_RENDER_FUNCTION_NAME];
+  if (runtimeEnv === "node") {
+    const cacheModuleName = "./ssrCache";
+    const { ssrCache } = await Promise.resolve().then(() => __toESM(require(cacheModuleName)));
+    const incomingMessage = nodeReq ? nodeReq : new IncomingMessgeProxy(request);
+    const cacheControl = await ssrCache.matchCacheControl(incomingMessage);
+    if (cacheControl) {
+      const { data: data2, status } = await ssrCache.getCache(request, cacheControl, render, ssrContext);
+      ssrResult = data2;
+      cacheStatus = status;
+    } else {
+      ssrResult = await render(ssrContext);
+    }
+  } else {
+    ssrResult = await render(ssrContext);
+  }
+  const { redirection } = ssrContext;
+  if (cacheStatus) {
+    responseProxy.headers.set(import_constants2.X_RENDER_CACHE, cacheStatus);
+  }
+  if (redirection.url) {
+    const { headers: headers2 } = responseProxy;
+    headers2.set("Location", redirection.url);
+    return new Response(null, {
+      status: redirection.status || 302,
+      headers: {
+        Location: redirection.url
+      }
+    });
+  }
+  const { Readable } = await Promise.resolve().then(() => __toESM(require("stream"))).catch((_) => ({
+    Readable: void 0
+  }));
+  const streamModule = "../../adapters/node/polyfills/stream";
+  const { createReadableStreamFromReadable } = runtimeEnv === "node" ? await Promise.resolve().then(() => __toESM(require(streamModule))).catch((_) => ({
+    createReadableStreamFromReadable: void 0
+  })) : {
+    createReadableStreamFromReadable: void 0
+  };
+  const data = Readable && ssrResult instanceof Readable ? (createReadableStreamFromReadable === null || createReadableStreamFromReadable === void 0 ? void 0 : createReadableStreamFromReadable(ssrResult)) || "" : ssrResult;
+  if (typeof data !== "string") {
+    responseProxy.headers.set("transfer-encoding", "chunked");
+  }
+  return new Response(data, {
+    status: responseProxy.status,
+    headers: responseProxy.headers
+  });
+}
+class ResponseProxy {
+  constructor() {
+    this.headers = new Headers();
+    this.status = 200;
+    this.headers.set("content-type", "text/html; charset=UTF-8");
+  }
+}
+class IncomingMessgeProxy {
+  constructor(req) {
+    this.headers = {};
+    req.headers.forEach((value, key) => {
+      this.headers[key] = value;
+    });
+    this.method = req.method;
+    this.url = (0, import_utils.getPathname)(req);
+  }
+}
+function getHrefFromNodeReq(nodeReq) {
+  function getProtocal() {
+    if (nodeReq.socket.encrypted) {
+      return "https";
+    }
+    const proto = nodeReq.headers["x-forwarded-proto"];
+    return proto ? proto.split(/\s*,\s*/, 1)[0] : "http";
+  }
+  function getHost2() {
+    let host = nodeReq.headers["x-forwarded-host"];
+    if (!host) {
+      host = nodeReq.headers.host;
+    }
+    host = host.split(/\s*,\s*/, 1)[0] || "undefined";
+    return host;
+  }
+  const href = `${getProtocal()}://${getHost2()}${nodeReq.url || ""}`;
+  return href;
+}
+function getPathnameFromNodeReq(nodeReq) {
+  const { url } = nodeReq;
+  if (!url) {
+    return "/";
+  }
+  const match = url.match(/\/[^?]*/);
+  let pathname = match ? match[0] : "/";
+  if (pathname !== "/" && pathname.endsWith("/")) {
+    pathname = pathname.slice(0, -1);
+  }
+  return pathname;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getPathnameFromNodeReq,
+  ssrRender
+});

package/dist/cjs/base/serverBase.js

@@ -0,0 +1,203 @@
+"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 serverBase_exports = {};
+__export(serverBase_exports, {
+  ServerBase: () => ServerBase,
+  createServerBase: () => createServerBase
+});
+module.exports = __toCommonJS(serverBase_exports);
+var import_constants = require("@modern-js/utils/universal/constants");
+var import_hono = require("hono");
+var import_core = require("../core");
+var import_utils = require("./utils");
+class ServerBase {
+  /**
+  * 初始化顺序
+  * - 获取 server runtime config
+  * - 设置 context
+  * - 创建 hooksRunner
+  * - 合并插件，内置插件和 serverConfig 中配置的插件
+  * - 执行 config hook
+  * - 获取最终的配置
+  * - 设置配置到 context
+  * - 执行 prepare hook
+  */
+  async init() {
+    const { options } = this;
+    const runtimeEnv = (0, import_utils.getRuntimeEnv)();
+    runtimeEnv === "node" && await this.initServerConfig(options);
+    await this.injectContext(options);
+    this.runner = await this.createHookRunner();
+    runtimeEnv === "node" && await this.initConfig(this.runner, options);
+    await this.injectContext(options);
+    await this.runner.prepare();
+    return this;
+  }
+  async createHookRunner() {
+    import_core.serverManager.clear();
+    const runtimeEnv = (0, import_utils.getRuntimeEnv)();
+    const internalPlugins = runtimeEnv === "node" ? await this.loadInternalPlugins() : [];
+    const externalPlugins = this.loadExternalPlugins();
+    const loadedPlugins = [
+      ...internalPlugins,
+      ...externalPlugins
+    ];
+    loadedPlugins.forEach((p) => {
+      import_core.serverManager.usePlugin(p);
+    });
+    const hooksRunner = await import_core.serverManager.init();
+    return hooksRunner;
+  }
+  async loadInternalPlugins() {
+    const { internalPlugins: plugins = import_constants.INTERNAL_SERVER_PLUGINS, appContext, pwd } = this.options;
+    const loadPluginsModule = "../core/loadPlugins";
+    const { loadPlugins } = await Promise.resolve().then(() => __toESM(require(loadPluginsModule)));
+    const internalPlugins = loadPlugins(appContext.appDirectory || pwd, plugins);
+    return internalPlugins;
+  }
+  loadExternalPlugins() {
+    const { plugins = [] } = this.options;
+    const configPlugins = this.serverConfig.plugins || [];
+    const externalPlugins = [
+      ...plugins,
+      ...configPlugins
+    ];
+    return externalPlugins.map((plugin) => (0, import_core.createPlugin)(plugin.setup, plugin));
+  }
+  async initServerConfig(options) {
+    const { pwd, serverConfigFile } = options;
+    const utilsModuleName = "./utils/serverConfig";
+    const { getServerConfigPath, requireConfig } = await Promise.resolve().then(() => __toESM(require(utilsModuleName)));
+    const serverConfigPath = await getServerConfigPath(pwd, serverConfigFile);
+    const serverConfig = requireConfig(serverConfigPath);
+    this.serverConfig = serverConfig;
+  }
+  async injectContext(options) {
+    const appContext = await this.initAppContext();
+    const { config, pwd } = options;
+    import_core.ConfigContext.set(config);
+    import_core.AppContext.set({
+      ...appContext,
+      serverBase: this,
+      distDirectory: pwd
+    });
+  }
+  async initAppContext() {
+    const { options } = this;
+    const { pwd, plugins = [], appContext } = options;
+    const serverPlugins = plugins.map((p) => ({
+      server: p
+    }));
+    return {
+      appDirectory: (appContext === null || appContext === void 0 ? void 0 : appContext.appDirectory) || "",
+      apiDirectory: appContext === null || appContext === void 0 ? void 0 : appContext.apiDirectory,
+      lambdaDirectory: appContext === null || appContext === void 0 ? void 0 : appContext.lambdaDirectory,
+      sharedDirectory: appContext.sharedDirectory || "",
+      distDirectory: pwd,
+      plugins: serverPlugins
+    };
+  }
+  /**
+  * Execute config hooks
+  * @param runner
+  * @param options
+  */
+  runConfigHook(runner, serverConfig) {
+    const newServerConfig = runner.config(serverConfig || {});
+    return newServerConfig;
+  }
+  async initConfig(runner, options) {
+    const path = await Promise.resolve().then(() => __toESM(require("path"))).catch((_) => {
+      return {};
+    });
+    const utilsModuleName = "@modern-js/utils";
+    const { ensureAbsolutePath, OUTPUT_CONFIG_FILE } = await Promise.resolve().then(() => __toESM(require(utilsModuleName)));
+    const configModuleName = "./utils/serverConfig";
+    const { loadConfig } = await Promise.resolve().then(() => __toESM(require(configModuleName)));
+    const { pwd, config } = options;
+    const { serverConfig } = this;
+    const finalServerConfig = this.runConfigHook(runner, serverConfig);
+    const resolvedConfigPath = ensureAbsolutePath(pwd, path.join(config.output.path || "dist", OUTPUT_CONFIG_FILE));
+    options.config = loadConfig({
+      cliConfig: config,
+      serverConfig: finalServerConfig,
+      resolvedConfigPath
+    });
+  }
+  get all() {
+    return this.app.all.bind(this.app);
+  }
+  get use() {
+    return this.app.use.bind(this.app);
+  }
+  get get() {
+    return this.app.get.bind(this.app);
+  }
+  get post() {
+    return this.app.post.bind(this.app);
+  }
+  get put() {
+    return this.app.put.bind(this.app);
+  }
+  get delete() {
+    return this.app.delete.bind(this.app);
+  }
+  get patch() {
+    return this.app.patch.bind(this.app);
+  }
+  get handle() {
+    return this.app.fetch.bind(this.app);
+  }
+  get request() {
+    return this.app.request.bind(this.app);
+  }
+  get notFound() {
+    return this.app.notFound.bind(this.app);
+  }
+  get onError() {
+    return this.app.onError.bind(this.app);
+  }
+  constructor(options) {
+    this.serverConfig = {};
+    this.options = options;
+    this.app = new import_hono.Hono();
+  }
+}
+function createServerBase(options) {
+  if (options == null) {
+    throw new Error("can not start server without options");
+  }
+  const server = new ServerBase(options);
+  return server;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ServerBase,
+  createServerBase
+});

package/dist/cjs/base/utils/debug.js

@@ -0,0 +1,29 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var debug_exports = {};
+__export(debug_exports, {
+  debug: () => debug
+});
+module.exports = __toCommonJS(debug_exports);
+var import_utils = require("@modern-js/utils");
+const debug = (0, import_utils.createDebugger)("prod-server");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  debug
+});

package/dist/cjs/base/utils/entry.js

@@ -0,0 +1,30 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var entry_exports = {};
+__export(entry_exports, {
+  sortRoutes: () => sortRoutes
+});
+module.exports = __toCommonJS(entry_exports);
+const sortRoutes = (route1, route2) => {
+  return route2.urlPath.length - route1.urlPath.length;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  sortRoutes
+});

package/dist/cjs/base/utils/env.js

@@ -0,0 +1,45 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var env_exports = {};
+__export(env_exports, {
+  checkIsProd: () => checkIsProd,
+  getRuntimeEnv: () => getRuntimeEnv
+});
+module.exports = __toCommonJS(env_exports);
+const getRuntimeEnv = () => {
+  var _globalThis_process_release, _globalThis_process, _globalThis;
+  if (((_globalThis = globalThis) === null || _globalThis === void 0 ? void 0 : (_globalThis_process = _globalThis.process) === null || _globalThis_process === void 0 ? void 0 : (_globalThis_process_release = _globalThis_process.release) === null || _globalThis_process_release === void 0 ? void 0 : _globalThis_process_release.name) === "node") {
+    return "node";
+  }
+  return "other";
+};
+const checkIsProd = () => {
+  const env = getRuntimeEnv();
+  switch (env) {
+    case "node":
+      return process.env.NODE_ENV === "production";
+    default:
+      return false;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  checkIsProd,
+  getRuntimeEnv
+});

package/dist/cjs/base/utils/error.js

@@ -0,0 +1,65 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var error_exports = {};
+__export(error_exports, {
+  createErrorHtml: () => createErrorHtml
+});
+module.exports = __toCommonJS(error_exports);
+const ERROR_PAGE_TEXT = {
+  404: "This page could not be found.",
+  500: "Internal Server Error."
+};
+const createErrorHtml = (status) => {
+  const text = ERROR_PAGE_TEXT[status] || "";
+  const title = `${status}: ${text}`;
+  return `<!DOCTYPE html>
+  <html lang="en">
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width">
+    <title>${title}</title>
+    <style>
+      html,body {
+        margin: 0;
+      }
+
+      .page-container {
+        color: #000;
+        background: #fff;
+        height: 100vh;
+        text-align: center;
+        display: flex;
+        flex-direction: column;
+        align-items: center;
+        justify-content: center;
+      }
+    </style>
+  </head>
+  <body>
+    <div class="page-container">
+    <h1>${status}</h1>
+    <div>${text}</div>
+  </body>
+  </html>
+  `;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createErrorHtml
+});

package/dist/cjs/base/utils/index.js

@@ -0,0 +1,34 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var utils_exports = {};
+module.exports = __toCommonJS(utils_exports);
+__reExport(utils_exports, require("./env"), module.exports);
+__reExport(utils_exports, require("./request"), module.exports);
+__reExport(utils_exports, require("./transformStream"), module.exports);
+__reExport(utils_exports, require("./middlewareCollector"), module.exports);
+__reExport(utils_exports, require("./error"), module.exports);
+__reExport(utils_exports, require("./warmup"), module.exports);
+__reExport(utils_exports, require("./entry"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./env"),
+  ...require("./request"),
+  ...require("./transformStream"),
+  ...require("./middlewareCollector"),
+  ...require("./error"),
+  ...require("./warmup"),
+  ...require("./entry")
+});

package/dist/cjs/base/utils/middlewareCollector.js

@@ -0,0 +1,54 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var middlewareCollector_exports = {};
+__export(middlewareCollector_exports, {
+  createMiddlewareCollecter: () => createMiddlewareCollecter,
+  mergeExtension: () => mergeExtension
+});
+module.exports = __toCommonJS(middlewareCollector_exports);
+const mergeExtension = (users) => {
+  const output = [];
+  return {
+    middleware: output.concat(users)
+  };
+};
+const createMiddlewareCollecter = () => {
+  const webMiddlewares = [];
+  const apiMiddlewares = [];
+  const addWebMiddleware = (input) => {
+    webMiddlewares.push(input);
+  };
+  const addAPIMiddleware = (input) => {
+    apiMiddlewares.push(input);
+  };
+  const getMiddlewares = () => ({
+    web: webMiddlewares,
+    api: apiMiddlewares
+  });
+  return {
+    getMiddlewares,
+    addWebMiddleware,
+    addAPIMiddleware
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createMiddlewareCollecter,
+  mergeExtension
+});