@modern-js/server-core 2.48.6 → 2.49.1-alpha.0

package/dist/cjs/base/adapters/node/middlewares/templates.js

@@ -0,0 +1,67 @@
+"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 templates_exports = {};
+__export(templates_exports, {
+  getHtmlTemplates: () => getHtmlTemplates,
+  injectTemplates: () => injectTemplates
+});
+module.exports = __toCommonJS(templates_exports);
+var import_path = __toESM(require("path"));
+var import_fileReader = require("@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 = import_path.default.join(pwd, route.entryPath);
+      html = (_this = await import_fileReader.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();
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getHtmlTemplates,
+  injectTemplates
+});

package/dist/cjs/base/adapters/node/node.js

@@ -0,0 +1,127 @@
+"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 node_exports = {};
+__export(node_exports, {
+  createNodeServer: () => createNodeServer,
+  createWebRequest: () => createWebRequest,
+  sendResponse: () => sendResponse
+});
+module.exports = __toCommonJS(node_exports);
+var import_node_http = require("node:http");
+var import_stream = require("./polyfills/stream");
+var import_install = require("./polyfills/install");
+(0, import_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 = (0, import_stream.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 import_node_http.ServerResponse) {
+    res.flushHeaders();
+  }
+  if (response.body) {
+    await (0, import_stream.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 = (0, import_node_http.createServer)(requestListener);
+  nodeServer.getRequestListener = () => requestListener;
+  nodeServer.getRequestHandler = () => requestHandler;
+  return nodeServer;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createNodeServer,
+  createWebRequest,
+  sendResponse
+});

package/dist/cjs/base/adapters/node/polyfills/index.js

@@ -0,0 +1,24 @@
+"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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var polyfills_exports = {};
+module.exports = __toCommonJS(polyfills_exports);
+__reExport(polyfills_exports, require("./install"), module.exports);
+__reExport(polyfills_exports, require("./stream"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./install"),
+  ...require("./stream")
+});

package/dist/cjs/base/adapters/node/polyfills/install.js

@@ -0,0 +1,72 @@
+"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 install_exports = {};
+__export(install_exports, {
+  installGlobals: () => installGlobals
+});
+module.exports = __toCommonJS(install_exports);
+var import_fetch = require("@web-std/fetch");
+var import_stream = require("@web-std/stream");
+var import_file = require("@web-std/file");
+if (!Object.getOwnPropertyDescriptor(import_fetch.Headers.prototype, "getSetCookie")) {
+  Object.defineProperty(import_fetch.Headers.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 = import_fetch.Headers;
+  }
+  if (!global.Request) {
+    global.Request = import_fetch.Request;
+  }
+  if (!global.Response) {
+    global.Response = import_fetch.Response;
+  }
+  if (!global.FormData) {
+    global.FormData = import_fetch.FormData;
+  }
+  if (!global.TransformStream) {
+    global.TransformStream = import_stream.TransformStream;
+  }
+  if (!global.ReadableStream) {
+    global.ReadableStream = import_stream.ReadableStream;
+  }
+  if (!global.WritableStream) {
+    global.WritableStream = import_stream.WritableStream;
+  }
+  if (!global.File) {
+    global.File = import_file.File;
+  }
+  if (!global.Blob) {
+    global.Blob = import_file.Blob;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  installGlobals
+});

package/dist/cjs/base/adapters/node/polyfills/stream.js

@@ -0,0 +1,153 @@
+"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 stream_exports = {};
+__export(stream_exports, {
+  createReadableStreamFromReadable: () => createReadableStreamFromReadable,
+  readableStreamToString: () => readableStreamToString,
+  writeAsyncIterableToWritable: () => writeAsyncIterableToWritable,
+  writeReadableStreamToWritable: () => writeReadableStreamToWritable
+});
+module.exports = __toCommonJS(stream_exports);
+var import_node_stream = require("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 import_node_stream.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);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createReadableStreamFromReadable,
+  readableStreamToString,
+  writeAsyncIterableToWritable,
+  writeReadableStreamToWritable
+});

package/dist/cjs/base/constants.js

@@ -0,0 +1,58 @@
+"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 constants_exports = {};
+__export(constants_exports, {
+  AGGRED_DIR: () => AGGRED_DIR,
+  REPLACE_REG: () => REPLACE_REG,
+  ServerReportTimings: () => ServerReportTimings,
+  X_RENDER_CACHE: () => X_RENDER_CACHE
+});
+module.exports = __toCommonJS(constants_exports);
+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";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AGGRED_DIR,
+  REPLACE_REG,
+  ServerReportTimings,
+  X_RENDER_CACHE
+});

package/dist/cjs/base/index.js

@@ -0,0 +1,49 @@
+"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 base_exports = {};
+__export(base_exports, {
+  AGGRED_DIR: () => import_constants.AGGRED_DIR,
+  bindRenderHandler: () => import_middlewares.bindRenderHandler,
+  createErrorHtml: () => import_utils.createErrorHtml,
+  createServerBase: () => import_serverBase.createServerBase,
+  favionFallbackMiddleware: () => import_middlewares.favionFallbackMiddleware,
+  getRenderHandler: () => import_middlewares.getRenderHandler,
+  injectLogger: () => import_middlewares.injectLogger,
+  injectReporter: () => import_middlewares.injectReporter,
+  logHandler: () => import_middlewares.logHandler,
+  processedBy: () => import_middlewares.processedBy
+});
+module.exports = __toCommonJS(base_exports);
+var import_utils = require("./utils");
+var import_constants = require("./constants");
+var import_middlewares = require("./middlewares");
+var import_serverBase = require("./serverBase");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AGGRED_DIR,
+  bindRenderHandler,
+  createErrorHtml,
+  createServerBase,
+  favionFallbackMiddleware,
+  getRenderHandler,
+  injectLogger,
+  injectReporter,
+  logHandler,
+  processedBy
+});