@modern-js/prod-server 2.48.6 → 2.49.0

package/dist/esm-node/libs/context/context.js

@@ -1,202 +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 { URL } from "url";
-import qs from "querystring";
-import { Buffer } from "buffer";
-import createEtag from "etag";
-import fresh from "fresh";
-import { cutNameByHyphen } from "@modern-js/utils";
-import { ServerTiming } from "../serverTiming";
-import { defaultReporter } from "../reporter";
-import { headersWithoutCookie } from "../../utils";
-const MOCK_URL_BASE = "https://modernjs.dev/";
-var _urls = /* @__PURE__ */ new WeakMap(), _queries = /* @__PURE__ */ new WeakMap();
-class ModernServerContext {
-  get logger() {
-    return this.req.logger;
-  }
-  get metrics() {
-    return this.req.metrics;
-  }
-  get parsedURL() {
-    try {
-      let url = _class_private_field_get(this, _urls).get(this.req.url);
-      if (!url) {
-        url = new URL(this.req.url, MOCK_URL_BASE);
-        _class_private_field_get(this, _urls).set(this.req.url, url);
-      }
-      return url;
-    } catch (e) {
-      this.logger.error("Parse URL error", e.stack || e.message);
-      return new URL("/_modern_mock_path", MOCK_URL_BASE);
-    }
-  }
-  bind() {
-    const { req, res } = this;
-    req.get = (key) => this.getReqHeader(key);
-    res.set = (key, value) => {
-      if (!res.headersSent) {
-        res.setHeader(key, value);
-      }
-      return res;
-    };
-    res.send = (body) => {
-      this.send(body);
-    };
-  }
-  // compat express res.send, only support etag now
-  send(body) {
-    try {
-      const generateETag = !this.res.getHeader("ETag") && this.options.etag;
-      if (body !== void 0 && generateETag) {
-        const encoding = typeof body === "string" ? "utf-8" : void 0;
-        const buf = !Buffer.isBuffer(body) ? Buffer.from(body, encoding) : body;
-        const etag = createEtag(buf, {
-          weak: true
-        });
-        if (etag) {
-          this.res.setHeader("ETag", etag);
-        }
-      }
-      if (this.fresh) {
-        this.status = 304;
-      }
-    } catch (e) {
-      this.logger.error(e.message);
-    }
-    this.res.end(body);
-  }
-  setParams(params) {
-    this.params = params;
-  }
-  setServerData(key, value) {
-    this.serverData[key] = value;
-  }
-  getReqHeader(key) {
-    const { req } = this;
-    const field = key.toLowerCase();
-    switch (field) {
-      case "referer":
-      case "referrer":
-        return req.headers.referrer || req.headers.referer || "";
-      default:
-        return req.headers[field] || "";
-    }
-  }
-  get fresh() {
-    const { status, res, method } = this;
-    if ("GET" !== method && "HEAD" !== method) {
-      return false;
-    }
-    if (status >= 200 && status < 300 || 304 === status) {
-      return fresh(this.headers, {
-        etag: res.getHeader("ETag"),
-        "last-modified": res.getHeader("Last-Modified")
-      });
-    }
-    return false;
-  }
-  /* request property */
-  get headers() {
-    return this.req.headers;
-  }
-  get method() {
-    return this.req.method;
-  }
-  get url() {
-    return this.req.url || "";
-  }
-  set url(val) {
-    this.req.url = val;
-  }
-  get host() {
-    let host = this.getReqHeader("X-Forwarded-Host");
-    if (!host) {
-      host = this.getReqHeader("Host");
-    }
-    host = host.split(/\s*,\s*/, 1)[0] || "undefined";
-    return host;
-  }
-  get protocol() {
-    if (this.req.socket.encrypted) {
-      return "https";
-    }
-    const proto = this.getReqHeader("X-Forwarded-Proto");
-    return proto ? proto.split(/\s*,\s*/, 1)[0] : "http";
-  }
-  get origin() {
-    return `${this.protocol}://${this.host}`;
-  }
-  get href() {
-    return this.origin + this.url;
-  }
-  get path() {
-    return this.parsedURL.pathname;
-  }
-  set path(p) {
-    if (!p) {
-      return;
-    }
-    if (this.path === p) {
-      return;
-    }
-    this.url = p + this.parsedURL.search;
-  }
-  get querystring() {
-    if (!this.req) {
-      return "";
-    }
-    return this.parsedURL.search.replace(/^\?/, "") || "";
-  }
-  get query() {
-    const str = this.querystring;
-    let query = _class_private_field_get(this, _queries).get(str);
-    if (!query) {
-      query = qs.parse(str);
-      _class_private_field_get(this, _queries).set(str, query);
-    }
-    return query;
-  }
-  /* response property */
-  get status() {
-    return this.res.statusCode;
-  }
-  set status(statusCode) {
-    this.res.statusCode = statusCode;
-  }
-  /**
-  * 判断链接是否已经关闭
-  */
-  resHasHandled() {
-    return this.res.writableEnded;
-  }
-  error(dig, e = "") {
-    this.logger.error(`Web Server Error - ${dig}, error = %s, req.url = %s, req.headers = %o`, e instanceof Error ? e.stack || e.message : e, this.path, headersWithoutCookie(this.headers));
-  }
-  constructor(req, res, options) {
-    _class_private_field_init(this, _urls, {
-      writable: true,
-      value: void 0
-    });
-    _class_private_field_init(this, _queries, {
-      writable: true,
-      value: void 0
-    });
-    this.params = {};
-    this.reporter = defaultReporter;
-    this.serverData = {};
-    this.options = {};
-    this.req = req;
-    this.res = res;
-    this.options = options || {};
-    this.bind();
-    _class_private_field_set(this, _urls, /* @__PURE__ */ new Map());
-    _class_private_field_set(this, _queries, /* @__PURE__ */ new Map());
-    this.serverTiming = new ServerTiming(this.res, cutNameByHyphen((options === null || options === void 0 ? void 0 : options.metaName) || "modern-js"));
-    req.reporter && (this.reporter = req.reporter);
-  }
-}
-export {
-  ModernServerContext
-};

package/dist/esm-node/libs/context/index.js

@@ -1,6 +0,0 @@
-import { ModernServerContext } from "./context";
-const createContext = (req, res, options) => new ModernServerContext(req, res, options);
-export {
-  ModernServerContext,
-  createContext
-};

package/dist/esm-node/libs/hook-api/afterRenderForStream.js

@@ -1,10 +0,0 @@
-import { Transform } from "stream";
-const afterRenderInjectableStream = (fn) => new Transform({
-  async write(chunk, _, callback) {
-    this.push(await fn(chunk.toString()));
-    callback();
-  }
-});
-export {
-  afterRenderInjectableStream
-};

package/dist/esm-node/libs/hook-api/base.js

@@ -1,61 +0,0 @@
-import cookie from "cookie";
-class BaseResponse {
-  get(key) {
-    return this.res.getHeader(key);
-  }
-  set(key, value) {
-    return this.res.setHeader(key, value);
-  }
-  status(code) {
-    this.res.statusCode = code;
-  }
-  setCookie(key, value, options) {
-    const cookieValue = this.res.getHeader("set-cookie") || "";
-    const fmt = Array.isArray(cookieValue) ? cookieValue : [
-      cookieValue
-    ].filter(Boolean);
-    fmt.push(cookie.serialize(key, value, options));
-    this.res.setHeader("set-cookie", fmt.length === 1 ? fmt[0] : fmt);
-  }
-  clearCookie() {
-    this.res.removeHeader("set-cookie");
-  }
-  raw(body, options) {
-    const { status, headers = {} } = options || {};
-    Object.entries(headers).forEach(([key, value]) => {
-      this.res.setHeader(key, value);
-    });
-    if (status) {
-      this.res.statusCode = status;
-    }
-    this.res.end(body);
-  }
-  constructor(res) {
-    this.res = res;
-    this.cookies = {
-      set: this.setCookie.bind(this),
-      clear: this.clearCookie.bind(this)
-    };
-  }
-}
-class BaseRequest {
-  getCookie(key) {
-    return this._cookie[key];
-  }
-  constructor(request) {
-    this.url = request.url;
-    this.host = request.host;
-    this.pathname = request.path;
-    this.query = request.query;
-    this.headers = request.headers;
-    this.cookie = request.headers.cookie || "";
-    this._cookie = cookie.parse(this.cookie);
-    this.cookies = {
-      get: this.getCookie.bind(this)
-    };
-  }
-}
-export {
-  BaseRequest,
-  BaseResponse
-};

package/dist/esm-node/libs/hook-api/index.js

@@ -1,57 +0,0 @@
-import { RouteAPI } from "./route";
-import { TemplateAPI } from "./template";
-import { BaseRequest, BaseResponse } from "./base";
-const base = (context) => {
-  const { res } = context;
-  return {
-    response: new BaseResponse(res),
-    request: new BaseRequest(context),
-    logger: context.logger,
-    metrics: context.metrics
-  };
-};
-const createAfterMatchContext = (context, entryName) => {
-  const baseContext = base(context);
-  return {
-    ...baseContext,
-    router: new RouteAPI(entryName)
-  };
-};
-const createAfterRenderContext = (context, route, content) => {
-  const baseContext = base(context);
-  return {
-    ...baseContext,
-    route,
-    template: new TemplateAPI(content)
-  };
-};
-const createAfterStreamingRenderContext = (context, route) => {
-  const baseContext = base(context);
-  return (chunk) => {
-    return {
-      ...baseContext,
-      route,
-      chunk
-    };
-  };
-};
-const createMiddlewareContext = (context) => {
-  const baseContext = base(context);
-  baseContext.response.locals = context.res.locals || {};
-  return {
-    ...baseContext,
-    response: baseContext.response,
-    reporter: context.reporter,
-    source: {
-      req: context.req,
-      res: context.res
-    }
-  };
-};
-export {
-  base,
-  createAfterMatchContext,
-  createAfterRenderContext,
-  createAfterStreamingRenderContext,
-  createMiddlewareContext
-};

package/dist/esm-node/libs/hook-api/index.worker.js

@@ -1,89 +0,0 @@
-import { BaseRequest, BaseResponse } from "./base";
-import { RouteAPI } from "./route";
-import { TemplateAPI } from "./template";
-class ServerResponse {
-  set statusCode(code) {
-    this.res.status = code;
-  }
-  get statusCode() {
-    return this.res.status;
-  }
-  getHeader(key) {
-    var _this_res_headers_get;
-    return (_this_res_headers_get = this.res.headers.get(key)) !== null && _this_res_headers_get !== void 0 ? _this_res_headers_get : void 0;
-  }
-  setHeader(key, value) {
-    this.res.headers.set(key, value);
-  }
-  removeHeader(key) {
-    this.res.headers.delete(key);
-  }
-  end(body) {
-    this.res.body = body;
-    this.res.isSent = true;
-  }
-  constructor(res) {
-    this.res = res;
-    this.locals = res.locals;
-  }
-}
-const base = (context) => {
-  const { req, res, logger, metrics } = context;
-  const serverResponse = new ServerResponse(res);
-  const { host, pathname, searchParams } = new URL(req.url);
-  const headers = {};
-  req.headers.forEach((value, key) => {
-    headers[key] = value;
-  });
-  return {
-    response: new BaseResponse(serverResponse),
-    request: new BaseRequest({
-      url: req.url,
-      host,
-      path: pathname,
-      headers,
-      // eslint-disable-next-line node/no-unsupported-features/es-builtins
-      query: Object.fromEntries(searchParams)
-    }),
-    logger,
-    metrics
-  };
-};
-const createAfterMatchContext = (context, entryName) => {
-  const baseContext = base(context);
-  return {
-    ...baseContext,
-    router: new RouteAPI(entryName)
-  };
-};
-const createAfterRenderContext = (context, route, content) => {
-  const baseContext = base(context);
-  return {
-    ...baseContext,
-    route,
-    template: new TemplateAPI(content)
-  };
-};
-const createMiddlewareContext = (context) => {
-  const baseContext = base(context);
-  baseContext.response.locals = context.res.locals;
-  const { url, headers } = context.req;
-  const rawRequest = new Request(url, {
-    headers
-  });
-  return {
-    ...baseContext,
-    reporter: context.reporter,
-    response: baseContext.response,
-    source: {
-      req: rawRequest,
-      res: baseContext.response
-    }
-  };
-};
-export {
-  base,
-  createAfterMatchContext,
-  createAfterRenderContext,
-  createMiddlewareContext
-};

package/dist/esm-node/libs/hook-api/route.js

@@ -1,20 +0,0 @@
-class RouteAPI {
-  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 {
-  RouteAPI
-};

package/dist/esm-node/libs/hook-api/template.js

@@ -1,47 +0,0 @@
-const RegList = {
-  before: {
-    head: "<head[^>]*>",
-    body: "<body[^>]*>"
-  },
-  after: {
-    head: "</head>",
-    body: "</body>"
-  }
-};
-class TemplateAPI {
-  get() {
-    return this.content;
-  }
-  set(content) {
-    this.content = content;
-  }
-  prependHead(fragment) {
-    const { head } = RegList.before;
-    return this.replaceByFunction(new RegExp(head), (beforeHead) => `${beforeHead}${fragment}`);
-  }
-  appendHead(fragment) {
-    const { head } = RegList.after;
-    return this.replace(head, `${fragment}${head}`);
-  }
-  prependBody(fragment) {
-    const { body } = RegList.before;
-    return this.replaceByFunction(new RegExp(body), (beforeBody) => `${beforeBody}${fragment}`);
-  }
-  appendBody(fragment) {
-    const { body } = RegList.after;
-    return this.replace(body, `${fragment}${body}`);
-  }
-  replaceByFunction(reg, replacer) {
-    this.content = this.content.replace(reg, replacer);
-  }
-  replace(reg, text) {
-    this.content = this.content.replace(reg, text);
-  }
-  constructor(content) {
-    this.content = content;
-  }
-}
-export {
-  RegList,
-  TemplateAPI
-};

package/dist/esm-node/libs/hook-api/templateForStream.js

@@ -1,28 +0,0 @@
-import { Transform } from "stream";
-import { RegList } from "./template";
-const templateInjectableStream = ({ prependHead, appendHead, prependBody, appendBody }) => new Transform({
-  write(chunk, _, callback) {
-    let chunk_str = chunk.toString();
-    if (prependHead) {
-      const { head } = RegList.before;
-      chunk_str = chunk_str.replace(new RegExp(head), (beforeHead) => `${beforeHead}${prependHead}`);
-    }
-    if (appendHead) {
-      const { head } = RegList.after;
-      chunk_str = chunk_str.replace(head, `${appendHead}${head}`);
-    }
-    if (prependBody) {
-      const { body } = RegList.before;
-      chunk_str = chunk_str.replace(new RegExp(body), (beforeBody) => `${beforeBody}${prependBody}`);
-    }
-    if (appendBody) {
-      const { body } = RegList.after;
-      chunk_str = chunk_str.replace(body, `${appendBody}${body}`);
-    }
-    this.push(chunk_str);
-    callback();
-  }
-});
-export {
-  templateInjectableStream
-};

package/dist/esm-node/libs/loadConfig.js

@@ -1,34 +0,0 @@
-import * as path from "path";
-import { compatRequire, fs, DEFAULT_SERVER_CONFIG } from "@modern-js/utils";
-import mergeDeep from "merge-deep";
-const getServerConfigPath = (distDirectory, serverConfigFile = DEFAULT_SERVER_CONFIG) => {
-  const serverConfigPath = path.join(distDirectory, serverConfigFile);
-  return `${serverConfigPath}.js`;
-};
-const requireConfig = (serverConfigPath) => {
-  if (fs.pathExistsSync(serverConfigPath)) {
-    return compatRequire(serverConfigPath);
-  }
-  return {};
-};
-const loadConfig = ({ cliConfig, serverConfig, resolvedConfigPath }) => {
-  let config = null;
-  if (process.env.NODE_ENV === "production") {
-    const resolvedConfig = requireConfig(resolvedConfigPath);
-    config = mergeDeep({
-      ...resolvedConfig,
-      plugins: []
-    }, serverConfig, cliConfig);
-  } else {
-    config = mergeDeep({
-      ...cliConfig,
-      plugins: []
-    }, serverConfig);
-  }
-  return config;
-};
-export {
-  getServerConfigPath,
-  loadConfig,
-  requireConfig
-};

package/dist/esm-node/libs/metrics.js

@@ -1,9 +0,0 @@
-const metrics = {
-  emitCounter() {
-  },
-  emitTimer() {
-  }
-};
-export {
-  metrics
-};

package/dist/esm-node/libs/preload/flushServerHeader.js

@@ -1,25 +0,0 @@
-import { parseLinks } from "./parseLinks";
-import { transformLinks2String } from "./transformLinks2String";
-async function flushServerHeader({ serverConf, ctx, distDir, template, headers }) {
-  const { ssr: ssrConf } = serverConf || {};
-  if (typeof ssrConf !== "object") {
-    return;
-  }
-  const { res } = ctx;
-  const links = await parseLinks({
-    template,
-    distDir,
-    pathname: ctx.path
-  });
-  const link = transformLinks2String(links, ssrConf.preload);
-  res.set("link", link);
-  for (const key in headers || {}) {
-    const value = headers === null || headers === void 0 ? void 0 : headers[key];
-    value && res.set(key, value);
-  }
-  res.flushHeaders();
-  res.modernFlushedHeaders = true;
-}
-export {
-  flushServerHeader
-};

package/dist/esm-node/libs/preload/index.js

@@ -1,2 +0,0 @@
-export * from "./parseLinks";
-export * from "./flushServerHeader";

package/dist/esm-node/libs/preload/parseLinks.js

@@ -1,90 +0,0 @@
-import path from "path";
-import { NESTED_ROUTE_SPEC_FILE, ROUTE_MANIFEST_FILE, ROUTE_SPEC_FILE, fs } from "@modern-js/utils";
-import { parse as htmlParse } from "node-html-parser";
-import { matchRoutes } from "@modern-js/runtime-utils/remix-router";
-import { matchEntry } from "@modern-js/runtime-utils/node";
-async function parseLinks({ pathname, distDir, template }) {
-  const links = await parseLinksFromRoutes(pathname, distDir);
-  return links.concat(parseLinksFromHtml(template));
-}
-function parseLinksFromHtml(html) {
-  const root = htmlParse(html);
-  const scripts = root.querySelectorAll("script").filter((elem) => Boolean(elem.getAttribute("src")));
-  const css = root.querySelectorAll("link").filter((elem) => {
-    const href = elem.getAttribute("href");
-    const rel = elem.getAttribute("rel");
-    return href && rel === "stylesheet";
-  });
-  const images = root.querySelectorAll("img").filter((elem) => Boolean(elem.getAttribute("src")));
-  return scripts.map((elem) => {
-    const src = elem.getAttribute("src");
-    return {
-      uri: src,
-      as: "script"
-    };
-  }).concat(css.map((elem) => {
-    const href = elem.getAttribute("href");
-    return {
-      uri: href,
-      as: "style"
-    };
-  })).concat(images.map((elem) => {
-    const src = elem.getAttribute("src");
-    return {
-      uri: src,
-      as: "image"
-    };
-  }));
-}
-async function parseLinksFromRoutes(pathname, distDir) {
-  const noopLinks = [];
-  const nestedRoutesSpec = path.join(distDir, NESTED_ROUTE_SPEC_FILE);
-  const routesJsonPath = path.join(distDir, ROUTE_SPEC_FILE);
-  const routeManifestPath = path.join(distDir, ROUTE_MANIFEST_FILE);
-  if (!fs.existsSync(nestedRoutesSpec) || !fs.existsSync(routesJsonPath) || !fs.existsSync(routeManifestPath)) {
-    return noopLinks;
-  }
-  const routesJson = await import(routesJsonPath);
-  const serverRoutes = routesJson.routes;
-  const entry = matchEntry(pathname, serverRoutes);
-  if (entry) {
-    var _routeAssets_entryName, _assets_filter, _assets_filter1;
-    const routes = await import(nestedRoutesSpec);
-    const { entryName } = entry;
-    if (!entryName) {
-      return noopLinks;
-    }
-    const entryRoutes = routes[entryName];
-    if (!entryRoutes) {
-      return noopLinks;
-    }
-    const routesManifest = await import(routeManifestPath);
-    const { routeAssets } = routesManifest;
-    const matches = matchRoutes(entryRoutes, pathname, entry.urlPath);
-    const entryAssets = (_routeAssets_entryName = routeAssets[entryName]) === null || _routeAssets_entryName === void 0 ? void 0 : _routeAssets_entryName.assets;
-    const assets = matches === null || matches === void 0 ? void 0 : matches.reduce((acc, match) => {
-      const routeId = match.route.id;
-      if (routeId) {
-        const matchedManifest = routeAssets[routeId];
-        const assets2 = matchedManifest === null || matchedManifest === void 0 ? void 0 : matchedManifest.assets;
-        if (Array.isArray(assets2)) {
-          acc.push(...assets2);
-        }
-      }
-      return acc;
-    }, []).concat(entryAssets || []);
-    const cssLinks = assets === null || assets === void 0 ? void 0 : (_assets_filter = assets.filter((asset) => asset.endsWith(".css"))) === null || _assets_filter === void 0 ? void 0 : _assets_filter.map((uri) => ({
-      uri,
-      as: "style"
-    }));
-    const scriptLinks = assets === null || assets === void 0 ? void 0 : (_assets_filter1 = assets.filter((asset) => asset.endsWith(".js"))) === null || _assets_filter1 === void 0 ? void 0 : _assets_filter1.map((uri) => ({
-      uri,
-      as: "script"
-    }));
-    return (cssLinks || []).concat(scriptLinks || []);
-  }
-  return noopLinks;
-}
-export {
-  parseLinks
-};