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

package/dist/cjs/base/utils/request.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 request_exports = {};
+__export(request_exports, {
+  getHost: () => getHost,
+  getPathname: () => getPathname,
+  parseHeaders: () => parseHeaders,
+  parseQuery: () => parseQuery
+});
+module.exports = __toCommonJS(request_exports);
+function parseQuery(request) {
+  const { url } = request;
+  const q = url.split("?")[1];
+  const query = {};
+  if (q) {
+    q.split("&").forEach((item) => {
+      const [key, value] = item.split("=");
+      query[key] = value;
+    });
+  }
+  return query;
+}
+function parseHeaders(request) {
+  const headersData = {};
+  request.headers.forEach((value, key) => {
+    headersData[key] = value;
+  });
+  return headersData;
+}
+function getPathname(request) {
+  const match = request.url.match(/^https?:\/\/[^/]+(\/[^?]*)/);
+  return match ? match[1] : "/";
+}
+function getHost(request) {
+  const { headers } = request;
+  let host = headers.get("X-Forwarded-Host");
+  if (!host) {
+    host = headers.get("Host");
+  }
+  host = (host === null || host === void 0 ? void 0 : host.split(/\s*,\s*/, 1)[0]) || "undefined";
+  return host;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getHost,
+  getPathname,
+  parseHeaders,
+  parseQuery
+});

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

@@ -0,0 +1,70 @@
+"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 serverConfig_exports = {};
+__export(serverConfig_exports, {
+  getServerConfigPath: () => getServerConfigPath,
+  loadConfig: () => loadConfig,
+  requireConfig: () => requireConfig
+});
+module.exports = __toCommonJS(serverConfig_exports);
+var import_utils = require("@modern-js/utils");
+var import_merge_deep = __toESM(require("merge-deep"));
+const getServerConfigPath = async (distDirectory, serverConfigFile = import_utils.DEFAULT_SERVER_CONFIG) => {
+  const path = await Promise.resolve().then(() => __toESM(require("path")));
+  const serverConfigPath = path.join(distDirectory, serverConfigFile);
+  return `${serverConfigPath}.js`;
+};
+const requireConfig = (serverConfigPath) => {
+  if (import_utils.fs.pathExistsSync(serverConfigPath)) {
+    return (0, import_utils.compatRequire)(serverConfigPath);
+  }
+  return {};
+};
+const loadConfig = ({ cliConfig, serverConfig, resolvedConfigPath }) => {
+  let config = null;
+  if (process.env.NODE_ENV === "production") {
+    const resolvedConfig = requireConfig(resolvedConfigPath);
+    config = (0, import_merge_deep.default)({
+      ...resolvedConfig,
+      plugins: []
+    }, serverConfig, cliConfig);
+  } else {
+    config = (0, import_merge_deep.default)({
+      ...cliConfig,
+      plugins: []
+    }, serverConfig);
+  }
+  return config;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getServerConfigPath,
+  loadConfig,
+  requireConfig
+});

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

@@ -0,0 +1,61 @@
+"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 transformStream_exports = {};
+__export(transformStream_exports, {
+  createTransformStream: () => createTransformStream,
+  transformResponse: () => transformResponse
+});
+module.exports = __toCommonJS(transformStream_exports);
+function createTransformStream(fn) {
+  const decoder = new TextDecoder();
+  const encoder = new TextEncoder();
+  return new TransformStream({
+    async transform(chunk, controller) {
+      const content = decoder.decode(chunk);
+      const newContent = await fn(content);
+      controller.enqueue(encoder.encode(newContent));
+    }
+  });
+}
+function transformResponse(response, transformCb) {
+  let readable = null;
+  if (response.body) {
+    const stream = createTransformStream(async (before) => {
+      if (Array.isArray(transformCb)) {
+        return transformCb.reduce(async (before2, cb) => {
+          return cb(await before2);
+        }, Promise.resolve(before));
+      } else {
+        return transformCb(before);
+      }
+    });
+    response.body.pipeThrough(stream);
+    readable = stream.readable;
+  }
+  return new Response(readable, {
+    status: response.status,
+    headers: response.headers,
+    statusText: response.statusText
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createTransformStream,
+  transformResponse
+});

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

@@ -0,0 +1,43 @@
+"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 warmup_exports = {};
+__export(warmup_exports, {
+  warmup: () => warmup
+});
+module.exports = __toCommonJS(warmup_exports);
+function warmup(bundles) {
+  bundles.forEach((bundle) => {
+    bundle && Promise.resolve().then(() => __toESM(require(bundle))).catch((_) => {
+    });
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  warmup
+});

package/dist/cjs/core/index.js

@@ -0,0 +1,22 @@
+"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 core_exports = {};
+module.exports = __toCommonJS(core_exports);
+__reExport(core_exports, require("./plugin"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./plugin")
+});

package/dist/cjs/{loadPlugins.js → core/loadPlugins.js}

@@ -22,7 +22,7 @@ __export(loadPlugins_exports, {
 });
 module.exports = __toCommonJS(loadPlugins_exports);
 var import_utils = require("@modern-js/utils");
-var import_plugin = require("./plugin");
+var import_plugin = require("../core/plugin");
 const resolvePlugin = (p, appDirectory) => {
   const isPluginInstance = typeof p !== "string";
   if (isPluginInstance) {
@@ -37,12 +37,9 @@ const resolvePlugin = (p, appDirectory) => {
     module: (0, import_plugin.createPlugin)(pluginInstance.setup, pluginInstance)
   };
 };
-const loadPlugins = (appDirectory, configPlugins, options) => {
-  const loadedPlugins = (0, import_utils.getInternalPlugins)(appDirectory, options.internalPlugins);
-  return [
-    ...loadedPlugins,
-    ...configPlugins
-  ].map((plugin) => {
+const loadPlugins = (appDirectory, internalPlugins) => {
+  const loadedPlugins = (0, import_utils.getInternalPlugins)(appDirectory, internalPlugins);
+  return loadedPlugins.map((plugin) => {
     const { module: module2 } = resolvePlugin(plugin, appDirectory);
     return module2;
   });

package/dist/cjs/{plugin.js → core/plugin.js}

@@ -32,34 +32,14 @@ var import_plugin = require("@modern-js/plugin");
 const gather = (0, import_plugin.createParallelWorkflow)();
 const config = (0, import_plugin.createWaterfall)();
 const prepare = (0, import_plugin.createWaterfall)();
-const prepareLoaderHandler = (0, import_plugin.createAsyncPipeline)();
 const prepareWebServer = (0, import_plugin.createAsyncPipeline)();
 const prepareApiServer = (0, import_plugin.createAsyncPipeline)();
-const onApiChange = (0, import_plugin.createWaterfall)();
+const onApiChange = (0, import_plugin.createAsyncWaterfall)();
 const repack = (0, import_plugin.createWaterfall)();
 const beforeServerInit = (0, import_plugin.createAsyncWaterfall)();
-const afterServerInit = (0, import_plugin.createAsyncWaterfall)();
-const setupCompiler = (0, import_plugin.createParallelWorkflow)();
-const beforeRouteSet = (0, import_plugin.createAsyncPipeline)();
-const afterRouteSet = (0, import_plugin.createAsyncPipeline)();
-const beforeProdServer = (0, import_plugin.createParallelWorkflow)();
-const afterProdServer = (0, import_plugin.createParallelWorkflow)();
-const listen = (0, import_plugin.createParallelWorkflow)();
-const beforeServerReset = (0, import_plugin.createParallelWorkflow)();
-const afterServerReset = (0, import_plugin.createParallelWorkflow)();
-const extendSSRContext = (0, import_plugin.createAsyncWaterfall)();
-const extendContext = (0, import_plugin.createAsyncPipeline)();
-const handleError = (0, import_plugin.createParallelWorkflow)();
-const handleSSRFallback = (0, import_plugin.createParallelWorkflow)();
-const beforeMatch = (0, import_plugin.createAsyncPipeline)();
 const afterMatch = (0, import_plugin.createAsyncPipeline)();
-const prefetch = (0, import_plugin.createParallelWorkflow)();
-const renderToString = (0, import_plugin.createAsyncPipeline)();
-const beforeRender = (0, import_plugin.createAsyncPipeline)();
 const afterRender = (0, import_plugin.createAsyncPipeline)();
 const afterStreamingRender = (0, import_plugin.createAsyncPipeline)();
-const beforeSend = (0, import_plugin.createAsyncPipeline)();
-const afterSend = (0, import_plugin.createParallelWorkflow)();
 const reset = (0, import_plugin.createParallelWorkflow)();
 const AppContext = (0, import_plugin.createContext)({});
 const setAppContext = (value) => AppContext.set(value);
@@ -76,35 +56,14 @@ const serverHooks = {
   gather,
   config,
   prepare,
-  prepareLoaderHandler,
   prepareWebServer,
   prepareApiServer,
   repack,
   onApiChange,
   beforeServerInit,
-  afterServerInit,
-  setupCompiler,
-  beforeRouteSet,
-  afterRouteSet,
-  beforeProdServer,
-  afterProdServer,
-  listen,
-  beforeServerReset,
-  afterServerReset,
-  // request hook
-  extendSSRContext,
-  extendContext,
-  handleError,
-  handleSSRFallback,
-  beforeMatch,
   afterMatch,
-  prefetch,
-  renderToString,
-  beforeRender,
   afterRender,
   afterStreamingRender,
-  beforeSend,
-  afterSend,
   reset
 };
 const createServerManager = () => (0, import_plugin.createAsyncManager)(serverHooks, pluginAPI);

package/dist/cjs/core/render.js

@@ -0,0 +1,16 @@
+"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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var render_exports = {};
+module.exports = __toCommonJS(render_exports);

package/dist/cjs/core/server.js

@@ -0,0 +1,16 @@
+"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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var server_exports = {};
+module.exports = __toCommonJS(server_exports);

package/dist/cjs/index.js

@@ -15,14 +15,16 @@ var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "defau
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var src_exports = {};
 module.exports = __toCommonJS(src_exports);
-__reExport(src_exports, require("./plugin"), module.exports);
+__reExport(src_exports, require("./core/plugin"), module.exports);
+__reExport(src_exports, require("./core/render"), module.exports);
 __reExport(src_exports, require("@modern-js/plugin"), module.exports);
-__reExport(src_exports, require("./loadPlugins"), module.exports);
+__reExport(src_exports, require("./core/loadPlugins"), module.exports);
 __reExport(src_exports, require("./types/config"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  ...require("./plugin"),
+  ...require("./core/plugin"),
+  ...require("./core/render"),
   ...require("@modern-js/plugin"),
-  ...require("./loadPlugins"),
+  ...require("./core/loadPlugins"),
   ...require("./types/config")
 });

package/dist/esm/base/adapters/node/bff.js

@@ -0,0 +1,128 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _object_without_properties } from "@swc/helpers/_/_object_without_properties";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { isWebOnly } from "@modern-js/utils";
+import { getRenderHandler } from "../../../base/middlewares";
+import { createMiddlewareCollecter, getRuntimeEnv } from "../../utils";
+var bindBFFHandler = function() {
+  var _ref = _async_to_generator(function(server, options) {
+    var _options_config_bff, _options_config, _options_config_bff1, _options_config1, _options_config_bff2, _options_config2, prefix, enableHandleWeb, httpMethodDecider, runtimeEnv, _createMiddlewareCollecter, getMiddlewares, collector, runner, webOnly, handler, renderHandler, _tmp;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          prefix = (options === null || options === void 0 ? void 0 : (_options_config = options.config) === null || _options_config === void 0 ? void 0 : (_options_config_bff = _options_config.bff) === null || _options_config_bff === void 0 ? void 0 : _options_config_bff.prefix) || "/api";
+          enableHandleWeb = options === null || options === void 0 ? void 0 : (_options_config1 = options.config) === null || _options_config1 === void 0 ? void 0 : (_options_config_bff1 = _options_config1.bff) === null || _options_config_bff1 === void 0 ? void 0 : _options_config_bff1.enableHandleWeb;
+          httpMethodDecider = options === null || options === void 0 ? void 0 : (_options_config2 = options.config) === null || _options_config2 === void 0 ? void 0 : (_options_config_bff2 = _options_config2.bff) === null || _options_config_bff2 === void 0 ? void 0 : _options_config_bff2.httpMethodDecider;
+          runtimeEnv = getRuntimeEnv();
+          if (runtimeEnv !== "node") {
+            return [
+              2
+            ];
+          }
+          _createMiddlewareCollecter = createMiddlewareCollecter(), getMiddlewares = _createMiddlewareCollecter.getMiddlewares, collector = _object_without_properties(_createMiddlewareCollecter, [
+            "getMiddlewares"
+          ]);
+          runner = server.runner;
+          return [
+            4,
+            runner.gather(collector)
+          ];
+        case 1:
+          _state.sent();
+          return [
+            4,
+            isWebOnly()
+          ];
+        case 2:
+          webOnly = _state.sent();
+          if (!webOnly)
+            return [
+              3,
+              3
+            ];
+          handler = function() {
+            var _ref2 = _async_to_generator(function(c, next) {
+              return _ts_generator(this, function(_state2) {
+                switch (_state2.label) {
+                  case 0:
+                    c.body("");
+                    return [
+                      4,
+                      next()
+                    ];
+                  case 1:
+                    _state2.sent();
+                    return [
+                      2
+                    ];
+                }
+              });
+            });
+            return function(c, next) {
+              return _ref2.apply(this, arguments);
+            };
+          }();
+          return [
+            3,
+            8
+          ];
+        case 3:
+          if (!enableHandleWeb)
+            return [
+              3,
+              5
+            ];
+          return [
+            4,
+            getRenderHandler(options)
+          ];
+        case 4:
+          _tmp = _state.sent();
+          return [
+            3,
+            6
+          ];
+        case 5:
+          _tmp = null;
+          _state.label = 6;
+        case 6:
+          renderHandler = _tmp;
+          return [
+            4,
+            server.runner.prepareApiServer({
+              pwd: options.pwd,
+              prefix,
+              render: renderHandler,
+              httpMethodDecider
+            }, {
+              onLast: function() {
+                return null;
+              }
+            })
+          ];
+        case 7:
+          handler = _state.sent();
+          _state.label = 8;
+        case 8:
+          if (handler) {
+            server.all("*", function(c, next) {
+              if (!c.req.path.startsWith(prefix) && !enableHandleWeb) {
+                return next();
+              } else {
+                return handler(c, next);
+              }
+            });
+          }
+          return [
+            2
+          ];
+      }
+    });
+  });
+  return function bindBFFHandler2(server, options) {
+    return _ref.apply(this, arguments);
+  };
+}();
+export {
+  bindBFFHandler
+};

package/dist/esm/base/adapters/node/hono.js

@@ -0,0 +1,83 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+var httpCallBack2HonoMid = function(handler) {
+  return function() {
+    var _ref = _async_to_generator(function(context, next) {
+      var _context_env_node, req, res;
+      return _ts_generator(this, function(_state) {
+        switch (_state.label) {
+          case 0:
+            _context_env_node = context.env.node, req = _context_env_node.req, res = _context_env_node.res;
+            req.__honoRequest = context.req;
+            req.__templates = context.get("templates") || {};
+            req.__serverManifest = context.get("serverManifest") || {};
+            return [
+              4,
+              handler(req, res)
+            ];
+          case 1:
+            _state.sent();
+            if (!res.headersSent)
+              return [
+                3,
+                2
+              ];
+            context.finalized = true;
+            return [
+              3,
+              4
+            ];
+          case 2:
+            return [
+              4,
+              next()
+            ];
+          case 3:
+            _state.sent();
+            _state.label = 4;
+          case 4:
+            return [
+              2
+            ];
+        }
+      });
+    });
+    return function(context, next) {
+      return _ref.apply(this, arguments);
+    };
+  }();
+};
+var noop = function() {
+};
+var connectMid2HonoMid = function(handler) {
+  return function() {
+    var _ref = _async_to_generator(function(context, next) {
+      return _ts_generator(this, function(_state) {
+        return [
+          2,
+          new Promise(function(resolve, reject) {
+            var _context_env_node = context.env.node, req = _context_env_node.req, res = _context_env_node.res;
+            if (handler.length < 3) {
+              resolve(handler(req, res, noop));
+            } else {
+              handler(req, res, function(err) {
+                if (err) {
+                  reject(err);
+                } else {
+                  resolve(next());
+                }
+              });
+            }
+          })
+        ];
+      });
+    });
+    return function(context, next) {
+      return _ref.apply(this, arguments);
+    };
+  }();
+};
+export {
+  connectMid2HonoMid,
+  httpCallBack2HonoMid
+};

package/dist/esm/base/adapters/node/index.js

@@ -0,0 +1,20 @@
+import { loadServerEnv } from "./loadServer";
+import { httpCallBack2HonoMid, connectMid2HonoMid } from "./hono";
+import { createNodeServer, sendResponse, createWebRequest } from "./node";
+import { bindBFFHandler } from "./bff";
+import { createStaticMiddleware, registerMockHandlers, injectServerManifest, injectTemplates, getHtmlTemplates, getServerManifest } from "./middlewares";
+export {
+  bindBFFHandler,
+  connectMid2HonoMid,
+  createNodeServer,
+  createStaticMiddleware,
+  createWebRequest,
+  getHtmlTemplates,
+  getServerManifest,
+  httpCallBack2HonoMid,
+  injectServerManifest,
+  injectTemplates,
+  loadServerEnv,
+  registerMockHandlers,
+  sendResponse
+};