@modern-js/server-core 2.48.3 → 2.48.5-alpha.0

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

@@ -0,0 +1,69 @@
+"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 bff_exports = {};
+__export(bff_exports, {
+  bindBFFHandler: () => bindBFFHandler
+});
+module.exports = __toCommonJS(bff_exports);
+var import_utils = require("@modern-js/utils");
+var import_middlewares = require("../../../base/middlewares");
+var import_utils2 = require("../../utils");
+const bindBFFHandler = async (server, options) => {
+  const prefix = options.config.bff.prefix || "/api";
+  const { enableHandleWeb } = options.config.bff;
+  const { httpMethodDecider } = options.config.bff;
+  const runtimeEnv = (0, import_utils2.getRuntimeEnv)();
+  if (runtimeEnv !== "node") {
+    return;
+  }
+  const { getMiddlewares, ...collector } = (0, import_utils2.createMiddlewareCollecter)();
+  const { runner } = server;
+  await runner.gather(collector);
+  const webOnly = await (0, import_utils.isWebOnly)();
+  let handler;
+  if (webOnly) {
+    handler = async (c, next) => {
+      c.body("");
+      await next();
+    };
+  } else {
+    const renderHandler = enableHandleWeb ? await (0, import_middlewares.getRenderHandler)(options) : null;
+    handler = await server.runner.prepareApiServer({
+      pwd: options.pwd,
+      prefix,
+      render: renderHandler,
+      httpMethodDecider
+    }, {
+      onLast: () => null
+    });
+  }
+  if (handler) {
+    server.all(`*`, (c, next) => {
+      if (!c.req.path.startsWith(prefix) && !enableHandleWeb) {
+        return next();
+      } else {
+        return handler(c, next);
+      }
+    });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  bindBFFHandler
+});

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

@@ -0,0 +1,63 @@
+"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 hono_exports = {};
+__export(hono_exports, {
+  connectMid2HonoMid: () => connectMid2HonoMid,
+  httpCallBack2HonoMid: () => httpCallBack2HonoMid
+});
+module.exports = __toCommonJS(hono_exports);
+const httpCallBack2HonoMid = (handler) => {
+  return async (context, next) => {
+    const { req, res } = context.env.node;
+    req.__honoRequest = context.req;
+    req.__templates = context.get("templates") || {};
+    req.__serverManifest = context.get("serverManifest") || {};
+    await handler(req, res);
+    if (res.headersSent) {
+      context.finalized = true;
+    } else {
+      await next();
+    }
+  };
+};
+const noop = () => {
+};
+const connectMid2HonoMid = (handler) => {
+  return async (context, next) => {
+    return new Promise((resolve, reject) => {
+      const { req, res } = context.env.node;
+      if (handler.length < 3) {
+        resolve(handler(req, res, noop));
+      } else {
+        handler(req, res, (err) => {
+          if (err) {
+            reject(err);
+          } else {
+            resolve(next());
+          }
+        });
+      }
+    });
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  connectMid2HonoMid,
+  httpCallBack2HonoMid
+});

package/dist/cjs/base/adapters/node/index.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 node_exports = {};
+__export(node_exports, {
+  bindBFFHandler: () => import_bff.bindBFFHandler,
+  connectMid2HonoMid: () => import_hono.connectMid2HonoMid,
+  createNodeServer: () => import_node.createNodeServer,
+  createStaticMiddleware: () => import_middlewares.createStaticMiddleware,
+  createWebRequest: () => import_node.createWebRequest,
+  getHtmlTemplates: () => import_middlewares.getHtmlTemplates,
+  httpCallBack2HonoMid: () => import_hono.httpCallBack2HonoMid,
+  injectServerManifest: () => import_middlewares.injectServerManifest,
+  injectTemplates: () => import_middlewares.injectTemplates,
+  loadServerEnv: () => import_loadServer.loadServerEnv,
+  registerMockHandlers: () => import_middlewares.registerMockHandlers,
+  sendResponse: () => import_node.sendResponse
+});
+module.exports = __toCommonJS(node_exports);
+var import_loadServer = require("./loadServer");
+var import_hono = require("./hono");
+var import_node = require("./node");
+var import_bff = require("./bff");
+var import_middlewares = require("./middlewares");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  bindBFFHandler,
+  connectMid2HonoMid,
+  createNodeServer,
+  createStaticMiddleware,
+  createWebRequest,
+  getHtmlTemplates,
+  httpCallBack2HonoMid,
+  injectServerManifest,
+  injectTemplates,
+  loadServerEnv,
+  registerMockHandlers,
+  sendResponse
+});

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

@@ -0,0 +1,56 @@
+"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 loadServer_exports = {};
+__export(loadServer_exports, {
+  loadServerEnv: () => loadServerEnv
+});
+module.exports = __toCommonJS(loadServer_exports);
+var import_path = __toESM(require("path"));
+var import_utils = require("@modern-js/utils");
+async function loadServerEnv(options) {
+  const { pwd } = options;
+  const serverEnv = process.env.MODERN_ENV;
+  const defaultEnvPath = import_path.default.resolve(pwd, `.env`);
+  const serverEnvPath = import_path.default.resolve(pwd, `.env.${serverEnv}`);
+  for (const envPath of [
+    serverEnvPath,
+    defaultEnvPath
+  ]) {
+    if (await import_utils.fs.pathExists(envPath) && !(await import_utils.fs.stat(envPath)).isDirectory()) {
+      const envConfig = import_utils.dotenv.config({
+        path: envPath
+      });
+      (0, import_utils.dotenvExpand)(envConfig);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  loadServerEnv
+});

package/dist/cjs/base/adapters/node/middlewares/index.js

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

package/dist/cjs/base/adapters/node/middlewares/mock.js

@@ -0,0 +1,113 @@
+"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 mock_exports = {};
+__export(mock_exports, {
+  registerMockHandlers: () => registerMockHandlers
+});
+module.exports = __toCommonJS(mock_exports);
+var import_node_path = __toESM(require("node:path"));
+var import_utils = require("@modern-js/utils");
+var import_constants = require("../../../constants");
+var import_hono = require("../hono");
+const parseKey = (key) => {
+  const _blank = " ";
+  const splitted = key.split(_blank).filter(Boolean);
+  if (splitted.length > 1) {
+    const [method, pathname] = splitted;
+    return {
+      method: method.toLowerCase(),
+      path: pathname
+    };
+  }
+  return {
+    method: "get",
+    path: key
+  };
+};
+const mockHandlerRegistry = /* @__PURE__ */ new Map();
+const registerMockHandlers = async ({ pwd, server }) => {
+  const exts = [
+    ".ts",
+    ".js"
+  ];
+  let mockFilePath = "";
+  for (const ext of exts) {
+    const maybeMatch = import_node_path.default.join(pwd, `${import_constants.AGGRED_DIR.mock}/index${ext}`);
+    if (await import_utils.fs.pathExists(maybeMatch)) {
+      mockFilePath = maybeMatch;
+      break;
+    }
+  }
+  if (!mockFilePath) {
+    return null;
+  }
+  const { default: mockModule, config } = await Promise.resolve().then(() => __toESM(require(mockFilePath)));
+  const enable = config === null || config === void 0 ? void 0 : config.enable;
+  if (enable === false) {
+    return;
+  }
+  if (!mockModule) {
+    throw new Error(`Mock file ${mockFilePath} parsed failed!`);
+  }
+  Object.entries(mockModule).forEach(([key, handler]) => {
+    const { method, path: path2 } = parseKey(key);
+    const methodName = method.toLowerCase();
+    const handlerId = `${methodName}-${path2}`;
+    mockHandlerRegistry.set(handlerId, {
+      handler,
+      isRegistered: false
+    });
+    if (typeof server[methodName] === "function") {
+      const mockHandler = async (c, next) => {
+        var _mockHandlerRegistry_get;
+        if (typeof enable === "function") {
+          const isEnabled = enable(c.env.node.req, c.env.node.res);
+          if (!isEnabled) {
+            return next();
+          }
+        }
+        const handler2 = (_mockHandlerRegistry_get = mockHandlerRegistry.get(handlerId)) === null || _mockHandlerRegistry_get === void 0 ? void 0 : _mockHandlerRegistry_get.handler;
+        if (typeof handler2 === "function") {
+          await (0, import_hono.connectMid2HonoMid)(handler2)(c, next);
+        } else {
+          return c.json(handler2);
+        }
+      };
+      const handlerInfo = mockHandlerRegistry.get(handlerId);
+      if (handlerInfo && !(handlerInfo === null || handlerInfo === void 0 ? void 0 : handlerInfo.isRegistered)) {
+        server[methodName](path2, mockHandler);
+        handlerInfo.isRegistered = true;
+      }
+    }
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  registerMockHandlers
+});

package/dist/cjs/base/adapters/node/middlewares/serverManifest.js

@@ -0,0 +1,82 @@
+"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 serverManifest_exports = {};
+__export(serverManifest_exports, {
+  injectServerManifest: () => injectServerManifest
+});
+module.exports = __toCommonJS(serverManifest_exports);
+var import_path = __toESM(require("path"));
+var import_utils = require("@modern-js/utils");
+async function getServerManifest(pwd, routes) {
+  const loaderBundles = {};
+  const renderBundles = {};
+  await Promise.all([
+    routes.map(async (route) => {
+      const entryName = route.entryName || import_utils.MAIN_ENTRY_NAME;
+      const loaderBundlePath = import_path.default.join(pwd, import_utils.SERVER_BUNDLE_DIRECTORY, `${entryName}-server-loaders.js`);
+      const renderBundlePath = import_path.default.join(pwd, route.bundle || "");
+      await Promise.allSettled([
+        Promise.resolve().then(() => __toESM(require(loaderBundlePath))),
+        Promise.resolve().then(() => __toESM(require(renderBundlePath)))
+      ]).then((results) => {
+        const { status: loaderStatus } = results[0];
+        if (loaderStatus === "fulfilled") {
+          loaderBundles[entryName] = results[0].value;
+        }
+        const { status: renderStatus } = results[1];
+        if (renderStatus === "fulfilled") {
+          renderBundles[entryName] = results[1].value;
+        }
+      });
+    })
+  ]);
+  const loadableUri = import_path.default.join(pwd, import_utils.LOADABLE_STATS_FILE);
+  const loadableStats = await Promise.resolve().then(() => __toESM(require(loadableUri))).catch((_) => ({}));
+  const routesManifestUri = import_path.default.join(pwd, import_utils.ROUTE_MANIFEST_FILE);
+  const routeManifest = await Promise.resolve().then(() => __toESM(require(routesManifestUri))).catch((_) => ({}));
+  return {
+    loaderBundles,
+    renderBundles,
+    loadableStats,
+    routeManifest
+  };
+}
+function injectServerManifest(pwd, routes) {
+  return async (c, next) => {
+    if (routes && !c.get("serverManifest")) {
+      const serverManifest = await getServerManifest(pwd, routes);
+      c.set("serverManifest", serverManifest);
+    }
+    await next();
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  injectServerManifest
+});

package/dist/cjs/base/adapters/node/middlewares/serverPublic.js

@@ -0,0 +1,67 @@
+"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 serverPublic_exports = {};
+__export(serverPublic_exports, {
+  createPublicMiddleware: () => createPublicMiddleware
+});
+module.exports = __toCommonJS(serverPublic_exports);
+var import_path = __toESM(require("path"));
+var import_fileReader = require("@modern-js/runtime-utils/fileReader");
+var import_mime = require("hono/utils/mime");
+var import_utils = require("../../../utils");
+function createPublicMiddleware({ pwd, routes }) {
+  return async (c, next) => {
+    const route = matchRoute(c.req, routes);
+    if (route) {
+      const { entryPath } = route;
+      const filename = import_path.default.join(pwd, entryPath);
+      const data = await import_fileReader.fileReader.readFile(filename, "buffer");
+      const mimeType = (0, import_mime.getMimeType)(filename);
+      if (data !== null) {
+        if (mimeType) {
+          c.header("Content-Type", mimeType);
+        }
+        return c.body(data, 200);
+      }
+    }
+    return await next();
+  };
+}
+function matchRoute(req, routes) {
+  for (const route of routes.sort(import_utils.sortRoutes)) {
+    if (!route.isSSR && !route.isApi && route.entryPath.startsWith("public") && req.path.startsWith(route.urlPath)) {
+      return route;
+    }
+  }
+  return void 0;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createPublicMiddleware
+});

package/dist/cjs/base/adapters/node/middlewares/serverStatic.js

@@ -0,0 +1,109 @@
+"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 serverStatic_exports = {};
+__export(serverStatic_exports, {
+  createStaticMiddleware: () => createStaticMiddleware
+});
+module.exports = __toCommonJS(serverStatic_exports);
+var import_path = __toESM(require("path"));
+var import_utils = require("@modern-js/utils");
+var import_mime = require("hono/utils/mime");
+var import_fileReader = require("@modern-js/runtime-utils/fileReader");
+var import_utils2 = require("../../../utils");
+var import_serverPublic = require("./serverPublic");
+function createStaticMiddleware(options) {
+  const { pwd, routes } = options;
+  const prefix = options.output.assetPrefix || "/";
+  const { distPath: { css: cssPath, js: jsPath, media: mediaPath } = {} } = options.output;
+  const { favicon, faviconByEntries } = options.html;
+  const favicons = prepareFavicons(favicon, faviconByEntries);
+  const staticFiles = [
+    cssPath,
+    jsPath,
+    mediaPath
+  ].filter((v) => Boolean(v));
+  const staticReg = [
+    "static/",
+    "upload/",
+    ...staticFiles
+  ];
+  const iconReg = [
+    "favicon.ico",
+    "icon.png",
+    ...favicons
+  ];
+  const regPrefix = prefix.endsWith("/") ? prefix : `${prefix}/`;
+  const staticPathRegExp = new RegExp(`^${regPrefix}(${[
+    ...staticReg,
+    ...iconReg
+  ].join("|")})`);
+  return async (c, next) => {
+    const pathname = c.req.path;
+    const hit = staticPathRegExp.test(pathname);
+    if (hit) {
+      const filepath = import_path.default.join(pwd, pathname.replace(prefix, () => ""));
+      if (!await import_utils.fs.pathExists(filepath)) {
+        return c.html((0, import_utils2.createErrorHtml)(404), 404);
+      }
+      const mimeType = (0, import_mime.getMimeType)(filepath);
+      if (mimeType) {
+        c.header("Content-Type", mimeType);
+      }
+      const stat = await import_utils.fs.lstat(filepath);
+      const { size } = stat;
+      const chunk = await import_fileReader.fileReader.readFile(filepath, "buffer");
+      c.header("Content-Length", String(size));
+      return c.body(chunk, 200);
+    } else {
+      return (0, import_serverPublic.createPublicMiddleware)({
+        pwd,
+        routes: routes || []
+      })(c, next);
+    }
+  };
+}
+const prepareFavicons = (favicon, faviconByEntries) => {
+  const faviconNames = [];
+  if (favicon && typeof favicon === "string") {
+    faviconNames.push(favicon.substring(favicon.lastIndexOf("/") + 1));
+  }
+  if (faviconByEntries) {
+    Object.keys(faviconByEntries).forEach((f) => {
+      const curFavicon = faviconByEntries[f];
+      if (curFavicon) {
+        faviconNames.push(curFavicon.substring(curFavicon.lastIndexOf("/") + 1));
+      }
+    });
+  }
+  return faviconNames;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createStaticMiddleware
+});