@modern-js/server-core 2.53.0 → 2.54.0

package/dist/cjs/plugins/render/ssrCache.js

@@ -0,0 +1,178 @@
+"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 ssrCache_exports = {};
+__export(ssrCache_exports, {
+  getCacheResult: () => getCacheResult,
+  matchCacheControl: () => matchCacheControl
+});
+module.exports = __toCommonJS(ssrCache_exports);
+var import_storer = require("@modern-js/runtime-utils/storer");
+var import_utils = require("../../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 Promise.resolve().then(() => __toESM(require("stream"))).catch((_) => ({
+      Readable: void 0
+    }));
+    const runtimeEnv = (0, import_utils.getRuntimeEnv)();
+    const streamModule = "../../adapters/node/polyfills/stream";
+    const { createReadableStreamFromReadable } = runtimeEnv === "node" ? await Promise.resolve().then(() => __toESM(require(streamModule))).catch((_) => ({
+      createReadableStreamFromReadable: void 0
+    })) : {
+      createReadableStreamFromReadable: void 0
+    };
+    const 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 = (0, import_utils.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 = (0, import_storer.createMemoryStorage)(CACHE_NAMESPACE);
+function computedKey(req, cacheControl) {
+  const pathname = (0, import_utils.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");
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getCacheResult,
+  matchCacheControl
+});

package/dist/cjs/{base/middlewares/renderHandler → plugins/render}/ssrRender.js

@@ -37,6 +37,7 @@ var isbot = __toESM(require("isbot"));
 var import_utils = require("../../utils");
 var import_constants2 = require("../../constants");
 var import_serverTiming = require("./serverTiming");
+var import_ssrCache = require("./ssrCache");
 const defaultReporter = {
   init() {
   },
@@ -49,7 +50,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 || {};
@@ -111,18 +112,16 @@ async function ssrRender(request, { routeInfo, html, staticGenerate, nonce, meta
   let ssrResult;
   let cacheStatus;
   const render = renderBundle[import_constants.SERVER_RENDER_FUNCTION_NAME];
-  if (runtimeEnv === "node") {
-    const cacheModuleName = "./ssrCache";
-    const { ssrCache } = await Promise.resolve().then(() => __toESM(require(cacheModuleName)));
-    const incomingMessage = nodeReq ? nodeReq : new IncomingMessgeProxy(request);
-    const cacheControl = await ssrCache.matchCacheControl(incomingMessage);
-    if (cacheControl) {
-      const { data: data2, status } = await ssrCache.getCache(request, cacheControl, render, ssrContext);
-      ssrResult = data2;
-      cacheStatus = status;
-    } else {
-      ssrResult = await render(ssrContext);
-    }
+  const cacheControl = await (0, import_ssrCache.matchCacheControl)(cacheConfig === null || cacheConfig === void 0 ? void 0 : cacheConfig.strategy, nodeReq || new IncomingMessgeProxy(request));
+  if (cacheControl) {
+    const { data: data2, status } = await (0, import_ssrCache.getCacheResult)(request, {
+      cacheControl,
+      container: cacheConfig === null || cacheConfig === void 0 ? void 0 : cacheConfig.container,
+      render,
+      ssrContext
+    });
+    ssrResult = data2;
+    cacheStatus = status;
   } else {
     ssrResult = await render(ssrContext);
   }
@@ -130,6 +129,7 @@ async function ssrRender(request, { routeInfo, html, staticGenerate, nonce, meta
   if (cacheStatus) {
     responseProxy.headers.set(import_constants2.X_RENDER_CACHE, cacheStatus);
   }
+  responseProxy.headers.set(import_constants2.X_MODERNJS_RENDER, "server");
   if (redirection.url) {
     const { headers: headers2 } = responseProxy;
     headers2.set("Location", redirection.url);

package/dist/cjs/serverBase.js

@@ -0,0 +1,178 @@
+"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 serverBase_exports = {};
+__export(serverBase_exports, {
+  ServerBase: () => ServerBase,
+  createServerBase: () => createServerBase
+});
+module.exports = __toCommonJS(serverBase_exports);
+var import_class_private_method_get = require("@swc/helpers/_/_class_private_method_get");
+var import_class_private_method_init = require("@swc/helpers/_/_class_private_method_init");
+var import_hono = require("hono");
+var import_plugin = require("@modern-js/plugin");
+var import_pluginManager = require("./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();
+    (0, import_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) {
+    (0, import_class_private_method_init._)(this, _getAppContext);
+    (0, import_class_private_method_init._)(this, _applyMiddlewares);
+    this.options = options;
+    const { config, serverConfig } = options;
+    const appContext = (0, import_class_private_method_get._)(this, _getAppContext, getAppContext).call(this);
+    this.appContext = appContext;
+    this.pluginManager = new import_pluginManager.PluginManager({
+      cliConfig: config,
+      appContext,
+      serverConfig
+    });
+    this.app = new import_hono.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 (0, import_plugin.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;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ServerBase,
+  createServerBase
+});

package/dist/cjs/{base/adapters/node/middlewares → types}/index.js

@@ -13,16 +13,16 @@ var __copyProps = (to, from, except, desc) => {
 };
 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);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);
+__reExport(types_exports, require("./config"), module.exports);
+__reExport(types_exports, require("./plugin"), module.exports);
+__reExport(types_exports, require("./render"), module.exports);
+__reExport(types_exports, require("./server"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  ...require("./mock"),
-  ...require("./serverStatic"),
-  ...require("./templates"),
-  ...require("./serverManifest")
+  ...require("./config"),
+  ...require("./plugin"),
+  ...require("./render"),
+  ...require("./server")
 });

package/dist/cjs/types/plugin.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 plugin_exports = {};
+module.exports = __toCommonJS(plugin_exports);

package/dist/cjs/{base/utils → utils}/index.js

@@ -22,6 +22,7 @@ __reExport(utils_exports, require("./error"), module.exports);
 __reExport(utils_exports, require("./warmup"), module.exports);
 __reExport(utils_exports, require("./entry"), module.exports);
 __reExport(utils_exports, require("./request"), module.exports);
+__reExport(utils_exports, require("./serverConfig"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ...require("./env"),
@@ -30,5 +31,6 @@ __reExport(utils_exports, require("./request"), module.exports);
   ...require("./error"),
   ...require("./warmup"),
   ...require("./entry"),
-  ...require("./request")
+  ...require("./request"),
+  ...require("./serverConfig")
 });

package/dist/cjs/{base/middlewares/faviconFallback.js → utils/serverConfig.js}

@@ -16,19 +16,20 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var faviconFallback_exports = {};
-__export(faviconFallback_exports, {
-  favionFallbackMiddleware: () => favionFallbackMiddleware
+var serverConfig_exports = {};
+__export(serverConfig_exports, {
+  loadConfig: () => loadConfig
 });
-module.exports = __toCommonJS(faviconFallback_exports);
-const favionFallbackMiddleware = async (c, next) => {
-  if (c.req.path === "/favicon.ico") {
-    return c.body(null, 204);
-  } else {
-    return next();
-  }
+module.exports = __toCommonJS(serverConfig_exports);
+var import_deepmerge_ts = require("deepmerge-ts");
+const loadConfig = ({ cliConfig, serverConfig }) => {
+  const config = (0, import_deepmerge_ts.deepmerge)({
+    ...cliConfig,
+    plugins: []
+  }, serverConfig);
+  return config;
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  favionFallbackMiddleware
+  loadConfig
 });

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

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

package/dist/esm/adapters/node/helper/loadCache.js

@@ -0,0 +1,19 @@
+import path from "path";
+import { SERVER_DIR, requireExistModule } from "@modern-js/utils";
+var CACHE_FILENAME = "cache";
+function loadCacheConfig(pwd) {
+  var serverCacheFilepath = path.resolve(pwd, SERVER_DIR, CACHE_FILENAME);
+  var mod = requireExistModule(serverCacheFilepath, {
+    interop: false
+  });
+  if (mod === null || mod === void 0 ? void 0 : mod.cacheOption) {
+    return {
+      strategy: mod.cacheOption,
+      container: mod.customContainer
+    };
+  }
+  return void 0;
+}
+export {
+  loadCacheConfig
+};

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

@@ -0,0 +1,32 @@
+import path from "path";
+import { compatRequire, fs, DEFAULT_SERVER_CONFIG, requireExistModule } from "@modern-js/utils";
+var requireConfig = function(serverConfigPath) {
+  if (fs.pathExistsSync(serverConfigPath)) {
+    return compatRequire(serverConfigPath);
+  }
+  return void 0;
+};
+function loadServerConfigNew(serverConfigPath) {
+  var mod = requireExistModule(serverConfigPath);
+  if (mod) {
+    return mod;
+  }
+  return void 0;
+}
+function loadServerConfigOld(pwd, configFile) {
+  var serverConfigPath = path.join(pwd, "".concat(configFile, ".js"));
+  var serverConfig = requireConfig(serverConfigPath);
+  return serverConfig;
+}
+function loadServerConfig(pwd) {
+  var oldServerFile = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : DEFAULT_SERVER_CONFIG, newServerConfigPath = arguments.length > 2 ? arguments[2] : void 0;
+  var newServerConfig = newServerConfigPath && loadServerConfigNew(newServerConfigPath);
+  if (newServerConfig) {
+    return newServerConfig;
+  }
+  var oldServerConfig = loadServerConfigOld(pwd, oldServerFile);
+  return oldServerConfig;
+}
+export {
+  loadServerConfig
+};

package/dist/esm/adapters/node/helper/loadPlugin.js

@@ -0,0 +1,17 @@
+import { compatRequire, tryResolve } from "@modern-js/utils";
+function resolveServerPlugin(plugin, appDirectory) {
+  var name = plugin.name, options = plugin.options;
+  var pluginPath = tryResolve(name, appDirectory);
+  var module = compatRequire(pluginPath);
+  var pluginInstance = module(options);
+  return pluginInstance;
+}
+function loadServerPlugins(serverPlugins, appDirectory) {
+  var instances = serverPlugins.map(function(plugin) {
+    return resolveServerPlugin(plugin, appDirectory);
+  });
+  return instances;
+}
+export {
+  loadServerPlugins
+};

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

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

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

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

package/dist/esm/adapters/node/plugins/nodeServer.js

@@ -0,0 +1,18 @@
+import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
+import { _ as _object_spread_props } from "@swc/helpers/_/_object_spread_props";
+var injectNodeSeverPlugin = function(param) {
+  var nodeServer = param.nodeServer;
+  return {
+    name: "@modern-js/plugin-inject-node-server",
+    setup: function setup(api) {
+      var appContext = api.useAppContext();
+      api.setAppContext(_object_spread_props(_object_spread({}, appContext), {
+        nodeServer
+      }));
+      return {};
+    }
+  };
+};
+export {
+  injectNodeSeverPlugin
+};