@modern-js/server-core 2.69.5 → 3.0.0-alpha.0

package/dist/esm-node/constants.js

@@ -1,35 +0,0 @@
-const AGGRED_DIR = {
-  mock: "config/mock",
-  server: "server",
-  api: "api",
-  shared: "shared",
-  lambda: "lambda"
-};
-const REPLACE_REG = {
-  before: {
-    head: "<head\\b[^>]*>",
-    body: "<body\\b[^>]*>"
-  },
-  after: {
-    head: "</head>",
-    body: "</body>"
-  }
-};
-var ServerTimings;
-(function(ServerTimings2) {
-  ServerTimings2["SERVER_HANDLE_REQUEST"] = "server-handle-request";
-  ServerTimings2["SERVER_MIDDLEWARE"] = "server-middleware";
-  ServerTimings2["SERVER_HOOK_AFTER_RENDER"] = "server-hook-after-render";
-  ServerTimings2["SERVER_HOOK_AFTER_MATCH"] = "server-hook-after-match";
-})(ServerTimings || (ServerTimings = {}));
-const SERVER_TIMING = "Server-Timing";
-const X_RENDER_CACHE = "x-render-cache";
-const X_MODERNJS_RENDER = "x-modernjs-render";
-export {
-  AGGRED_DIR,
-  REPLACE_REG,
-  SERVER_TIMING,
-  ServerTimings,
-  X_MODERNJS_RENDER,
-  X_RENDER_CACHE
-};

package/dist/esm-node/helper.js

@@ -1,14 +0,0 @@
-const LOADER_CONTEXT = "loaderContext";
-function getLoaderCtx(c) {
-  const loaderContext = c.get(LOADER_CONTEXT);
-  if (loaderContext) {
-    return loaderContext;
-  } else {
-    const loaderContext2 = /* @__PURE__ */ new Map();
-    c.set(LOADER_CONTEXT, loaderContext2);
-    return loaderContext2;
-  }
-}
-export {
-  getLoaderCtx
-};

package/dist/esm-node/index.js

@@ -1,22 +0,0 @@
-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";
-export * from "./types/render";
-export * from "@modern-js/plugin";
-export * from "./types/config";
-export * from "./types/requestHandler";
-export {
-  AGGRED_DIR,
-  ErrorDigest,
-  Hono,
-  createErrorHtml,
-  createServerBase,
-  getLoaderCtx,
-  onError,
-  useHonoContext
-};

package/dist/esm-node/plugins/compat/hooks.js

@@ -1,66 +0,0 @@
-function getHookRunners(context) {
-  const { hooks } = context;
-  return {
-    config: (params) => {
-      return hooks.modifyConfig.call(params);
-    },
-    prepare: () => {
-      return hooks.onPrepare.call();
-    },
-    reset: (params) => {
-      return hooks.onReset.call(params);
-    },
-    fallback: (input) => {
-      return hooks.fallback.call(input);
-    },
-    prepareWebServer: (input) => {
-      return hooks.prepareWebServer.call(input);
-    },
-    prepareApiServer: (input) => {
-      return hooks.prepareApiServer.call(input);
-    },
-    afterMatch: (ctx) => {
-      return hooks.afterMatch.call(ctx);
-    },
-    afterRender: (ctx) => {
-      return hooks.afterRender.call(ctx);
-    },
-    afterStreamingRender: (ctx) => {
-      return hooks.afterStreamingRender.call(ctx);
-    }
-  };
-}
-function transformHookRunner(hookRunnerName) {
-  switch (hookRunnerName) {
-    case "config":
-      return "modifyConfig";
-    case "prepare":
-      return "onPrepare";
-    case "reset":
-      return "onReset";
-    default:
-      return hookRunnerName;
-  }
-}
-function handleSetupResult(setupResult, api) {
-  if (!setupResult) {
-    return;
-  }
-  Object.keys(setupResult).forEach((key) => {
-    const fn = setupResult[key];
-    if (typeof fn === "function") {
-      const newAPI = transformHookRunner(key);
-      if (api[newAPI]) {
-        api[newAPI]((...params) => {
-          const res = fn(...params);
-          return res;
-        });
-      }
-    }
-  });
-}
-export {
-  getHookRunners,
-  handleSetupResult,
-  transformHookRunner
-};

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

@@ -1,40 +0,0 @@
-import { createAsyncHook, createAsyncPipelineHook } from "@modern-js/plugin-v2";
-import { getHookRunners } from "./hooks";
-import { handleSetupResult } from "./hooks";
-const compatPlugin = () => ({
-  name: "@modern-js/server-compat",
-  registryHooks: {
-    fallback: createAsyncHook(),
-    prepareWebServer: createAsyncPipelineHook(),
-    prepareApiServer: createAsyncPipelineHook(),
-    afterMatch: createAsyncPipelineHook(),
-    afterRender: createAsyncPipelineHook(),
-    afterStreamingRender: createAsyncPipelineHook()
-  },
-  _registryApi: (getServerContext, updateServerContext) => {
-    const getInternalContext = () => {
-      return getServerContext()._internalContext;
-    };
-    return {
-      useConfigContext: () => {
-        return getInternalContext().config;
-      },
-      useAppContext: () => {
-        const { _internalContext, ...serverContext } = getServerContext();
-        return serverContext;
-      },
-      setAppContext: (context) => {
-        return updateServerContext(context);
-      },
-      useHookRunners: () => {
-        return getHookRunners(getInternalContext());
-      }
-    };
-  },
-  setup: () => {
-  }
-});
-export {
-  compatPlugin,
-  handleSetupResult
-};

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

@@ -1,162 +0,0 @@
-import { _ as _class_private_field_get } from "@swc/helpers/_/_class_private_field_get";
-import { _ as _class_private_field_init } from "@swc/helpers/_/_class_private_field_init";
-import { _ as _class_private_field_set } from "@swc/helpers/_/_class_private_field_set";
-import { getCookie } from "hono/cookie";
-import { getHost } from "../../utils";
-function createBaseHookContext(c, resParams) {
-  const logger = c.get("logger");
-  const metrics = c.get("metrics");
-  return {
-    request: new BaseHookRequest(c),
-    response: new BaseHookResponse(c, resParams),
-    logger,
-    metrics
-  };
-}
-var _req = /* @__PURE__ */ new WeakMap(), _c = /* @__PURE__ */ new WeakMap(), _headersData = /* @__PURE__ */ new WeakMap(), _headers = /* @__PURE__ */ new WeakMap();
-class BaseHookRequest {
-  get url() {
-    const query = _class_private_field_get(this, _c).req.query();
-    const q = Object.entries(query).map(([key, value]) => `${key}=${value}`).join("&");
-    return q ? `${_class_private_field_get(this, _c).req.path}?${q}` : _class_private_field_get(this, _c).req.path;
-  }
-  // TODO: remove next major version
-  set url(_u) {
-  }
-  get host() {
-    return getHost(_class_private_field_get(this, _req).raw);
-  }
-  // TODO: remove next major version
-  set host(_h) {
-  }
-  get pathname() {
-    return _class_private_field_get(this, _req).path;
-  }
-  // TODO: remove next major version
-  set pathname(_p) {
-  }
-  get query() {
-    return _class_private_field_get(this, _req).query();
-  }
-  // TODO: remove next major version
-  set query(_q) {
-  }
-  get headers() {
-    return _class_private_field_get(this, _headers);
-  }
-  // TODO: remove next major version
-  set headers(_h) {
-  }
-  get cookies() {
-    return {
-      // FIXME: ModernRequest Type Error
-      get: (key) => {
-        return getCookie(_class_private_field_get(this, _c), key);
-      }
-    };
-  }
-  get cookie() {
-    return _class_private_field_get(this, _req).header("cookie");
-  }
-  // TODO: remove next major version
-  set cookie(_c2) {
-  }
-  constructor(c) {
-    _class_private_field_init(this, _req, {
-      writable: true,
-      value: void 0
-    });
-    _class_private_field_init(this, _c, {
-      writable: true,
-      value: void 0
-    });
-    _class_private_field_init(this, _headersData, {
-      writable: true,
-      value: void 0
-    });
-    _class_private_field_init(this, _headers, {
-      writable: true,
-      value: void 0
-    });
-    _class_private_field_set(this, _headersData, {});
-    _class_private_field_set(this, _c, c);
-    _class_private_field_set(this, _req, c.req);
-    const rawHeaders = _class_private_field_get(this, _req).raw.headers;
-    rawHeaders.forEach((value, key) => {
-      _class_private_field_get(this, _headersData)[key] = value;
-    });
-    _class_private_field_set(this, _headers, new Proxy(_class_private_field_get(this, _headersData), {
-      get(target, p) {
-        return target[p];
-      },
-      set(target, p, newValue) {
-        target[p] = newValue;
-        rawHeaders.set(p, newValue);
-        return true;
-      }
-    }));
-  }
-}
-var _c1 = /* @__PURE__ */ new WeakMap(), _resArgs = /* @__PURE__ */ new WeakMap();
-class BaseHookResponse {
-  get(key) {
-    return _class_private_field_get(this, _c1).res.headers.get(key);
-  }
-  set(key, value) {
-    if ([
-      "set-cookie",
-      "Set-Cookie"
-    ].includes(key)) {
-      var _class_private_field_get1;
-      _class_private_field_get(this, _c1).header(key, value.toString(), {
-        append: true
-      });
-      (_class_private_field_get1 = _class_private_field_get(this, _resArgs)) === null || _class_private_field_get1 === void 0 ? void 0 : _class_private_field_get1.headers.append(key, value.toString());
-    } else {
-      var _class_private_field_get2;
-      _class_private_field_get(this, _c1).header(key, value.toString());
-      (_class_private_field_get2 = _class_private_field_get(this, _resArgs)) === null || _class_private_field_get2 === void 0 ? void 0 : _class_private_field_get2.headers.set(key, value.toString());
-    }
-  }
-  status(code) {
-    _class_private_field_get(this, _c1).status(code);
-    _class_private_field_get(this, _resArgs) && (_class_private_field_get(this, _resArgs).status = code);
-  }
-  getStatus() {
-    return _class_private_field_get(this, _c1).res.status;
-  }
-  get cookies() {
-    const setCookie = (key, value) => {
-      _class_private_field_get(this, _c1).header("set-cookie", `${key}=${value}`, {
-        append: true
-      });
-    };
-    const clearCookie = () => {
-      _class_private_field_get(this, _c1).header("set-cookie", void 0);
-    };
-    return {
-      set: setCookie,
-      clear: clearCookie
-    };
-  }
-  raw(body, options) {
-    _class_private_field_get(this, _c1).res = _class_private_field_get(this, _c1).newResponse(body, options);
-    this.private_overrided = true;
-  }
-  constructor(c, resArgs) {
-    _class_private_field_init(this, _c1, {
-      writable: true,
-      value: void 0
-    });
-    _class_private_field_init(this, _resArgs, {
-      writable: true,
-      value: void 0
-    });
-    this.private_overrided = false;
-    _class_private_field_set(this, _c1, c);
-    _class_private_field_set(this, _resArgs, resArgs);
-  }
-}
-export {
-  createBaseHookContext
-};

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

@@ -1,43 +0,0 @@
-import { createBaseHookContext } from "./base";
-import { RouterAPI } from "./routerApi";
-import { TemplateApi } from "./template";
-function getAfterMatchCtx(entryName, baseHookCtx) {
-  const afterMatchCtx = baseHookCtx;
-  afterMatchCtx.router = new RouterAPI(entryName);
-  return afterMatchCtx;
-}
-async function getAfterRenderCtx(c, baseHookCtx, route) {
-  const afterRenderCtx = baseHookCtx;
-  const resBody = await c.res.text();
-  afterRenderCtx.template = new TemplateApi(resBody);
-  afterRenderCtx.route = route;
-  return afterRenderCtx;
-}
-function createCustomMiddlewaresCtx(c, locals, resArgs) {
-  var _c_env_node, _c_env_node1;
-  const baseContext = createBaseHookContext(c, resArgs);
-  const response = baseContext.response;
-  response.locals = locals;
-  return {
-    ...baseContext,
-    response,
-    source: {
-      req: (_c_env_node = c.env.node) === null || _c_env_node === void 0 ? void 0 : _c_env_node.req,
-      res: (_c_env_node1 = c.env.node) === null || _c_env_node1 === void 0 ? void 0 : _c_env_node1.res
-    }
-  };
-}
-function createAfterStreamingRenderContext(baseHookCtx, route) {
-  const streamingRenderCtx = baseHookCtx;
-  streamingRenderCtx.route = route;
-  return (chunk) => {
-    streamingRenderCtx.chunk = chunk;
-    return streamingRenderCtx;
-  };
-}
-export {
-  createAfterStreamingRenderContext,
-  createCustomMiddlewaresCtx,
-  getAfterMatchCtx,
-  getAfterRenderCtx
-};

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

@@ -1,185 +0,0 @@
-import { time } from "@modern-js/runtime-utils/time";
-import { isArray, isFunction } from "@modern-js/utils";
-import { ServerTimings } from "../../constants";
-import { getLoaderCtx } from "../../helper";
-import { transformResponse } from "../../utils";
-import { createBaseHookContext } from "./base";
-import { createAfterStreamingRenderContext, createCustomMiddlewaresCtx, getAfterMatchCtx, getAfterRenderCtx } from "./context";
-const noop = () => {
-};
-const isHtmlResponse = (response) => {
-  const contentType = response.headers.get("content-type");
-  return contentType === null || contentType === void 0 ? void 0 : contentType.includes("text/html");
-};
-class CustomServer {
-  getHookMiddleware(entryName, routes) {
-    return async (c, next) => {
-      const routeInfo = routes.find((route) => route.entryName === entryName);
-      const monitors = c.get("monitors");
-      const baseHookCtx = createBaseHookContext(c);
-      const afterMatchCtx = getAfterMatchCtx(entryName, baseHookCtx);
-      const getCost = time();
-      await this.hooks.afterMatch.call(afterMatchCtx);
-      const cost = getCost();
-      cost && (monitors === null || monitors === void 0 ? void 0 : monitors.timing(ServerTimings.SERVER_HOOK_AFTER_MATCH, cost));
-      const { url, status } = afterMatchCtx.router;
-      if (url) {
-        return c.redirect(url, status);
-      }
-      const { current } = afterMatchCtx.router;
-      if (current !== entryName) {
-        const rewriteRoute = routes.find((route) => route.entryName === current);
-        if (rewriteRoute) {
-          c.set("matchPathname", rewriteRoute.urlPath);
-          c.set("matchEntryName", current);
-        }
-      }
-      if (c.finalized) {
-        return void 0;
-      }
-      await next();
-      if (c.finalized && (!c.res.body || !isHtmlResponse(c.res) || [
-        404,
-        500
-      ].includes(c.res.status))) {
-        return void 0;
-      }
-      if (c.res) {
-        c.status(c.res.status);
-      }
-      if (routeInfo.isStream) {
-        const afterStreamingRenderContext = createAfterStreamingRenderContext(baseHookCtx, routeInfo);
-        c.res = transformResponse(c.res, async (chunk) => {
-          const context = afterStreamingRenderContext(chunk);
-          const result = await this.hooks.afterStreamingRender.call(context);
-          if (typeof result === "string") {
-            return result;
-          }
-          return result.chunk;
-        });
-      } else {
-        const afterRenderCtx = await getAfterRenderCtx(c, baseHookCtx, routeInfo);
-        const getCost2 = time();
-        await this.hooks.afterRender.call(afterRenderCtx);
-        const cost2 = getCost2();
-        cost2 && (monitors === null || monitors === void 0 ? void 0 : monitors.timing(ServerTimings.SERVER_HOOK_AFTER_RENDER, cost2));
-        if (afterRenderCtx.response.private_overrided) {
-          return void 0;
-        }
-        const newBody = afterRenderCtx.template.get();
-        c.res = c.body(newBody);
-      }
-    };
-  }
-  async getServerMiddleware() {
-    const serverMiddleware = await this.serverMiddlewarePromise;
-    if (!serverMiddleware || !isFunction(serverMiddleware) && !isArray(serverMiddleware)) {
-      return;
-    }
-    if (Array.isArray(serverMiddleware)) {
-      const unstableMiddlewares = getServerMidFromUnstableMid(serverMiddleware);
-      return unstableMiddlewares;
-    }
-    return async (c, next) => {
-      var _c_env_node_res, _c_env_node, _c_env;
-      const monitors = c.get("monitors");
-      const locals = {};
-      const resArgs = {
-        headers: new Headers()
-      };
-      const customMiddlewareCtx = createCustomMiddlewaresCtx(c, locals, resArgs);
-      const getCost = time();
-      await serverMiddleware(customMiddlewareCtx);
-      const cost = getCost();
-      cost && (monitors === null || monitors === void 0 ? void 0 : monitors.timing(ServerTimings.SERVER_MIDDLEWARE, cost));
-      c.set("locals", locals);
-      if (isRedirect(resArgs.headers, resArgs.status)) {
-        return c.redirect(resArgs.headers.get("Location") || "", resArgs.status || 302);
-      }
-      if ((_c_env = c.env) === null || _c_env === void 0 ? void 0 : (_c_env_node = _c_env.node) === null || _c_env_node === void 0 ? void 0 : (_c_env_node_res = _c_env_node.res) === null || _c_env_node_res === void 0 ? void 0 : _c_env_node_res.headersSent) {
-        return void 0;
-      }
-      if (!c.finalized) {
-        return next();
-      }
-    };
-  }
-  constructor(hooks, pwd) {
-    this.hooks = hooks;
-    const webExtension = [];
-    this.serverMiddlewarePromise = hooks.prepareWebServer.call({
-      pwd,
-      config: {
-        middleware: webExtension
-      }
-    });
-  }
-}
-function getServerMidFromUnstableMid(serverMiddleware) {
-  return serverMiddleware.map((middleware) => {
-    return async (c, next) => {
-      const context = await createMiddlewareContextFromHono(c);
-      return middleware(context, next);
-    };
-  });
-}
-function isRedirect(headers, code) {
-  return [
-    301,
-    302,
-    307,
-    308
-  ].includes(code || 0) || headers.get("Location");
-}
-async function createMiddlewareContextFromHono(c) {
-  const loaderContext = getLoaderCtx(c);
-  const rawRequest = c.req.raw;
-  const method = rawRequest.method.toUpperCase();
-  if (![
-    "GET",
-    "HEAD"
-  ].includes(method) && !rawRequest.body && c.env.node.req) {
-    const streamModulePath = "../../adapters/node/polyfills/stream.js";
-    const { createReadableStreamFromReadable } = await import(streamModulePath);
-    const init = {
-      body: createReadableStreamFromReadable(c.env.node.req),
-      headers: rawRequest.headers,
-      signal: rawRequest.signal,
-      method: rawRequest.method
-    };
-    init.duplex = "half";
-    c.req.raw = new Request(rawRequest.url, init);
-  }
-  return {
-    get request() {
-      return c.req.raw;
-    },
-    set request(request) {
-      c.req.raw = request;
-    },
-    get response() {
-      return c.res;
-    },
-    set response(newRes) {
-      c.res = newRes;
-    },
-    get route() {
-      return c.get("route");
-    },
-    get(key) {
-      return loaderContext.get(key);
-    },
-    set(key, value) {
-      return loaderContext.set(key, value);
-    },
-    status: c.status.bind(c),
-    header: c.header.bind(c),
-    body: c.body.bind(c),
-    html: c.html.bind(c),
-    redirect: c.redirect.bind(c)
-  };
-}
-export {
-  CustomServer,
-  getServerMidFromUnstableMid
-};

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

@@ -1,20 +0,0 @@
-class RouterAPI {
-  redirect(url, status = 302) {
-    this.url = url;
-    this.status = status;
-  }
-  rewrite(entryName) {
-    this.current = entryName;
-  }
-  use(entryName) {
-    this.rewrite(entryName);
-  }
-  constructor(entryName) {
-    this.current = entryName;
-    this.status = 200;
-    this.url = "";
-  }
-}
-export {
-  RouterAPI
-};

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

@@ -1,34 +0,0 @@
-import { REPLACE_REG } from "../../constants";
-class TemplateApi {
-  set(content) {
-    this.body = content;
-  }
-  get() {
-    return this.body;
-  }
-  prependHead(fragment) {
-    const { head } = REPLACE_REG.before;
-    this.replaceBody(new RegExp(head), (beforeHead) => `${beforeHead}${fragment}`);
-  }
-  appendHead(fragment) {
-    const { head } = REPLACE_REG.after;
-    this.replaceBody(head, () => `${fragment}${head}`);
-  }
-  prependBody(fragment) {
-    const { body } = REPLACE_REG.before;
-    this.replaceBody(new RegExp(body), (beforeBody) => `${beforeBody}${fragment}`);
-  }
-  appendBody(fragment) {
-    const { body } = REPLACE_REG.after;
-    this.replaceBody(body, () => `${fragment}${body}`);
-  }
-  replaceBody(searchValue, replaceCb) {
-    this.body = this.body.replace(searchValue, replaceCb);
-  }
-  constructor(body) {
-    this.body = body;
-  }
-}
-export {
-  TemplateApi
-};

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

@@ -1,30 +0,0 @@
-import { compatPlugin } from "./compat";
-import { logPlugin } from "./log";
-import { initMonitorsPlugin, injectServerTiming, injectloggerPlugin } from "./monitors";
-import { processedByPlugin } from "./processedBy";
-import { injectRenderHandlerPlugin } from "./render";
-import { injectRoutePlugin } from "./route";
-function createSilenceLogger() {
-  return new Proxy({}, {
-    get: () => {
-      return () => {
-      };
-    }
-  });
-}
-function createDefaultPlugins(options = {}) {
-  const plugins = [
-    compatPlugin(),
-    logPlugin(),
-    initMonitorsPlugin(),
-    injectRenderHandlerPlugin(options),
-    injectloggerPlugin(options.logger ? options.logger : createSilenceLogger()),
-    injectServerTiming(),
-    processedByPlugin(),
-    injectRoutePlugin()
-  ];
-  return plugins;
-}
-export {
-  createDefaultPlugins
-};

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

@@ -1,20 +0,0 @@
-const faviconPlugin = () => ({
-  name: "@modern-js/plugin-favicon",
-  setup(api) {
-    return {
-      prepare() {
-        const { middlewares } = api.useAppContext();
-        middlewares.push({
-          name: "favicon-fallback",
-          path: "/favicon.ico",
-          handler: async (c, _next) => {
-            return c.body(null, 204);
-          }
-        });
-      }
-    };
-  }
-});
-export {
-  faviconPlugin
-};