@modern-js/server-core 2.67.2 → 2.67.4

package/dist/esm/plugins/index.js

@@ -5,12 +5,14 @@ import { processedByPlugin } from "./processedBy";
 import { logPlugin } from "./log";
 import { createDefaultPlugins } from "./default";
 import { compatPlugin, handleSetupResult } from "./compat";
+import { injectConfigMiddlewarePlugin } from "./middlewares";
 export {
   compatPlugin,
   createDefaultPlugins,
   faviconPlugin,
   getRenderHandler,
   handleSetupResult,
+  injectConfigMiddlewarePlugin,
   injectRenderHandlerPlugin,
   injectServerTiming,
   injectloggerPlugin,

package/dist/esm/plugins/middlewares.js

@@ -0,0 +1,22 @@
+var injectConfigMiddlewarePlugin = function() {
+  var configMiddlewares = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : [], configRenderMiddlewares = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : [];
+  return {
+    name: "@modern-js/plugin-inject-config-middleware",
+    setup: function setup(api) {
+      return {
+        prepare: function prepare() {
+          var _api_useAppContext = api.useAppContext(), middlewares = _api_useAppContext.middlewares, renderMiddlewares = _api_useAppContext.renderMiddlewares;
+          configMiddlewares.forEach(function(m) {
+            middlewares.push(m);
+          });
+          configRenderMiddlewares.forEach(function(m) {
+            renderMiddlewares.push(m);
+          });
+        }
+      };
+    }
+  };
+};
+export {
+  injectConfigMiddlewarePlugin
+};

package/dist/esm/plugins/render/index.js

@@ -1,9 +1,10 @@
 import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
 import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { _ as _ts_values } from "@swc/helpers/_/_ts_values";
 import { MAIN_ENTRY_NAME } from "@modern-js/utils/universal/constants";
 import { getLoaderCtx } from "../../helper";
 import { sortRoutes } from "../../utils";
-import { CustomServer, getServerMidFromUnstableMid } from "../customServer";
+import { CustomServer } from "../customServer";
 import { requestLatencyMiddleware } from "../monitors";
 export * from "./inject";
 var renderPlugin = function() {
@@ -13,11 +14,11 @@ var renderPlugin = function() {
       return {
         prepare: function prepare() {
           return _async_to_generator(function() {
-            var _config_render, _api_useAppContext, middlewares, routes, render, pwd, serverBase, hooks, config, customServer, serverMiddleware, pageRoutes, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, route, _config_server, originUrlPath, _route_entryName, entryName, urlPath, customServerHookMiddleware, customServerMiddleware, err;
+            var _api_useAppContext, middlewares, routes, render, pwd, renderMiddlewares, hooks, config, customServer, pageRoutes, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _loop, _iterator, _step, err;
             return _ts_generator(this, function(_state) {
               switch (_state.label) {
                 case 0:
-                  _api_useAppContext = api.useAppContext(), middlewares = _api_useAppContext.middlewares, routes = _api_useAppContext.routes, render = _api_useAppContext.render, pwd = _api_useAppContext.distDirectory, serverBase = _api_useAppContext.serverBase;
+                  _api_useAppContext = api.useAppContext(), middlewares = _api_useAppContext.middlewares, routes = _api_useAppContext.routes, render = _api_useAppContext.render, pwd = _api_useAppContext.distDirectory, renderMiddlewares = _api_useAppContext.renderMiddlewares;
                   hooks = api.getHooks();
                   config = api.useConfigContext();
                   if (!routes) {
@@ -25,8 +26,7 @@ var renderPlugin = function() {
                       2
                     ];
                   }
-                  customServer = new CustomServer(hooks, serverBase, pwd);
-                  serverMiddleware = ((_config_render = config.render) === null || _config_render === void 0 ? void 0 : _config_render.middleware) && getServerMidFromUnstableMid(config.render.middleware);
+                  customServer = new CustomServer(hooks, pwd);
                   pageRoutes = getPageRoutes(routes);
                   middlewares.push({
                     name: "page-latency",
@@ -41,6 +41,51 @@ var renderPlugin = function() {
                     7,
                     8
                   ]);
+                  _loop = function() {
+                    var route, _config_server, originUrlPath, _route_entryName, entryName, urlPath, customServerHookMiddleware, customServerMiddleware;
+                    return _ts_generator(this, function(_state2) {
+                      switch (_state2.label) {
+                        case 0:
+                          route = _step.value;
+                          originUrlPath = route.urlPath, _route_entryName = route.entryName, entryName = _route_entryName === void 0 ? MAIN_ENTRY_NAME : _route_entryName;
+                          urlPath = originUrlPath.endsWith("/") ? "".concat(originUrlPath, "*") : "".concat(originUrlPath, "/*");
+                          if (((_config_server = config.server) === null || _config_server === void 0 ? void 0 : _config_server.disableHook) !== true) {
+                            customServerHookMiddleware = customServer.getHookMiddleware(entryName, routes);
+                            middlewares.push({
+                              name: "custom-server-hook",
+                              path: urlPath,
+                              handler: customServerHookMiddleware
+                            });
+                          }
+                          renderMiddlewares === null || renderMiddlewares === void 0 ? void 0 : renderMiddlewares.forEach(function(m) {
+                            middlewares.push({
+                              name: m.name,
+                              path: urlPath,
+                              handler: m.handler
+                            });
+                          });
+                          return [
+                            4,
+                            customServer.getServerMiddleware()
+                          ];
+                        case 1:
+                          customServerMiddleware = _state2.sent();
+                          customServerMiddleware && middlewares.push({
+                            name: "custom-server-middleware",
+                            path: urlPath,
+                            handler: customServerMiddleware
+                          });
+                          render && middlewares.push({
+                            name: "render",
+                            path: urlPath,
+                            handler: createRenderHandler(render)
+                          });
+                          return [
+                            2
+                          ];
+                      }
+                    });
+                  };
                   _iterator = pageRoutes[Symbol.iterator]();
                   _state.label = 2;
                 case 2:
@@ -49,33 +94,12 @@ var renderPlugin = function() {
                       3,
                       5
                     ];
-                  route = _step.value;
-                  originUrlPath = route.urlPath, _route_entryName = route.entryName, entryName = _route_entryName === void 0 ? MAIN_ENTRY_NAME : _route_entryName;
-                  urlPath = originUrlPath.endsWith("/") ? "".concat(originUrlPath, "*") : "".concat(originUrlPath, "/*");
-                  if (((_config_server = config.server) === null || _config_server === void 0 ? void 0 : _config_server.disableHook) !== true) {
-                    customServerHookMiddleware = customServer.getHookMiddleware(entryName, routes);
-                    middlewares.push({
-                      name: "custom-server-hook",
-                      path: urlPath,
-                      handler: customServerHookMiddleware
-                    });
-                  }
                   return [
-                    4,
-                    customServer.getServerMiddleware(serverMiddleware)
+                    5,
+                    _ts_values(_loop())
                   ];
                 case 3:
-                  customServerMiddleware = _state.sent();
-                  customServerMiddleware && middlewares.push({
-                    name: "custom-server-middleware",
-                    path: urlPath,
-                    handler: customServerMiddleware
-                  });
-                  render && middlewares.push({
-                    name: "render",
-                    path: urlPath,
-                    handler: createRenderHandler(render)
-                  });
+                  _state.sent();
                   _state.label = 4;
                 case 4:
                   _iteratorNormalCompletion = true;

package/dist/esm/plugins/render/inject.js

@@ -12,7 +12,7 @@ var injectRenderHandlerPlugin = function(param) {
       return {
         prepare: function prepare() {
           return _async_to_generator(function() {
-            var _config_render, _api_useAppContext, pwd, routes, metaName, config, hookRunner, onFallback, getRenderHandlerOptions, render;
+            var _api_useAppContext, pwd, routes, metaName, config, hookRunner, onFallback, getRenderHandlerOptions, render;
             return _ts_generator(this, function(_state) {
               switch (_state.label) {
                 case 0:
@@ -54,7 +54,8 @@ var injectRenderHandlerPlugin = function(param) {
                     routes,
                     config,
                     metaName,
-                    cacheConfig: ((_config_render = config.render) === null || _config_render === void 0 ? void 0 : _config_render.cache) || cacheConfig,
+                    // TODO: support modern.server.ts cache config
+                    cacheConfig,
                     staticGenerate,
                     onFallback
                   };

package/dist/esm/serverBase.js

@@ -7,6 +7,7 @@ import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
 import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
 import { server } from "@modern-js/plugin-v2/server";
 import { Hono } from "hono";
+import { run } from "./context";
 import { handleSetupResult } from "./plugins/compat/hooks";
 import { loadConfig } from "./utils";
 var _applyMiddlewares = /* @__PURE__ */ new WeakSet();
@@ -19,6 +20,7 @@ var ServerBase = /* @__PURE__ */ function() {
     this.serverContext = null;
     this.options = options;
     this.app = new Hono();
+    this.app.use("*", run);
   }
   var _proto = ServerBase2.prototype;
   _proto.init = function init() {
@@ -33,7 +35,6 @@ var ServerBase = /* @__PURE__ */ function() {
               cliConfig,
               serverConfig: serverConfig || {}
             });
-            _this.addPlugins(mergedConfig.plugins || []);
             return [
               4,
               server.run({

package/dist/esm/utils/storage.js

@@ -0,0 +1,38 @@
+import * as ah from "async_hooks";
+var createStorage = function() {
+  var storage;
+  if (typeof ah.AsyncLocalStorage !== "undefined") {
+    storage = new ah.AsyncLocalStorage();
+  }
+  var run = function(context, cb) {
+    if (!storage) {
+      throw new Error("Unable to use async_hook, please confirm the node version >= 12.17\n        ");
+    }
+    return new Promise(function(resolve, reject) {
+      storage.run(context, function() {
+        try {
+          return resolve(cb());
+        } catch (error) {
+          return reject(error);
+        }
+      });
+    });
+  };
+  var useHonoContext = function() {
+    if (!storage) {
+      throw new Error("Unable to use async_hook, please confirm the node version >= 12.17\n        ");
+    }
+    var context = storage.getStore();
+    if (!context) {
+      throw new Error("Can't call useContext out of server scope");
+    }
+    return context;
+  };
+  return {
+    run,
+    useHonoContext
+  };
+};
+export {
+  createStorage
+};

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

@@ -1,5 +1,5 @@
 import path from "path";
-import { fs, DEFAULT_SERVER_CONFIG, OUTPUT_CONFIG_FILE, lodash as _, compatibleRequire, ensureAbsolutePath, requireExistModule } from "@modern-js/utils";
+import { fs, DEFAULT_SERVER_CONFIG, OUTPUT_CONFIG_FILE, lodash as _, chalk, compatibleRequire, ensureAbsolutePath, getMeta, requireExistModule } from "@modern-js/utils";
 import { parse } from "flatted";
 const requireConfig = async (serverConfigPath) => {
   if (fs.pathExistsSync(serverConfigPath)) {
@@ -19,12 +19,16 @@ async function loadServerConfigOld(pwd, configFile) {
   const serverConfig = await requireConfig(serverConfigPath);
   return serverConfig;
 }
-async function loadServerRuntimeConfig(pwd, oldServerFile = DEFAULT_SERVER_CONFIG, newServerConfigPath) {
+async function loadServerRuntimeConfig(pwd, oldServerFile = DEFAULT_SERVER_CONFIG, newServerConfigPath, metaName) {
   const newServerConfig = newServerConfigPath && await loadServerConfigNew(newServerConfigPath);
   if (newServerConfig) {
     return newServerConfig;
   }
   const oldServerConfig = await loadServerConfigOld(pwd, oldServerFile);
+  if (oldServerConfig) {
+    const meta = getMeta(metaName);
+    console.warn(`${chalk.red("\n[Warning]")} ${chalk.yellow.bold(`\`${oldServerFile}\``)} is no longer maintained. To extend the server, please migrate to ${chalk.yellow.bold(`\`server/${meta}.server.ts\``)};`);
+  }
   return oldServerConfig;
 }
 function loadServerCliConfig(pwd, defaultConfig = {}) {

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

@@ -1,4 +1,5 @@
 import { ServerResponse } from "node:http";
+import cloneable from "cloneable-readable";
 import { isResFinalized } from "./helper";
 import { installGlobals } from "./polyfills/install";
 import { createReadableStreamFromReadable, writeReadableStreamToWritable } from "./polyfills/stream";
@@ -6,14 +7,26 @@ import { writeReadableStreamToWritable as writeReadableStreamToWritable2 } from
 installGlobals();
 const createWebRequest = (req, res, body) => {
   const headerRecord = [];
-  const len = req.rawHeaders.length;
-  for (let i = 0; i < len; i += 2) {
-    const key = req.rawHeaders[i];
-    if (!key.startsWith(":")) {
-      headerRecord.push([
-        key,
-        req.rawHeaders[i + 1]
-      ]);
+  for (const [key, value] of Object.entries(req.headers)) {
+    if (key.startsWith(":")) {
+      continue;
+    }
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        if (item !== void 0) {
+          headerRecord.push([
+            key,
+            item
+          ]);
+        }
+      }
+    } else if (value !== void 0) {
+      if (typeof value === "string") {
+        headerRecord.push([
+          key,
+          value
+        ]);
+      }
     }
   }
   const { method } = req;
@@ -25,13 +38,36 @@ const createWebRequest = (req, res, body) => {
   };
   res.on("close", () => controller.abort("res closed"));
   const url = `http://${req.headers.host}${req.url}`;
-  const fullUrl = new URL(url);
-  if (body || !(method === "GET" || method === "HEAD") && fullUrl.searchParams.has("__loader") || fullUrl.searchParams.has("__pass_body") || req.headers["x-mf-micro"] || req.headers["x-rsc-action"] || req.headers["x-parse-through-body"]) {
-    init.body = body !== null && body !== void 0 ? body : createReadableStreamFromReadable(req);
+  const needsRequestBody = body || !(method === "GET" || method === "HEAD");
+  const cloneableReq = needsRequestBody ? cloneable(req) : null;
+  if (needsRequestBody) {
+    if (body) {
+      init.body = body;
+    } else {
+      const stream = cloneableReq.clone();
+      init.body = createReadableStreamFromReadable(stream);
+    }
     init.duplex = "half";
   }
-  const request = new Request(url, init);
-  return request;
+  const originalRequest = new Request(url, init);
+  if (needsRequestBody) {
+    return new Proxy(originalRequest, {
+      get(target, prop) {
+        if ([
+          "json",
+          "text",
+          "blob",
+          "arrayBuffer",
+          "formData",
+          "body"
+        ].includes(prop)) {
+          cloneableReq.resume();
+        }
+        return target[prop];
+      }
+    });
+  }
+  return originalRequest;
 };
 const sendResponse = async (response, res) => {
   var _response_headers_get;

package/dist/esm-node/context.js

@@ -0,0 +1,6 @@
+import { createStorage } from "./utils/storage";
+const { run, useHonoContext } = createStorage();
+export {
+  run,
+  useHonoContext
+};

package/dist/esm-node/index.js

@@ -1,6 +1,8 @@
 import { createErrorHtml, onError, ErrorDigest } from "./utils";
 import { AGGRED_DIR } from "./constants";
 import { createServerBase } from "./serverBase";
+import { useHonoContext } from "./context";
+import { Hono } from "hono";
 import { getLoaderCtx } from "./helper";
 export * from "./plugins";
 export * from "./types/plugins";
@@ -11,8 +13,10 @@ export * from "./types/requestHandler";
 export {
   AGGRED_DIR,
   ErrorDigest,
+  Hono,
   createErrorHtml,
   createServerBase,
   getLoaderCtx,
-  onError
+  onError,
+  useHonoContext
 };

package/dist/esm-node/plugins/customServer/index.js

@@ -68,19 +68,14 @@ class CustomServer {
       }
     };
   }
-  async getServerMiddleware(renderMiddlewares) {
+  async getServerMiddleware() {
     const serverMiddleware = await this.serverMiddlewarePromise;
     if (!serverMiddleware || !isFunction(serverMiddleware) && !isArray(serverMiddleware)) {
-      return renderMiddlewares;
+      return;
     }
     if (Array.isArray(serverMiddleware)) {
       const unstableMiddlewares = getServerMidFromUnstableMid(serverMiddleware);
-      return [
-        ...renderMiddlewares || [],
-        ...unstableMiddlewares
-      ];
-    } else if (renderMiddlewares) {
-      return renderMiddlewares;
+      return unstableMiddlewares;
     }
     return async (c, next) => {
       var _c_env_node_res, _c_env_node, _c_env;
@@ -106,9 +101,8 @@ class CustomServer {
       }
     };
   }
-  constructor(hooks, serverBase, pwd) {
+  constructor(hooks, pwd) {
     this.hooks = hooks;
-    this.serverBase = serverBase;
     const webExtension = [];
     this.serverMiddlewarePromise = hooks.prepareWebServer.call({
       pwd,

package/dist/esm-node/plugins/index.js

@@ -5,12 +5,14 @@ import { processedByPlugin } from "./processedBy";
 import { logPlugin } from "./log";
 import { createDefaultPlugins } from "./default";
 import { compatPlugin, handleSetupResult } from "./compat";
+import { injectConfigMiddlewarePlugin } from "./middlewares";
 export {
   compatPlugin,
   createDefaultPlugins,
   faviconPlugin,
   getRenderHandler,
   handleSetupResult,
+  injectConfigMiddlewarePlugin,
   injectRenderHandlerPlugin,
   injectServerTiming,
   injectloggerPlugin,

package/dist/esm-node/plugins/middlewares.js

@@ -0,0 +1,19 @@
+const injectConfigMiddlewarePlugin = (configMiddlewares = [], configRenderMiddlewares = []) => ({
+  name: "@modern-js/plugin-inject-config-middleware",
+  setup(api) {
+    return {
+      prepare() {
+        const { middlewares, renderMiddlewares } = api.useAppContext();
+        configMiddlewares.forEach((m) => {
+          middlewares.push(m);
+        });
+        configRenderMiddlewares.forEach((m) => {
+          renderMiddlewares.push(m);
+        });
+      }
+    };
+  }
+});
+export {
+  injectConfigMiddlewarePlugin
+};

package/dist/esm-node/plugins/render/index.js

@@ -1,7 +1,7 @@
 import { MAIN_ENTRY_NAME } from "@modern-js/utils/universal/constants";
 import { getLoaderCtx } from "../../helper";
 import { sortRoutes } from "../../utils";
-import { CustomServer, getServerMidFromUnstableMid } from "../customServer";
+import { CustomServer } from "../customServer";
 import { requestLatencyMiddleware } from "../monitors";
 export * from "./inject";
 const renderPlugin = () => ({
@@ -9,15 +9,13 @@ const renderPlugin = () => ({
   setup(api) {
     return {
       async prepare() {
-        var _config_render;
-        const { middlewares, routes, render, distDirectory: pwd, serverBase } = api.useAppContext();
+        const { middlewares, routes, render, distDirectory: pwd, renderMiddlewares } = api.useAppContext();
         const hooks = api.getHooks();
         const config = api.useConfigContext();
         if (!routes) {
           return;
         }
-        const customServer = new CustomServer(hooks, serverBase, pwd);
-        const serverMiddleware = ((_config_render = config.render) === null || _config_render === void 0 ? void 0 : _config_render.middleware) && getServerMidFromUnstableMid(config.render.middleware);
+        const customServer = new CustomServer(hooks, pwd);
         const pageRoutes = getPageRoutes(routes);
         middlewares.push({
           name: "page-latency",
@@ -35,7 +33,14 @@ const renderPlugin = () => ({
               handler: customServerHookMiddleware
             });
           }
-          const customServerMiddleware = await customServer.getServerMiddleware(serverMiddleware);
+          renderMiddlewares === null || renderMiddlewares === void 0 ? void 0 : renderMiddlewares.forEach((m) => {
+            middlewares.push({
+              name: m.name,
+              path: urlPath,
+              handler: m.handler
+            });
+          });
+          const customServerMiddleware = await customServer.getServerMiddleware();
           customServerMiddleware && middlewares.push({
             name: "custom-server-middleware",
             path: urlPath,

package/dist/esm-node/plugins/render/inject.js

@@ -4,7 +4,6 @@ const injectRenderHandlerPlugin = ({ staticGenerate, cacheConfig }) => ({
   setup(api) {
     return {
       async prepare() {
-        var _config_render;
         const { distDirectory: pwd, routes, metaName } = api.useAppContext();
         const config = api.useConfigContext();
         const hookRunner = api.useHookRunners();
@@ -23,7 +22,8 @@ const injectRenderHandlerPlugin = ({ staticGenerate, cacheConfig }) => ({
           routes,
           config,
           metaName,
-          cacheConfig: ((_config_render = config.render) === null || _config_render === void 0 ? void 0 : _config_render.cache) || cacheConfig,
+          // TODO: support modern.server.ts cache config
+          cacheConfig,
           staticGenerate,
           onFallback
         };

package/dist/esm-node/serverBase.js

@@ -2,6 +2,7 @@ import { _ as _class_private_method_get } from "@swc/helpers/_/_class_private_me
 import { _ as _class_private_method_init } from "@swc/helpers/_/_class_private_method_init";
 import { server } from "@modern-js/plugin-v2/server";
 import { Hono } from "hono";
+import { run } from "./context";
 import { handleSetupResult } from "./plugins/compat/hooks";
 import { loadConfig } from "./utils";
 var _applyMiddlewares = /* @__PURE__ */ new WeakSet();
@@ -17,7 +18,6 @@ class ServerBase {
       cliConfig,
       serverConfig: serverConfig || {}
     });
-    this.addPlugins(mergedConfig.plugins || []);
     const { serverContext } = await server.run({
       plugins: this.plugins,
       options: this.options,
@@ -75,6 +75,7 @@ class ServerBase {
     this.serverContext = null;
     this.options = options;
     this.app = new Hono();
+    this.app.use("*", run);
   }
 }
 function applyMiddlewares() {

package/dist/esm-node/utils/storage.js

@@ -0,0 +1,40 @@
+import * as ah from "async_hooks";
+const createStorage = () => {
+  let storage;
+  if (typeof ah.AsyncLocalStorage !== "undefined") {
+    storage = new ah.AsyncLocalStorage();
+  }
+  const run = (context, cb) => {
+    if (!storage) {
+      throw new Error(`Unable to use async_hook, please confirm the node version >= 12.17
+        `);
+    }
+    return new Promise((resolve, reject) => {
+      storage.run(context, () => {
+        try {
+          return resolve(cb());
+        } catch (error) {
+          return reject(error);
+        }
+      });
+    });
+  };
+  const useHonoContext = () => {
+    if (!storage) {
+      throw new Error(`Unable to use async_hook, please confirm the node version >= 12.17
+        `);
+    }
+    const context = storage.getStore();
+    if (!context) {
+      throw new Error(`Can't call useContext out of server scope`);
+    }
+    return context;
+  };
+  return {
+    run,
+    useHonoContext
+  };
+};
+export {
+  createStorage
+};

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

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

package/dist/types/context.d.ts

@@ -0,0 +1,3 @@
+import type { Context } from 'hono';
+declare const run: <O>(context: Context<any, any, {}>, cb: () => O | Promise<O>) => Promise<O>, useHonoContext: () => Context<any, any, {}>;
+export { run, useHonoContext };

package/dist/types/index.d.ts

@@ -2,7 +2,9 @@ export { createErrorHtml, onError, ErrorDigest } from './utils';
 export { AGGRED_DIR } from './constants';
 export type { ServerBase, ServerBaseOptions } from './serverBase';
 export { createServerBase } from './serverBase';
-export type { Middleware, Context, Next, HonoRequest as InternalRequest, ServerEnv, ServerManifest, ServerLoaderBundle, } from './types';
+export { useHonoContext } from './context';
+export { Hono } from 'hono';
+export type { Middleware, MiddlewareHandler, Context, Next, HonoRequest as InternalRequest, ServerEnv, ServerManifest, ServerLoaderBundle, } from './types';
 export { getLoaderCtx } from './helper';
 export * from './plugins';
 export * from './types/plugins';

package/dist/types/plugins/customServer/index.d.ts

@@ -1,13 +1,11 @@
 import type { ServerRoute, UnstableMiddleware } from '@modern-js/types';
 import type { ServerNodeEnv } from '../../adapters/node/hono';
-import type { ServerBase } from '../../serverBase';
 import type { Middleware, ServerEnv, ServerPluginHooks } from '../../types';
 export declare class CustomServer {
     private hooks;
     private serverMiddlewarePromise;
-    private serverBase;
-    constructor(hooks: ServerPluginHooks, serverBase: ServerBase, pwd: string);
+    constructor(hooks: ServerPluginHooks, pwd: string);
     getHookMiddleware(entryName: string, routes: ServerRoute[]): Middleware<ServerEnv>;
-    getServerMiddleware(renderMiddlewares?: Middleware<ServerNodeEnv & ServerEnv>[]): Promise<Middleware<ServerNodeEnv & ServerEnv> | Array<Middleware<ServerNodeEnv & ServerEnv>> | undefined>;
+    getServerMiddleware(): Promise<Middleware<ServerNodeEnv & ServerEnv> | Array<Middleware<ServerNodeEnv & ServerEnv>> | undefined>;
 }
 export declare function getServerMidFromUnstableMid(serverMiddleware: UnstableMiddleware[]): Array<Middleware<ServerNodeEnv & ServerEnv>>;

package/dist/types/plugins/index.d.ts

@@ -5,3 +5,4 @@ export { processedByPlugin } from './processedBy';
 export { logPlugin } from './log';
 export { createDefaultPlugins, type CreateDefaultPluginsOptions, } from './default';
 export { compatPlugin, handleSetupResult } from './compat';
+export { injectConfigMiddlewarePlugin } from './middlewares';

package/dist/types/plugins/middlewares.d.ts

@@ -0,0 +1,2 @@
+import type { MiddlewareObj, ServerPluginLegacy } from '../types';
+export declare const injectConfigMiddlewarePlugin: (configMiddlewares?: MiddlewareObj[], configRenderMiddlewares?: MiddlewareObj[]) => ServerPluginLegacy;