@modern-js/prod-server 2.48.6 → 2.49.1

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

@@ -1,27 +0,0 @@
-function transformToRegExp(input) {
-  if (typeof input === "string") {
-    return new RegExp(input);
-  }
-  return input;
-}
-function shouldFlushServerHeader(serverConf, userAgent, disablePreload) {
-  const { ssr: ssrConf } = serverConf || {};
-  if (disablePreload) {
-    return false;
-  }
-  if (typeof ssrConf === "object" && ssrConf.preload) {
-    if (typeof ssrConf.preload === "object") {
-      const { userAgentFilter } = ssrConf.preload;
-      if (userAgentFilter && userAgent) {
-        return !transformToRegExp(userAgentFilter).test(userAgent);
-      }
-      return true;
-    }
-    return true;
-  }
-  return false;
-}
-export {
-  shouldFlushServerHeader,
-  transformToRegExp
-};

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

@@ -1,126 +0,0 @@
-import { transformToRegExp } from "./shouldFlushServerHeader";
-function transformLinks2String(links, preload) {
-  if (typeof preload === "boolean") {
-    return transformLinkToString(dedup(links));
-  }
-  const { include, exclude, attributes } = preload;
-  const resolveLinks = transformLinkToString(addAttributes(dedup(removeExclude(addInclude(links, include), exclude)), attributes));
-  return resolveLinks;
-}
-function addInclude(links, include) {
-  const images = [
-    "gif",
-    "jpg",
-    "jpeg",
-    "png",
-    "webp",
-    "bmp",
-    "tiff",
-    "anpg",
-    "ico"
-  ];
-  const videos = [
-    "mp4",
-    "webm",
-    "ogm",
-    "ogv",
-    "ogg"
-  ];
-  const fonts = [
-    "woff",
-    "woff2",
-    "eot",
-    "ttf",
-    "otf"
-  ];
-  const includes = (include === null || include === void 0 ? void 0 : include.map((item) => {
-    if (typeof item === "string") {
-      const type = (() => {
-        if (item.endsWith(".js")) {
-          return "script";
-        }
-        if (item.endsWith(".css")) {
-          return "style";
-        }
-        if (images.some((image) => item.endsWith(`.${image}`))) {
-          return "image";
-        }
-        if (videos.some((video) => item.endsWith(`.${video}`))) {
-          return "video";
-        }
-        if (fonts.some((font) => item.endsWith(`.${font}`))) {
-          return "font";
-        }
-      })();
-      return {
-        uri: item,
-        as: type
-      };
-    }
-    return {
-      uri: item.url,
-      as: item.as,
-      rel: item.rel
-    };
-  })) || [];
-  return links.concat(includes);
-}
-function removeExclude(links, exclude) {
-  return exclude ? links.filter(({ uri }) => !transformToRegExp(exclude).test(uri)) : links;
-}
-function addAttributes(links, attributes) {
-  const parseAttributes = (_attributes) => {
-    return Object.entries(_attributes || {}).reduce((results, [key, value]) => {
-      if (typeof value === "boolean") {
-        value && results.push(`; ${key}`);
-        return results;
-      }
-      results.push(`; ${key}=${value}`);
-      return results;
-    }, []).join("");
-  };
-  return links.map((link) => {
-    const { as } = link;
-    if (as) {
-      const attributesStr = (() => {
-        const { style, script, image, font } = attributes || {};
-        switch (as) {
-          case "script":
-            return parseAttributes(script);
-          case "style":
-            return parseAttributes(style);
-          case "image":
-            return parseAttributes(image);
-          case "font":
-            return parseAttributes(font);
-          default:
-            return "";
-        }
-      })();
-      return {
-        ...link,
-        rest: attributesStr
-      };
-    }
-    return link;
-  });
-}
-function dedup(links) {
-  const set = /* @__PURE__ */ new Set();
-  return links.filter(({ uri }) => {
-    if (set.has(uri)) {
-      return false;
-    }
-    set.add(uri);
-    return true;
-  });
-}
-function transformLinkToString(links) {
-  return links.map(({ uri, as, rel: originalRel, rest }) => {
-    const rel = originalRel || "preload";
-    return as ? `<${uri}>; rel=${rel}; as=${as}${rest || ""}` : `<${uri}>; rel=${rel}${rest || ""}`;
-  }).join(", ");
-}
-export {
-  transformLinks2String
-};

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

@@ -1,74 +0,0 @@
-import { HttpProxyMiddleware } from "http-proxy-middleware/dist/http-proxy-middleware";
-import { debug } from "../utils";
-function formatProxyOptions(proxyOptions) {
-  const ret = [];
-  if (Array.isArray(proxyOptions)) {
-    ret.push(...proxyOptions);
-  } else if ("target" in proxyOptions) {
-    ret.push(proxyOptions);
-  } else {
-    for (const [context, options] of Object.entries(proxyOptions)) {
-      const opts = {
-        context,
-        changeOrigin: true,
-        logLevel: "warn"
-      };
-      if (typeof options === "string") {
-        opts.target = options;
-      } else {
-        Object.assign(opts, options);
-      }
-      ret.push(opts);
-    }
-  }
-  const handleError = (err, _req, _res, _target) => {
-    console.error(err);
-  };
-  for (const opts of ret) {
-    var _opts;
-    var _onError;
-    (_onError = (_opts = opts).onError) !== null && _onError !== void 0 ? _onError : _opts.onError = handleError;
-  }
-  return ret;
-}
-const createProxyHandler = (proxyOptions) => {
-  debug("createProxyHandler", proxyOptions);
-  const formattedOptionsList = formatProxyOptions(proxyOptions);
-  const proxies = [];
-  const handlers = [];
-  for (const opts of formattedOptionsList) {
-    const proxy = new HttpProxyMiddleware(opts.context, opts);
-    const handler = async (ctx, next) => {
-      const { req, res } = ctx;
-      const bypassUrl = typeof opts.bypass === "function" ? opts.bypass(req, res, opts) : null;
-      if (typeof bypassUrl === "boolean") {
-        ctx.status = 404;
-        next();
-      } else if (typeof bypassUrl === "string") {
-        ctx.url = bypassUrl;
-        next();
-      } else {
-        proxy.middleware(req, res, next);
-      }
-    };
-    proxies.push(proxy);
-    handlers.push(handler);
-  }
-  const handleUpgrade = (server) => {
-    for (const proxy of proxies) {
-      const raw = proxy;
-      if (raw.proxyOptions.ws === true && !raw.wsInternalSubscribed) {
-        server.on("upgrade", raw.handleUpgrade);
-        raw.wsInternalSubscribed = true;
-      }
-    }
-  };
-  return {
-    handlers,
-    handleUpgrade
-  };
-};
-export {
-  createProxyHandler,
-  formatProxyOptions
-};

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

@@ -1,75 +0,0 @@
-import path from "path";
-import { cutNameByHyphen, mime } from "@modern-js/utils";
-import { fileReader } from "@modern-js/runtime-utils/fileReader";
-import { ERROR_DIGEST } from "../../constants";
-import { shouldFlushServerHeader } from "../preload/shouldFlushServerHeader";
-import { handleDirectory } from "./static";
-import * as ssr from "./ssr";
-import { injectServerData } from "./utils";
-const calcFallback = (metaName) => `x-${cutNameByHyphen(metaName)}-ssr-fallback`;
-const createRenderHandler = ({ distDir, staticGenerate, conf, forceCSR, nonce, ssrRender, metaName = "modern-js" }) => async function render({ ctx, route, runner }) {
-  if (ctx.resHasHandled()) {
-    return null;
-  }
-  const { entryPath, urlPath } = route;
-  const entry = path.join(distDir, entryPath);
-  if (!route.isSPA) {
-    const result = await handleDirectory(ctx, entry, urlPath);
-    return result;
-  }
-  const templatePath = entry;
-  const content = await fileReader.readFile(templatePath);
-  if (!content) {
-    return null;
-  }
-  const queryCSR = ctx.query.csr;
-  const headerFallback = ctx.headers[calcFallback(metaName)];
-  const useCSR = forceCSR && (queryCSR || headerFallback);
-  if (route.isSSR && !useCSR) {
-    try {
-      const userAgent = ctx.getReqHeader("User-Agent");
-      const disablePreload = Boolean(ctx.headers[`x-${cutNameByHyphen(metaName)}-disable-preload`]);
-      if (shouldFlushServerHeader(conf.server, userAgent, disablePreload)) {
-        const { flushServerHeader } = await import("../preload");
-        flushServerHeader({
-          serverConf: conf.server,
-          ctx,
-          distDir,
-          template: content.toString(),
-          headers: {
-            "Content-Type": mime.contentType(path.extname(templatePath))
-          }
-        });
-      }
-      const ssrRenderOptions = {
-        distDir,
-        route,
-        template: content.toString(),
-        staticGenerate,
-        nonce
-      };
-      const result = await (ssrRender ? ssrRender(ctx, ssrRenderOptions, runner) : ssr.render(ctx, ssrRenderOptions, runner));
-      return result;
-    } catch (err) {
-      ctx.error(ERROR_DIGEST.ERENDER, err.stack || err.message);
-      ctx.res.set(calcFallback(metaName), "1");
-      await runner.handleSSRFallback({
-        ctx,
-        type: "error"
-      });
-    }
-  } else if (route.isSSR && useCSR) {
-    const fallbackType = queryCSR ? "query" : "header";
-    await runner.handleSSRFallback({
-      ctx,
-      type: fallbackType
-    });
-  }
-  return {
-    content: route.entryName ? injectServerData(content.toString(), ctx) : content,
-    contentType: mime.contentType(path.extname(templatePath))
-  };
-};
-export {
-  createRenderHandler
-};

package/dist/esm-node/libs/render/measure.js

@@ -1,49 +0,0 @@
-import { headersWithoutCookie } from "../../utils";
-const createMetrics = (context, metrics) => {
-  const { entryName: entry, request } = context;
-  const { pathname = "" } = request || {};
-  const emitTimer = (name, cost, tags = {}) => {
-    metrics.emitTimer(name, cost, void 0, {
-      ...tags,
-      pathname,
-      entry
-    });
-  };
-  const emitCounter = (name, counter, tags = {}) => {
-    metrics.emitCounter(name, counter, void 0, {
-      ...tags,
-      pathname,
-      entry
-    });
-  };
-  return {
-    emitTimer,
-    emitCounter
-  };
-};
-const createLogger = (serverContext, logger) => {
-  const request = serverContext.request || {};
-  const { headers = {}, pathname = "" } = request;
-  const debug = (message, ...args) => {
-    logger.debug(`SSR Debug - ${message}, req.url = %s`, ...args, pathname);
-  };
-  const info = (message, ...args) => {
-    logger.info(`SSR Info - ${message}, req.url = %s`, ...args, pathname);
-  };
-  const error = (message, e) => {
-    if (!e) {
-      e = message;
-      message = "";
-    }
-    logger.error(`SSR Error - ${message}, error = %s, req.url = %s, req.headers = %o`, e instanceof Error ? e.stack || e.message : e, pathname, headersWithoutCookie(headers));
-  };
-  return {
-    error,
-    info,
-    debug
-  };
-};
-export {
-  createLogger,
-  createMetrics
-};

package/dist/esm-node/libs/render/ssr.js

@@ -1,96 +0,0 @@
-import path from "path";
-import { fs, mime, LOADABLE_STATS_FILE, ROUTE_MANIFEST_FILE, SERVER_RENDER_FUNCTION_NAME } from "@modern-js/utils";
-import * as isbot from "isbot";
-import { createAfterStreamingRenderContext } from "../hook-api";
-import { afterRenderInjectableStream } from "../hook-api/afterRenderForStream";
-import { createLogger, createMetrics } from "./measure";
-import { injectServerDataStream, injectServerData } from "./utils";
-import { ssrCache } from "./ssrCache";
-const render = async (ctx, renderOptions, runner) => {
-  var _ctx_res;
-  const { distDir, route, template, staticGenerate, enableUnsafeCtx = false, nonce } = renderOptions;
-  const { urlPath, bundle, entryName } = route;
-  const bundleJS = path.join(distDir, bundle);
-  const loadableUri = path.join(distDir, LOADABLE_STATS_FILE);
-  const loadableStats = fs.existsSync(loadableUri) ? require(loadableUri) : "";
-  const routesManifestUri = path.join(distDir, ROUTE_MANIFEST_FILE);
-  const routeManifest = fs.existsSync(routesManifestUri) ? require(routesManifestUri) : void 0;
-  const isSpider = isbot.default(ctx.headers["user-agent"] || null);
-  const context = {
-    request: {
-      baseUrl: urlPath,
-      params: ctx.params,
-      pathname: ctx.path,
-      host: ctx.host,
-      query: ctx.query,
-      url: ctx.href,
-      headers: ctx.headers
-    },
-    response: {
-      setHeader: (key, value) => {
-        return ctx.res.setHeader(key, value);
-      },
-      status: (code) => {
-        ctx.res.statusCode = code;
-      },
-      locals: ((_ctx_res = ctx.res) === null || _ctx_res === void 0 ? void 0 : _ctx_res.locals) || {}
-    },
-    redirection: {},
-    template,
-    loadableStats,
-    routeManifest,
-    entryName,
-    staticGenerate,
-    logger: void 0,
-    metrics: void 0,
-    reporter: ctx.reporter,
-    serverTiming: ctx.serverTiming,
-    req: ctx.req,
-    res: ctx.res,
-    enableUnsafeCtx,
-    isSpider,
-    nonce
-  };
-  context.logger = createLogger(context, ctx.logger);
-  context.metrics = createMetrics(context, ctx.metrics);
-  runner.extendSSRContext(context);
-  const bundleJSContent = await Promise.resolve(require(bundleJS));
-  const serverRender = bundleJSContent[SERVER_RENDER_FUNCTION_NAME];
-  const { data: content, status: cacheStatus } = await ssrCache(ctx.req, serverRender, context);
-  const { url, status = 302 } = context.redirection;
-  if (url) {
-    return {
-      content: url,
-      contentType: "",
-      statusCode: status,
-      redirect: true
-    };
-  }
-  const headers = {};
-  cacheStatus && (headers["x-render-cache"] = cacheStatus);
-  if (typeof content === "string") {
-    return {
-      content: injectServerData(content, ctx),
-      contentType: mime.contentType("html"),
-      headers
-    };
-  } else {
-    let contentStream = injectServerDataStream(content, ctx);
-    const afterStreamingRenderContext = createAfterStreamingRenderContext(ctx, route);
-    contentStream = contentStream.pipe(afterRenderInjectableStream((chunk) => {
-      const context2 = afterStreamingRenderContext(chunk);
-      return runner.afterStreamingRender(context2, {
-        onLast: ({ chunk: chunk2 }) => chunk2
-      });
-    }));
-    return {
-      content: "",
-      contentStream,
-      contentType: mime.contentType("html"),
-      headers
-    };
-  }
-};
-export {
-  render
-};

package/dist/esm-node/libs/render/ssrCache/cacheMod.js

@@ -1,17 +0,0 @@
-import path from "path";
-import { SERVER_DIR, requireExistModule } from "@modern-js/utils";
-const CACHE_FILENAME = "cache";
-class ServerCacheMod {
-  loadServerCacheMod(pwd = process.cwd()) {
-    const serverCacheFilepath = path.resolve(pwd, SERVER_DIR, CACHE_FILENAME);
-    const mod = requireExistModule(serverCacheFilepath, {
-      interop: false
-    });
-    this.customContainer = mod === null || mod === void 0 ? void 0 : mod.customContainer;
-    this.cacheOption = mod === null || mod === void 0 ? void 0 : mod.cacheOption;
-  }
-}
-const cacheMod = new ServerCacheMod();
-export {
-  cacheMod
-};

package/dist/esm-node/libs/render/ssrCache/index.js

@@ -1,66 +0,0 @@
-import { Transform } from "stream";
-import { createMemoryStorage } from "@modern-js/runtime-utils/storer";
-import { cacheMod } from "./cacheMod";
-import { CacheManager } from "./manager";
-const cacheStorage = createMemoryStorage("__ssr__cache");
-async function ssrCache(req, render, ssrContext) {
-  const { customContainer, cacheOption } = cacheMod;
-  const cacheControl = await matchCacheControl(req, cacheOption);
-  const cacheManager = new CacheManager(customContainer ? customContainer : cacheStorage);
-  if (cacheControl) {
-    return cacheManager.getCacheResult(req, cacheControl, render, ssrContext);
-  } else {
-    const renderResult = await render(ssrContext);
-    if (!renderResult) {
-      return {
-        data: ""
-      };
-    } else if (typeof renderResult === "string") {
-      return {
-        data: renderResult
-      };
-    } else {
-      const stream = new Transform({
-        write(chunk, _, callback) {
-          this.push(chunk);
-          callback();
-        }
-      });
-      const data = await renderResult(stream);
-      return {
-        data
-      };
-    }
-  }
-}
-async function matchCacheControl(req, cacheOption) {
-  if (!cacheOption) {
-    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;
-  }
-}
-export {
-  ssrCache
-};

package/dist/esm-node/libs/render/ssrCache/manager.js

@@ -1,96 +0,0 @@
-import { Transform } from "stream";
-import { normalizePathname } from "@modern-js/runtime-utils/url";
-class CacheManager {
-  async getCacheResult(req, cacheControl, render, ssrContext) {
-    const key = this.computedKey(req, cacheControl);
-    const value = await this.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) {
-        this.processCache(key, render, ssrContext, ttl);
-        return {
-          data: cache.val,
-          status: "stale"
-        };
-      } else {
-        return this.processCache(key, render, ssrContext, ttl, "expired");
-      }
-    } else {
-      return this.processCache(key, render, ssrContext, ttl, "miss");
-    }
-  }
-  async processCache(key, render, ssrContext, ttl, 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 this.container.set(key, JSON.stringify(cache), {
-        ttl
-      });
-      return {
-        data: renderResult,
-        status
-      };
-    } else {
-      let html = "";
-      const stream = new Transform({
-        write(chunk, _, callback) {
-          html += chunk.toString();
-          this.push(chunk);
-          callback();
-        }
-      });
-      stream.on("close", () => {
-        const current = Date.now();
-        const cache = {
-          val: html,
-          cursor: current
-        };
-        this.container.set(key, JSON.stringify(cache), {
-          ttl
-        });
-      });
-      const readable = await renderResult(stream);
-      return {
-        data: readable,
-        status
-      };
-    }
-  }
-  computedKey(req, cacheControl) {
-    const { url } = req;
-    const [pathname] = url.split("?");
-    const { customKey } = cacheControl;
-    const defaultKey = normalizePathname(pathname);
-    if (customKey) {
-      if (typeof customKey === "string") {
-        return customKey;
-      } else {
-        return customKey(defaultKey);
-      }
-    } else {
-      return defaultKey;
-    }
-  }
-  constructor(container) {
-    this.container = container;
-  }
-}
-export {
-  CacheManager
-};

package/dist/esm-node/libs/render/static.js

@@ -1,38 +0,0 @@
-import path from "path";
-import { mime } from "@modern-js/utils";
-import { fileReader } from "@modern-js/runtime-utils/fileReader";
-async function handleDirectory(ctx, entryPath, urlPath) {
-  const { path: pathname } = ctx;
-  const filepath = path.join(entryPath, trimLeft(pathname, urlPath));
-  let content = await fileReader.readFile(filepath);
-  let contentType = mime.contentType(path.extname(filepath) || "");
-  if (!content) {
-    if (pathname.endsWith("/")) {
-      content = await fileReader.readFile(`${filepath}index.html`);
-    } else if (!pathname.includes(".")) {
-      content = await fileReader.readFile(`${filepath}.html`);
-      if (!content) {
-        content = await fileReader.readFile(`${filepath}/index.html`);
-      }
-    }
-    if (content) {
-      contentType = mime.contentType("html");
-    }
-  }
-  if (!content) {
-    return null;
-  }
-  return {
-    content,
-    contentType: contentType || ""
-  };
-}
-const trimLeft = (str, prefix) => {
-  if (str.startsWith(prefix)) {
-    return str.substring(prefix.length);
-  }
-  return str;
-};
-export {
-  handleDirectory
-};

package/dist/esm-node/libs/render/type.js

@@ -1,9 +0,0 @@
-var RenderLevel;
-(function(RenderLevel2) {
-  RenderLevel2[RenderLevel2["CLIENT_RENDER"] = 0] = "CLIENT_RENDER";
-  RenderLevel2[RenderLevel2["SERVER_PREFETCH"] = 1] = "SERVER_PREFETCH";
-  RenderLevel2[RenderLevel2["SERVER_RENDER"] = 2] = "SERVER_RENDER";
-})(RenderLevel || (RenderLevel = {}));
-export {
-  RenderLevel
-};

package/dist/esm-node/libs/render/utils.js

@@ -1,16 +0,0 @@
-import { TemplateAPI } from "../hook-api/template";
-import { templateInjectableStream } from "../hook-api/templateForStream";
-const injectServerData = (content, context) => {
-  const template = new TemplateAPI(content);
-  template.prependHead(`<script type="application/json" id="__MODERN_SERVER_DATA__">${JSON.stringify(context.serverData)}</script>`);
-  return template.get();
-};
-const injectServerDataStream = (content, context) => {
-  return content.pipe(templateInjectableStream({
-    prependHead: `<script type="application/json" id="__MODERN_SERVER_DATA__">${JSON.stringify(context.serverData)}</script>`
-  }));
-};
-export {
-  injectServerData,
-  injectServerDataStream
-};