@modern-js/server-core 2.53.0 → 2.54.0

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

@@ -0,0 +1,111 @@
+import { MAIN_ENTRY_NAME } from "@modern-js/utils/universal/constants";
+import { initReporter } from "../monitor";
+import { sortRoutes } from "../../utils";
+import { getLoaderCtx, CustomServer, getServerMidFromUnstableMid } from "../customServer";
+import { createRender } from "./render";
+const renderPlugin = (options = {}) => ({
+  name: "@modern-js/plugin-render",
+  setup(api) {
+    const { staticGenerate, cacheConfig } = options;
+    return {
+      async prepare() {
+        var _config_render, _config_render1;
+        const { middlewares, routes, metaName, distDirectory: pwd, serverBase } = api.useAppContext();
+        const runner = api.useHookRunners();
+        const config = api.useConfigContext();
+        if (!routes) {
+          return;
+        }
+        const customServer = new CustomServer(runner, serverBase, pwd);
+        const serverMiddleware = ((_config_render = config.render) === null || _config_render === void 0 ? void 0 : _config_render.middleware) && getServerMidFromUnstableMid(config.render.middleware);
+        const pageRoutes = getPageRoutes(routes);
+        const render = await getRenderHandler({
+          pwd,
+          routes,
+          config,
+          metaName,
+          cacheConfig: ((_config_render1 = config.render) === null || _config_render1 === void 0 ? void 0 : _config_render1.cache) || cacheConfig,
+          staticGenerate
+        });
+        for (const route of pageRoutes) {
+          const { urlPath: originUrlPath, entryName } = route;
+          const urlPath = originUrlPath.endsWith("/") ? `${originUrlPath}*` : `${originUrlPath}/*`;
+          middlewares.push({
+            name: "init-reporter",
+            handler: initReporter(entryName || MAIN_ENTRY_NAME)
+          });
+          const customServerHookMiddleware = customServer.getHookMiddleware(entryName || "main", routes);
+          middlewares.push({
+            name: "custom-server-hook",
+            path: urlPath,
+            handler: customServerHookMiddleware
+          });
+          const customServerMiddleware = serverMiddleware || await customServer.getServerMiddleware();
+          customServerMiddleware && middlewares.push({
+            name: "custom-server-middleware",
+            path: urlPath,
+            handler: customServerMiddleware
+          });
+          middlewares.push({
+            name: `render`,
+            path: urlPath,
+            handler: createRenderHandler(render)
+          });
+        }
+      }
+    };
+  }
+});
+function getPageRoutes(routes) {
+  return routes.filter((route) => !route.isApi).sort(sortRoutes);
+}
+function createRenderHandler(render) {
+  return async (c, _) => {
+    var _c_env_node;
+    const logger = c.get("logger");
+    const reporter = c.get("reporter");
+    const templates = c.get("templates") || {};
+    const serverManifest = c.get("serverManifest") || {};
+    const locals = c.get("locals");
+    const metrics = c.get("metrics");
+    const loaderContext = getLoaderCtx(c);
+    const request = c.req.raw;
+    const nodeReq = (_c_env_node = c.env.node) === null || _c_env_node === void 0 ? void 0 : _c_env_node.req;
+    const res = await render(request, {
+      logger,
+      nodeReq,
+      reporter,
+      templates,
+      metrics,
+      serverManifest,
+      loaderContext,
+      locals
+    });
+    const { body, status, headers } = res;
+    const headersData = {};
+    headers.forEach((v, k) => {
+      headersData[k] = v;
+    });
+    return c.body(body, status, headersData);
+  };
+}
+async function getRenderHandler({ pwd, routes, config, cacheConfig, metaName, staticGenerate }) {
+  var _config_server, _config_security;
+  const ssrConfig = (_config_server = config.server) === null || _config_server === void 0 ? void 0 : _config_server.ssr;
+  const forceCSR = typeof ssrConfig === "object" ? ssrConfig.forceCSR : false;
+  const render = createRender({
+    routes,
+    pwd,
+    // TODO: need static Genrate
+    staticGenerate,
+    cacheConfig,
+    forceCSR,
+    nonce: (_config_security = config.security) === null || _config_security === void 0 ? void 0 : _config_security.nonce,
+    metaName: metaName || "modern-js"
+  });
+  return render;
+}
+export {
+  getRenderHandler,
+  renderPlugin
+};

package/dist/esm-node/{base/middlewares/renderHandler → plugins/render}/render.js

@@ -1,13 +1,26 @@
 import { cutNameByHyphen } from "@modern-js/utils/universal";
 import { TrieRouter } from "hono/router/trie-router";
 import { parseQuery, getPathname, createErrorHtml, sortRoutes, transformResponse, onError as onErrorFn, ErrorDigest } from "../../utils";
-import { REPLACE_REG } from "../../../base/constants";
+import { REPLACE_REG, X_MODERNJS_RENDER } from "../../constants";
 import { dataHandler } from "./dataHandler";
 import { ssrRender } from "./ssrRender";
+const DYNAMIC_ROUTE_REG = /\/:./;
 function getRouter(routes) {
-  const sorted = routes.sort(sortRoutes);
+  const dynamicRoutes = [];
+  const normalRoutes = [];
+  routes.forEach((route) => {
+    if (DYNAMIC_ROUTE_REG.test(route.urlPath)) {
+      dynamicRoutes.push(route);
+    } else {
+      normalRoutes.push(route);
+    }
+  });
+  const finalRoutes = [
+    ...normalRoutes.sort(sortRoutes),
+    ...dynamicRoutes.sort(sortRoutes)
+  ];
   const router = new TrieRouter();
-  for (const route of sorted) {
+  for (const route of finalRoutes) {
     const { urlPath: originUrlPath } = route;
     const urlPath = originUrlPath.endsWith("/") ? `${originUrlPath}*` : `${originUrlPath}/*`;
     router.add("*", urlPath, route);
@@ -20,7 +33,7 @@ function matchRoute(router, request) {
   const result = matched[0][0];
   return result || [];
 }
-async function createRender({ routes, pwd, metaName, staticGenerate, forceCSR, nonce, onFallback: onFallbackFn }) {
+async function createRender({ routes, pwd, metaName, staticGenerate, cacheConfig, forceCSR, nonce, onFallback: onFallbackFn }) {
   const router = getRouter(routes);
   return async (req, { logger, nodeReq, reporter, templates, serverManifest, locals, metrics, loaderContext }) => {
     const [routeInfo, params] = matchRoute(router, req);
@@ -62,6 +75,7 @@ async function createRender({ routes, pwd, metaName, staticGenerate, forceCSR, n
       nonce,
       logger,
       nodeReq,
+      cacheConfig,
       reporter,
       serverRoutes: routes,
       params,
@@ -137,7 +151,8 @@ function csrRender(html) {
   return new Response(html, {
     status: 200,
     headers: new Headers({
-      "content-type": "text/html; charset=UTF-8"
+      "content-type": "text/html; charset=UTF-8",
+      [X_MODERNJS_RENDER]: "client"
     })
   });
 }

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

@@ -0,0 +1,143 @@
+import { createMemoryStorage } from "@modern-js/runtime-utils/storer";
+import { createTransformStream, getPathname, getRuntimeEnv } from "../../utils";
+async function processCache(key, render, ssrContext, ttl, container, status) {
+  const renderResult = await render(ssrContext);
+  if (!renderResult) {
+    return {
+      data: ""
+    };
+  } else if (typeof renderResult === "string") {
+    const current = Date.now();
+    const cache = {
+      val: renderResult,
+      cursor: current
+    };
+    await container.set(key, JSON.stringify(cache), {
+      ttl
+    });
+    return {
+      data: renderResult,
+      status
+    };
+  } else {
+    const { Readable } = await import("stream").catch((_) => ({
+      Readable: void 0
+    }));
+    const runtimeEnv = getRuntimeEnv();
+    const streamModule = "../../adapters/node/polyfills/stream";
+    const { createReadableStreamFromReadable } = runtimeEnv === "node" ? await import(streamModule).catch((_) => ({
+      createReadableStreamFromReadable: void 0
+    })) : {
+      createReadableStreamFromReadable: void 0
+    };
+    const body = (
+      // TODO: remove node:stream, move it to ssr entry.
+      Readable && renderResult instanceof Readable ? createReadableStreamFromReadable === null || createReadableStreamFromReadable === void 0 ? void 0 : createReadableStreamFromReadable(renderResult) : renderResult
+    );
+    let html = "";
+    const stream = createTransformStream((chunk) => {
+      html += chunk;
+      return chunk;
+    });
+    const reader = body.getReader();
+    const writer = stream.writable.getWriter();
+    const push = () => {
+      reader.read().then(({ done, value }) => {
+        if (done) {
+          const current = Date.now();
+          const cache = {
+            val: html,
+            cursor: current
+          };
+          container.set(key, JSON.stringify(cache), {
+            ttl
+          });
+          writer.close();
+          return;
+        }
+        writer.write(value);
+        push();
+      });
+    };
+    push();
+    return {
+      data: stream.readable,
+      status
+    };
+  }
+}
+const CACHE_NAMESPACE = "__ssr__cache";
+const storage = createMemoryStorage(CACHE_NAMESPACE);
+function computedKey(req, cacheControl) {
+  const pathname = getPathname(req);
+  const { customKey } = cacheControl;
+  const defaultKey = pathname.replace(/.+\/+$/, "");
+  if (customKey) {
+    if (typeof customKey === "string") {
+      return customKey;
+    } else {
+      return customKey(defaultKey);
+    }
+  } else {
+    return defaultKey;
+  }
+}
+function matchCacheControl(cacheOption, req) {
+  if (!cacheOption || !req) {
+    return void 0;
+  } else if (isCacheControl(cacheOption)) {
+    return cacheOption;
+  } else if (isCacheOptionProvider(cacheOption)) {
+    return cacheOption(req);
+  } else {
+    const url = req.url;
+    const options = Object.entries(cacheOption);
+    for (const [key, option] of options) {
+      if (key === "*" || new RegExp(key).test(url)) {
+        if (typeof option === "function") {
+          return option(req);
+        } else {
+          return option;
+        }
+      }
+    }
+    return void 0;
+  }
+  function isCacheOptionProvider(option) {
+    return typeof option === "function";
+  }
+  function isCacheControl(option) {
+    return typeof option === "object" && option !== null && "maxAge" in option;
+  }
+}
+async function getCacheResult(request, options) {
+  const { cacheControl, render, ssrContext, container = storage } = options;
+  const key = computedKey(request, cacheControl);
+  const value = await container.get(key);
+  const { maxAge, staleWhileRevalidate } = cacheControl;
+  const ttl = maxAge + staleWhileRevalidate;
+  if (value) {
+    const cache = JSON.parse(value);
+    const interval = Date.now() - cache.cursor;
+    if (interval <= maxAge) {
+      return {
+        data: cache.val,
+        status: "hit"
+      };
+    } else if (interval <= staleWhileRevalidate + maxAge) {
+      processCache(key, render, ssrContext, ttl, container);
+      return {
+        data: cache.val,
+        status: "stale"
+      };
+    } else {
+      return processCache(key, render, ssrContext, ttl, container, "expired");
+    }
+  } else {
+    return processCache(key, render, ssrContext, ttl, container, "miss");
+  }
+}
+export {
+  getCacheResult,
+  matchCacheControl
+};

package/dist/esm-node/{base/middlewares/renderHandler → plugins/render}/ssrRender.js

@@ -1,8 +1,9 @@
 import { SERVER_RENDER_FUNCTION_NAME, MAIN_ENTRY_NAME } from "@modern-js/utils/universal/constants";
 import * as isbot from "isbot";
 import { getRuntimeEnv, parseHeaders, parseQuery, getHost, getPathname } from "../../utils";
-import { X_RENDER_CACHE } from "../../constants";
+import { X_MODERNJS_RENDER, X_RENDER_CACHE } from "../../constants";
 import { ServerTiming } from "./serverTiming";
+import { matchCacheControl, getCacheResult } from "./ssrCache";
 const defaultReporter = {
   init() {
   },
@@ -15,7 +16,7 @@ const defaultReporter = {
   reportWarn() {
   }
 };
-async function ssrRender(request, { routeInfo, html, staticGenerate, nonce, metaName, reporter, logger, nodeReq, serverManifest, locals, params, metrics, loaderContext }) {
+async function ssrRender(request, { routeInfo, html, staticGenerate, nonce, metaName, reporter, logger, nodeReq, serverManifest, locals, params, metrics, loaderContext, cacheConfig }) {
   var _serverManifest_renderBundles;
   const { entryName } = routeInfo;
   const loadableStats = serverManifest.loadableStats || {};
@@ -77,18 +78,16 @@ async function ssrRender(request, { routeInfo, html, staticGenerate, nonce, meta
   let ssrResult;
   let cacheStatus;
   const render = renderBundle[SERVER_RENDER_FUNCTION_NAME];
-  if (runtimeEnv === "node") {
-    const cacheModuleName = "./ssrCache";
-    const { ssrCache } = await import(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);
-    }
+  const cacheControl = await matchCacheControl(cacheConfig === null || cacheConfig === void 0 ? void 0 : cacheConfig.strategy, nodeReq || new IncomingMessgeProxy(request));
+  if (cacheControl) {
+    const { data: data2, status } = await getCacheResult(request, {
+      cacheControl,
+      container: cacheConfig === null || cacheConfig === void 0 ? void 0 : cacheConfig.container,
+      render,
+      ssrContext
+    });
+    ssrResult = data2;
+    cacheStatus = status;
   } else {
     ssrResult = await render(ssrContext);
   }
@@ -96,6 +95,7 @@ async function ssrRender(request, { routeInfo, html, staticGenerate, nonce, meta
   if (cacheStatus) {
     responseProxy.headers.set(X_RENDER_CACHE, cacheStatus);
   }
+  responseProxy.headers.set(X_MODERNJS_RENDER, "server");
   if (redirection.url) {
     const { headers: headers2 } = responseProxy;
     headers2.set("Location", redirection.url);

package/dist/esm-node/serverBase.js

@@ -0,0 +1,153 @@
+import { _ as _class_private_method_get } from "@swc/helpers/_/_class_private_method_get";
+import { _ as _class_private_method_init } from "@swc/helpers/_/_class_private_method_init";
+import { Hono } from "hono";
+import { createContext } from "@modern-js/plugin";
+import { PluginManager } from "./pluginManager";
+var _getAppContext = /* @__PURE__ */ new WeakSet(), _applyMiddlewares = /* @__PURE__ */ new WeakSet();
+class ServerBase {
+  /**
+  * 初始化顺序
+  * - 初始化 pluginManager;
+  * - 执行 runner.prepare;
+  * - 应用 middlewares
+  */
+  async init() {
+    const runner = await this.pluginManager.init();
+    this.runner = runner;
+    await runner.prepare();
+    _class_private_method_get(this, _applyMiddlewares, applyMiddlewares).call(this);
+    return this;
+  }
+  addPlugins(plugins) {
+    this.pluginManager.addPlugins(plugins);
+  }
+  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) {
+    _class_private_method_init(this, _getAppContext);
+    _class_private_method_init(this, _applyMiddlewares);
+    this.options = options;
+    const { config, serverConfig } = options;
+    const appContext = _class_private_method_get(this, _getAppContext, getAppContext).call(this);
+    this.appContext = appContext;
+    this.pluginManager = new PluginManager({
+      cliConfig: config,
+      appContext,
+      serverConfig
+    });
+    this.app = new Hono();
+  }
+}
+function getAppContext() {
+  const { appContext: context, pwd, routes, metaName } = this.options;
+  const appContext = {
+    routes,
+    middlewares: [],
+    appDirectory: (context === null || context === void 0 ? void 0 : context.appDirectory) || "",
+    apiDirectory: context === null || context === void 0 ? void 0 : context.apiDirectory,
+    lambdaDirectory: context === null || context === void 0 ? void 0 : context.lambdaDirectory,
+    sharedDirectory: (context === null || context === void 0 ? void 0 : context.sharedDirectory) || "",
+    distDirectory: pwd,
+    plugins: [],
+    metaName: metaName || "modern-js",
+    serverBase: this
+  };
+  return createContext(appContext);
+}
+function applyMiddlewares() {
+  const { middlewares } = this.appContext.get();
+  const preMiddlewares = [];
+  const defaultMiddlewares = [];
+  const postMiddlewares = [];
+  for (const middleware of middlewares) {
+    switch (middleware.order) {
+      case "pre":
+        preMiddlewares.push(middleware);
+        break;
+      case "post":
+        postMiddlewares.push(middleware);
+        break;
+      default:
+        defaultMiddlewares.push(middleware);
+    }
+  }
+  const finalMiddlewares = [];
+  const insertMiddleware = (middleware) => {
+    if (middleware.before) {
+      const targetIndex = finalMiddlewares.findIndex((item) => {
+        var _middleware_before;
+        if ((_middleware_before = middleware.before) === null || _middleware_before === void 0 ? void 0 : _middleware_before.includes(item.name)) {
+          return true;
+        } else {
+          return false;
+        }
+      });
+      if (targetIndex !== -1) {
+        finalMiddlewares.splice(targetIndex, 0, middleware);
+      } else {
+        finalMiddlewares.push(middleware);
+      }
+    } else {
+      finalMiddlewares.push(middleware);
+    }
+  };
+  preMiddlewares.forEach(insertMiddleware);
+  defaultMiddlewares.forEach(insertMiddleware);
+  postMiddlewares.forEach(insertMiddleware);
+  for (const middleware of finalMiddlewares) {
+    const { path = "*", method = "all", handler } = middleware;
+    const handlers = handler2Handlers(handler);
+    this.app[method](path, ...handlers);
+  }
+  function handler2Handlers(handler) {
+    if (Array.isArray(handler)) {
+      return handler;
+    } else {
+      return [
+        handler
+      ];
+    }
+  }
+}
+function createServerBase(options) {
+  if (options == null) {
+    throw new Error("can not start server without options");
+  }
+  const server = new ServerBase(options);
+  return server;
+}
+export {
+  ServerBase,
+  createServerBase
+};

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

@@ -0,0 +1,4 @@
+export * from "./config";
+export * from "./plugin";
+export * from "./render";
+export * from "./server";

package/dist/esm-node/{base/utils → utils}/index.js

@@ -5,3 +5,4 @@ export * from "./error";
 export * from "./warmup";
 export * from "./entry";
 export * from "./request";
+export * from "./serverConfig";

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

@@ -0,0 +1,11 @@
+import { deepmerge } from "deepmerge-ts";
+const loadConfig = ({ cliConfig, serverConfig }) => {
+  const config = deepmerge({
+    ...cliConfig,
+    plugins: []
+  }, serverConfig);
+  return config;
+};
+export {
+  loadConfig
+};

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

@@ -0,0 +1,4 @@
+export { loadServerEnv } from './loadEnv';
+export { loadServerPlugins } from './loadPlugin';
+export { loadServerConfig } from './loadConfig';
+export { loadCacheConfig } from './loadCache';

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

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

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

@@ -0,0 +1,2 @@
+import { ServerConfig } from '../../../types';
+export declare function loadServerConfig(pwd: string, oldServerFile?: string, newServerConfigPath?: string): ServerConfig | undefined;

package/dist/types/{base/adapters/node/loadServer.d.ts → adapters/node/helper/loadEnv.d.ts}

@@ -1,3 +1,3 @@
-import type { ServerBaseOptions } from '../../serverBase';
+import type { ServerBaseOptions } from '../../../serverBase';
 /** 读取 .env.{process.env.MODERN_ENV} 文件，加载环境变量 */
 export declare function loadServerEnv(options: ServerBaseOptions): Promise<void>;

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

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

package/dist/types/{base/adapters → adapters}/node/hono.d.ts

@@ -1,5 +1,4 @@
-import { NodeRequest, NodeResponse } from '../../../core/plugin';
-import { Context, HonoRequest, ServerEnv, Middleware, Next, ServerManifest } from '../../../core/server';
+import { NodeRequest, NodeResponse, Context, HonoRequest, ServerEnv, Middleware, Next, ServerManifest } from '../../types';
 type NodeBindings = {
     node: {
         req: NodeRequest & {

package/dist/types/{base/adapters → adapters}/node/index.d.ts

@@ -1,6 +1,5 @@
-export { loadServerEnv } from './loadServer';
 export { httpCallBack2HonoMid, connectMid2HonoMid } from './hono';
 export type { ServerNodeContext, ServerNodeMiddleware } from './hono';
 export { createNodeServer, sendResponse, createWebRequest, writeReadableStreamToWritable, } from './node';
-export { bindBFFHandler } from './bff';
-export { createStaticMiddleware, registerMockHandlers, injectServerManifest, injectTemplates, getHtmlTemplates, getServerManifest, } from './middlewares';
+export { serverStaticPlugin, injectResourcePlugin, getHtmlTemplates, getServerManifest, injectNodeSeverPlugin, } from './plugins';
+export { loadServerPlugins, loadServerEnv, loadServerConfig, loadCacheConfig, } from './helper';

package/dist/types/{base/adapters → adapters}/node/node.d.ts

@@ -2,8 +2,7 @@
 /// <reference types="node" />
 import { Server as NodeServer } from 'node:http';
 import type { Server as NodeHttpsServer } from 'node:https';
-import { NodeRequest, NodeResponse } from '../../../core/plugin';
-import { RequestHandler } from '../../../core/server';
+import { NodeRequest, NodeResponse, RequestHandler } from '../../types';
 export { writeReadableStreamToWritable } from './polyfills';
 export declare const createWebRequest: (req: NodeRequest, res: NodeResponse, body?: BodyInit) => Request;
 export declare const sendResponse: (response: Response, res: NodeResponse) => Promise<void>;

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

@@ -0,0 +1,3 @@
+export * from './static';
+export * from './resource';
+export * from './nodeServer';

package/dist/types/adapters/node/plugins/nodeServer.d.ts

@@ -0,0 +1,4 @@
+import { ServerPlugin, NodeServer } from '../../../types';
+export declare const injectNodeSeverPlugin: ({ nodeServer, }: {
+    nodeServer: NodeServer;
+}) => ServerPlugin;

package/dist/types/adapters/node/plugins/resource.d.ts

@@ -0,0 +1,7 @@
+import type { Logger, ServerRoute } from '@modern-js/types';
+import { Middleware, ServerEnv, ServerManifest, ServerPlugin } from '../../../types';
+export declare function getHtmlTemplates(pwd: string, routes: ServerRoute[]): Promise<Record<string, string>>;
+export declare function injectTemplates(pwd: string, routes?: ServerRoute[]): Middleware<ServerEnv>;
+export declare function getServerManifest(pwd: string, routes: ServerRoute[], logger: Logger): Promise<ServerManifest>;
+export declare function injectServerManifest(pwd: string, routes?: ServerRoute[]): Middleware<ServerEnv>;
+export declare const injectResourcePlugin: () => ServerPlugin;

package/dist/types/adapters/node/plugins/static.d.ts

@@ -0,0 +1,15 @@
+import { ServerRoute } from '@modern-js/types';
+import type { OutputNormalizedConfig, HtmlNormalizedConfig, Middleware, ServerPlugin } from '../../../types';
+export declare const serverStaticPlugin: () => ServerPlugin;
+export type PublicMiddlwareOptions = {
+    pwd: string;
+    routes: ServerRoute[];
+};
+export declare function createPublicMiddleware({ pwd, routes, }: PublicMiddlwareOptions): Middleware;
+export interface ServerStaticOptions {
+    pwd: string;
+    output: OutputNormalizedConfig;
+    html: HtmlNormalizedConfig;
+    routes?: ServerRoute[];
+}
+export declare function createStaticMiddleware(options: ServerStaticOptions): Middleware;

package/dist/types/{base/constants.d.ts → constants.d.ts}

@@ -22,3 +22,4 @@ export declare enum ServerReportTimings {
     SERVER_HOOK_AFTER_MATCH = "server-hook-after-match"
 }
 export declare const X_RENDER_CACHE = "x-render-cache";
+export declare const X_MODERNJS_RENDER = "x-modernjs-render";

package/dist/types/index.d.ts

@@ -1,5 +1,11 @@
-export * from './core/plugin';
-export * from './core/render';
+export { createErrorHtml, onError, ErrorDigest } from './utils';
+export { AGGRED_DIR } from './constants';
+export type { ServerBase, ServerBaseOptions } from './serverBase';
+export { createServerBase } from './serverBase';
+export { PluginManager, type PluginManagerOptions } from './pluginManager';
+export type { Middleware, Context, Next, HonoRequest as InternalRequest, ServerEnv, ServerManifest, } from './types';
+export * from './plugins';
+export * from './types/plugin';
+export * from './types/render';
 export * from '@modern-js/plugin';
-export * from './core/loadPlugins';
 export * from './types/config';