@modern-js/server-core 2.48.5-alpha.2 → 2.48.6

package/dist/esm-node/base/adapters/node/middlewares/serverStatic.js

@@ -1,75 +0,0 @@
-import path from "path";
-import { fs } from "@modern-js/utils";
-import { getMimeType } from "hono/utils/mime";
-import { fileReader } from "@modern-js/runtime-utils/fileReader";
-import { createErrorHtml } from "../../../utils";
-import { createPublicMiddleware } from "./serverPublic";
-function createStaticMiddleware(options) {
-  const { pwd, routes } = options;
-  const prefix = options.output.assetPrefix || "/";
-  const { distPath: { css: cssPath, js: jsPath, media: mediaPath } = {} } = options.output;
-  const { favicon, faviconByEntries } = options.html;
-  const favicons = prepareFavicons(favicon, faviconByEntries);
-  const staticFiles = [
-    cssPath,
-    jsPath,
-    mediaPath
-  ].filter((v) => Boolean(v));
-  const staticReg = [
-    "static/",
-    "upload/",
-    ...staticFiles
-  ];
-  const iconReg = [
-    "favicon.ico",
-    "icon.png",
-    ...favicons
-  ];
-  const regPrefix = prefix.endsWith("/") ? prefix : `${prefix}/`;
-  const staticPathRegExp = new RegExp(`^${regPrefix}(${[
-    ...staticReg,
-    ...iconReg
-  ].join("|")})`);
-  return async (c, next) => {
-    const pathname = c.req.path;
-    const hit = staticPathRegExp.test(pathname);
-    if (hit) {
-      const filepath = path.join(pwd, pathname.replace(prefix, () => ""));
-      if (!await fs.pathExists(filepath)) {
-        return c.html(createErrorHtml(404), 404);
-      }
-      const mimeType = getMimeType(filepath);
-      if (mimeType) {
-        c.header("Content-Type", mimeType);
-      }
-      const stat = await fs.lstat(filepath);
-      const { size } = stat;
-      const chunk = await fileReader.readFile(filepath, "buffer");
-      c.header("Content-Length", String(size));
-      return c.body(chunk, 200);
-    } else {
-      return createPublicMiddleware({
-        pwd,
-        routes: routes || []
-      })(c, next);
-    }
-  };
-}
-const prepareFavicons = (favicon, faviconByEntries) => {
-  const faviconNames = [];
-  if (favicon && typeof favicon === "string") {
-    faviconNames.push(favicon.substring(favicon.lastIndexOf("/") + 1));
-  }
-  if (faviconByEntries) {
-    Object.keys(faviconByEntries).forEach((f) => {
-      const curFavicon = faviconByEntries[f];
-      if (curFavicon) {
-        faviconNames.push(curFavicon.substring(curFavicon.lastIndexOf("/") + 1));
-      }
-    });
-  }
-  return faviconNames;
-};
-export {
-  createStaticMiddleware
-};

package/dist/esm-node/base/adapters/node/middlewares/templates.js

@@ -1,32 +0,0 @@
-import path from "path";
-import { fileReader } from "@modern-js/runtime-utils/fileReader";
-async function getHtmlTemplates(pwd, routes) {
-  const htmls = await Promise.all(routes.map(async (route) => {
-    let html;
-    try {
-      var _this;
-      const htmlPath = path.join(pwd, route.entryPath);
-      html = (_this = await fileReader.readFile(htmlPath, "utf-8")) === null || _this === void 0 ? void 0 : _this.toString();
-    } catch (e) {
-    }
-    return [
-      route.entryName,
-      html
-    ];
-  }) || []);
-  const templates = Object.fromEntries(htmls);
-  return templates;
-}
-function injectTemplates(pwd, routes) {
-  return async (c, next) => {
-    if (routes && !c.get("templates")) {
-      const templates = await getHtmlTemplates(pwd, routes);
-      c.set("templates", templates);
-    }
-    await next();
-  };
-}
-export {
-  getHtmlTemplates,
-  injectTemplates
-};

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

@@ -1,101 +0,0 @@
-import { createServer, ServerResponse } from "node:http";
-import { createReadableStreamFromReadable, writeReadableStreamToWritable } from "./polyfills/stream";
-import { installGlobals } from "./polyfills/install";
-installGlobals();
-const createWebRequest = (req, res) => {
-  var _req_url;
-  const headerRecord = [];
-  const len = req.rawHeaders.length;
-  for (let i = 0; i < len; i += 2) {
-    headerRecord.push([
-      req.rawHeaders[i],
-      req.rawHeaders[i + 1]
-    ]);
-  }
-  const { method } = req;
-  const controller = new AbortController();
-  const init = {
-    method,
-    headers: headerRecord,
-    signal: controller.signal
-  };
-  res.on("close", () => controller.abort());
-  if (!(method === "GET" || method === "HEAD") && ((_req_url = req.url) === null || _req_url === void 0 ? void 0 : _req_url.includes("__loader"))) {
-    init.body = createReadableStreamFromReadable(req);
-    init.duplex = "half";
-  }
-  const url = `http://${req.headers.host}${req.url}`;
-  const request = new Request(url, init);
-  return request;
-};
-const sendResponse = async (response, res) => {
-  var _response_headers_get;
-  res.statusMessage = response.statusText;
-  res.statusCode = response.status;
-  const cookies = [];
-  for (const [key, value] of response.headers.entries()) {
-    if (key === "set-cookie") {
-      cookies.push(value);
-    } else {
-      res.setHeader(key, value);
-    }
-  }
-  if (cookies.length > 0) {
-    res.setHeader("set-cookie", cookies);
-  }
-  if (((_response_headers_get = response.headers.get("Content-Type")) === null || _response_headers_get === void 0 ? void 0 : _response_headers_get.match(/text\/event-stream/i)) && res instanceof ServerResponse) {
-    res.flushHeaders();
-  }
-  if (response.body) {
-    await writeReadableStreamToWritable(response.body, res);
-  } else {
-    res.end();
-  }
-};
-const handleResponseError = (e, res) => {
-  const err = e instanceof Error ? e : new Error("unknown error", {
-    cause: e
-  });
-  if (err.code === "ERR_STREAM_PREMATURE_CLOSE") {
-    console.info("The user aborted a request.");
-  } else {
-    console.error(e);
-    if (!res.headersSent) {
-      res.writeHead(500, {
-        "Content-Type": "text/plain"
-      });
-    }
-    res.end(`Error: ${err.message}`);
-    res.destroy(err);
-  }
-};
-const getRequestListener = (handler) => {
-  return async (req, res) => {
-    try {
-      const request = createWebRequest(req, res);
-      const response = await handler(request, {
-        node: {
-          req,
-          res
-        }
-      });
-      if (!res.headersSent && !response.res) {
-        await sendResponse(response, res);
-      }
-    } catch (error) {
-      return handleResponseError(error, res);
-    }
-  };
-};
-const createNodeServer = (requestHandler) => {
-  const requestListener = getRequestListener(requestHandler);
-  const nodeServer = createServer(requestListener);
-  nodeServer.getRequestListener = () => requestListener;
-  nodeServer.getRequestHandler = () => requestHandler;
-  return nodeServer;
-};
-export {
-  createNodeServer,
-  createWebRequest,
-  sendResponse
-};

package/dist/esm-node/base/adapters/node/polyfills/index.js

@@ -1,2 +0,0 @@
-export * from "./install";
-export * from "./stream";

package/dist/esm-node/base/adapters/node/polyfills/install.js

@@ -1,48 +0,0 @@
-import { Request as NodeRequest, Response as NodeResponse, Headers as NodeHeaders, FormData as NodeFormData } from "@web-std/fetch";
-import { TransformStream as NodeTransformStream, ReadableStream as NodeReadableStream, WritableStream as NodeWritableStream } from "@web-std/stream";
-import { File as NodeFile, Blob as NodeBlob } from "@web-std/file";
-if (!Object.getOwnPropertyDescriptor(NodeHeaders.prototype, "getSetCookie")) {
-  Object.defineProperty(NodeHeaders.prototype, "getSetCookie", {
-    value: function getSetCookie() {
-      const cookies = [];
-      this.forEach((value, name) => {
-        if (name.toLowerCase() === "set-cookie") {
-          cookies.push(value);
-        }
-      });
-      return cookies;
-    }
-  });
-}
-const installGlobals = () => {
-  if (!global.Headers) {
-    global.Headers = NodeHeaders;
-  }
-  if (!global.Request) {
-    global.Request = NodeRequest;
-  }
-  if (!global.Response) {
-    global.Response = NodeResponse;
-  }
-  if (!global.FormData) {
-    global.FormData = NodeFormData;
-  }
-  if (!global.TransformStream) {
-    global.TransformStream = NodeTransformStream;
-  }
-  if (!global.ReadableStream) {
-    global.ReadableStream = NodeReadableStream;
-  }
-  if (!global.WritableStream) {
-    global.WritableStream = NodeWritableStream;
-  }
-  if (!global.File) {
-    global.File = NodeFile;
-  }
-  if (!global.Blob) {
-    global.Blob = NodeBlob;
-  }
-};
-export {
-  installGlobals
-};

package/dist/esm-node/base/adapters/node/polyfills/stream.js

@@ -1,126 +0,0 @@
-import { Stream } from "node:stream";
-async function writeReadableStreamToWritable(stream, writable) {
-  const reader = stream.getReader();
-  const flushable = writable;
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) {
-        writable.end();
-        break;
-      }
-      writable.write(value);
-      if (typeof flushable.flush === "function") {
-        flushable.flush();
-      }
-    }
-  } catch (error) {
-    writable.destroy(error);
-    throw error;
-  }
-}
-async function writeAsyncIterableToWritable(iterable, writable) {
-  try {
-    for await (const chunk of iterable) {
-      writable.write(chunk);
-    }
-    writable.end();
-  } catch (error) {
-    writable.destroy(error);
-    throw error;
-  }
-}
-async function readableStreamToString(stream, encoding) {
-  const reader = stream.getReader();
-  const chunks = [];
-  while (true) {
-    const { done, value } = await reader.read();
-    if (done) {
-      break;
-    }
-    if (value) {
-      chunks.push(value);
-    }
-  }
-  return Buffer.concat(chunks).toString(encoding);
-}
-const createReadableStreamFromReadable = (source) => {
-  const pump = new StreamPump(source);
-  const stream = new ReadableStream(pump, pump);
-  return stream;
-};
-class StreamPump {
-  size(chunk) {
-    return (chunk === null || chunk === void 0 ? void 0 : chunk.byteLength) || 0;
-  }
-  start(controller) {
-    this.controller = controller;
-    this.stream.on("data", this.enqueue);
-    this.stream.once("error", this.error);
-    this.stream.once("end", this.close);
-    this.stream.once("close", this.close);
-  }
-  pull() {
-    this.resume();
-  }
-  cancel(reason) {
-    if (this.stream.destroy) {
-      this.stream.destroy(reason);
-    }
-    this.stream.off("data", this.enqueue);
-    this.stream.off("error", this.error);
-    this.stream.off("end", this.close);
-    this.stream.off("close", this.close);
-  }
-  enqueue(chunk) {
-    if (this.controller) {
-      try {
-        const bytes = chunk instanceof Uint8Array ? chunk : Buffer.from(chunk);
-        const available = (this.controller.desiredSize || 0) - bytes.byteLength;
-        this.controller.enqueue(bytes);
-        if (available <= 0) {
-          this.pause();
-        }
-      } catch (error) {
-        this.controller.error(new Error("Could not create Buffer, chunk must be of type string or an instance of Buffer, ArrayBuffer, or Array or an Array-like Object"));
-        this.cancel();
-      }
-    }
-  }
-  pause() {
-    if (this.stream.pause) {
-      this.stream.pause();
-    }
-  }
-  resume() {
-    if (this.stream.readable && this.stream.resume) {
-      this.stream.resume();
-    }
-  }
-  close() {
-    if (this.controller) {
-      this.controller.close();
-      delete this.controller;
-    }
-  }
-  error(error) {
-    if (this.controller) {
-      this.controller.error(error);
-      delete this.controller;
-    }
-  }
-  constructor(stream) {
-    this.highWaterMark = stream.readableHighWaterMark || new Stream.Readable().readableHighWaterMark;
-    this.accumalatedSize = 0;
-    this.stream = stream;
-    this.enqueue = this.enqueue.bind(this);
-    this.error = this.error.bind(this);
-    this.close = this.close.bind(this);
-  }
-}
-export {
-  createReadableStreamFromReadable,
-  readableStreamToString,
-  writeAsyncIterableToWritable,
-  writeReadableStreamToWritable
-};

package/dist/esm-node/base/constants.js

@@ -1,31 +0,0 @@
-const AGGRED_DIR = {
-  mock: "config/mock",
-  server: "server",
-  api: "api",
-  shared: "shared",
-  lambda: "lambda"
-};
-const REPLACE_REG = {
-  before: {
-    head: "<head[^>]*>",
-    body: "<body[^>]*>"
-  },
-  after: {
-    head: "</head>",
-    body: "</body>"
-  }
-};
-var ServerReportTimings;
-(function(ServerReportTimings2) {
-  ServerReportTimings2["SERVER_HANDLE_REQUEST"] = "server-handle-request";
-  ServerReportTimings2["SERVER_MIDDLEWARE"] = "server-middleware";
-  ServerReportTimings2["SERVER_HOOK_AFTER_RENDER"] = "server-hook-after-render";
-  ServerReportTimings2["SERVER_HOOK_AFTER_MATCH"] = "server-hook-after-match";
-})(ServerReportTimings || (ServerReportTimings = {}));
-const X_RENDER_CACHE = "x-render-cache";
-export {
-  AGGRED_DIR,
-  REPLACE_REG,
-  ServerReportTimings,
-  X_RENDER_CACHE
-};

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

@@ -1,16 +0,0 @@
-import { createErrorHtml } from "./utils";
-import { AGGRED_DIR } from "./constants";
-import { favionFallbackMiddleware, injectReporter, injectLogger, getRenderHandler, bindRenderHandler, logHandler, processedBy } from "./middlewares";
-import { createServerBase } from "./serverBase";
-export {
-  AGGRED_DIR,
-  bindRenderHandler,
-  createErrorHtml,
-  createServerBase,
-  favionFallbackMiddleware,
-  getRenderHandler,
-  injectLogger,
-  injectReporter,
-  logHandler,
-  processedBy
-};

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

@@ -1,130 +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) {
-  const logger = c.get("logger");
-  const metrics = c.get("metrics");
-  return {
-    request: new BaseHookRequest(c),
-    response: new BaseHookResponse(c),
-    logger,
-    metrics
-  };
-}
-var _headers = /* @__PURE__ */ new WeakMap();
-class BaseHookRequest {
-  get url() {
-    return this.req.path;
-  }
-  // TODO: remove next major version
-  set url(_u) {
-  }
-  get host() {
-    return getHost(this.req.raw);
-  }
-  // TODO: remove next major version
-  set host(_h) {
-  }
-  get pathname() {
-    return this.req.path;
-  }
-  // TODO: remove next major version
-  set pathname(_p) {
-  }
-  get query() {
-    return 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(this.c, key);
-      }
-    };
-  }
-  get cookie() {
-    return this.req.header("cookie");
-  }
-  // TODO: remove next major version
-  set cookie(_c) {
-  }
-  constructor(c) {
-    _class_private_field_init(this, _headers, {
-      writable: true,
-      value: void 0
-    });
-    this.headersData = {};
-    this.c = c;
-    this.req = c.req;
-    const rawHeaders = this.req.raw.headers;
-    rawHeaders.forEach((value, key) => {
-      this.headersData[key] = value;
-    });
-    _class_private_field_set(this, _headers, new Proxy(this.headersData, {
-      get(target, p) {
-        return target[p];
-      },
-      set(target, p, newValue) {
-        target[p] = newValue;
-        rawHeaders.set(p, newValue);
-        return true;
-      }
-    }));
-  }
-}
-class BaseHookResponse {
-  get(key) {
-    return this.c.res.headers.get(key);
-  }
-  set(key, value) {
-    if ([
-      "set-cookie",
-      "Set-Cookie"
-    ].includes(key)) {
-      this.c.header(key, value.toString(), {
-        append: true
-      });
-    } else {
-      this.c.header(key, value.toString());
-    }
-  }
-  status(code) {
-    this.c.status(code);
-  }
-  get cookies() {
-    const setCookie = (key, value) => {
-      this.c.header("set-cookie", `${key}=${value}`, {
-        append: true
-      });
-    };
-    const clearCookie = () => {
-      this.c.header("set-cookie", void 0);
-    };
-    return {
-      set: setCookie,
-      clear: clearCookie
-    };
-  }
-  raw(body, options) {
-    this.c.res = this.c.newResponse(body, options);
-    this.private_overrided = true;
-  }
-  constructor(c) {
-    this.private_overrided = false;
-    this.c = c;
-  }
-}
-export {
-  createBaseHookContext
-};

package/dist/esm-node/base/middlewares/customServer/context.js

@@ -1,46 +0,0 @@
-import { RouterAPI } from "./routerApi";
-import { TemplateApi } from "./template";
-import { createBaseHookContext } from "./base";
-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) {
-  var _c_env_node, _c_env_node1;
-  const baseContext = createBaseHookContext(c);
-  const reporter = c.get("reporter");
-  return {
-    ...baseContext,
-    reporter,
-    response: {
-      ...baseContext.response,
-      locals
-    },
-    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
-};