@modern-js/prod-server 2.4.1-beta.0 → 2.5.0

package/dist/cjs/libs/render/cache/index.js

@@ -0,0 +1,97 @@
+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 cache_exports = {};
+__export(cache_exports, {
+  default: () => cache_default
+});
+module.exports = __toCommonJS(cache_exports);
+var import_stream = require("stream");
+var import_constants = require("../../../constants");
+var import_spr = require("./spr");
+var import_util = require("./util");
+var cache_default = (renderFn, ctx) => {
+  const sprCache = (0, import_spr.createCache)();
+  const doRender = async (context) => {
+    const cacheContext = {
+      entry: context.entryName,
+      ...context.request
+    };
+    const cacheFile = await sprCache.get(cacheContext);
+    async function afterRender(source, onAfterRender) {
+      if (!source) {
+        return "";
+      }
+      if (typeof source === "string") {
+        await onAfterRender(source);
+        return source;
+      } else {
+        let htmlForStream = "";
+        const cacheStream = new import_stream.Transform({
+          write(chunk, _, callback) {
+            htmlForStream += chunk.toString();
+            this.push(chunk);
+            callback();
+          }
+        });
+        cacheStream.on("close", () => onAfterRender(htmlForStream));
+        return source(cacheStream);
+      }
+    }
+    async function saveHtmlIntoCache(html) {
+      const { cacheConfig } = context;
+      if (html && cacheConfig) {
+        await sprCache.set(cacheContext, html, cacheConfig);
+      }
+    }
+    if (!cacheFile) {
+      const renderResult = await renderFn(context);
+      return afterRender(renderResult, saveHtmlIntoCache);
+    }
+    const cacheHash = cacheFile == null ? void 0 : cacheFile.hash;
+    if (cacheFile.isGarbage) {
+      const renderResult = await renderFn(context);
+      return afterRender(renderResult, saveHtmlIntoCache);
+    } else if (cacheFile.isStale) {
+      const render = (0, import_util.withCoalescedInvoke)(() => renderFn(context)).bind(
+        null,
+        (0, import_util.namespaceHash)("render", cacheFile.hash),
+        []
+      );
+      render().then(async (res) => {
+        if (res.value && res.isOrigin) {
+          const { cacheConfig } = context;
+          if (cacheConfig) {
+            afterRender(res.value, async (html) => {
+              sprCache.set(cacheContext, html, cacheConfig);
+            });
+          } else {
+            sprCache.del(cacheContext, cacheHash);
+          }
+        }
+      }).catch((e) => {
+        sprCache.del(cacheContext, cacheHash);
+        ctx.error(import_constants.ERROR_DIGEST.ERENDER, e);
+      });
+    }
+    ctx.res.setHeader("x-modern-spr", "1");
+    return cacheFile.content;
+  };
+  return doRender;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {});

package/dist/cjs/libs/render/cache/page-caches/index.js

@@ -0,0 +1,33 @@
+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 page_caches_exports = {};
+__export(page_caches_exports, {
+  createPageCaches: () => createPageCaches
+});
+module.exports = __toCommonJS(page_caches_exports);
+var import_lru = require("./lru");
+async function createPageCaches(max) {
+  const constructorOptions = { max };
+  const cacheInstance = new import_lru.LRUCaches(constructorOptions);
+  await cacheInstance.init();
+  return cacheInstance;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createPageCaches
+});

package/dist/{js/node → cjs}/libs/render/cache/spr.js

@@ -21,26 +21,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var __async = (__this, __arguments, generator) => {
-  return new Promise((resolve, reject) => {
-    var fulfilled = (value) => {
-      try {
-        step(generator.next(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var rejected = (value) => {
-      try {
-        step(generator.throw(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
-    step((generator = generator.apply(__this, __arguments)).next());
-  });
-};
 var spr_exports = {};
 __export(spr_exports, {
   createCache: () => createCache,
@@ -159,15 +139,13 @@ class CacheManager {
     const headerFactor = this.factor(headerKeys, requestHeader, headerMatches);
     return headerFactor;
   }
-  best(context, cacheKey, data) {
-    return __async(this, null, function* () {
-      const { level } = data;
-      const cacheHash = this.find[(0, import_util.fname)(level)](context, cacheKey, data);
-      if (!cacheHash) {
-        return null;
-      }
-      return data.caches.get(cacheHash);
-    });
+  async best(context, cacheKey, data) {
+    const { level } = data;
+    const cacheHash = this.find[(0, import_util.fname)(level)](context, cacheKey, data);
+    if (!cacheHash) {
+      return null;
+    }
+    return data.caches.get(cacheHash);
   }
   createCacheContent(config, caches) {
     return {
@@ -179,77 +157,71 @@ class CacheManager {
       caches
     };
   }
-  get(context) {
-    return __async(this, null, function* () {
-      const cacheKey = this.generateRequestKey(context);
-      const data = this.cache.get(cacheKey);
-      if (!data) {
-        return null;
-      }
-      const dest = yield this.best(context, cacheKey, data);
-      if (!dest) {
-        return null;
-      }
-      const { expireTime, limitTime, html, cacheHash } = dest;
-      const isStale = Date.now() - expireTime > 0;
-      const isGarbage = limitTime ? Date.now() - limitTime > 0 : false;
-      return {
-        content: html || "",
-        contentType: import_utils.mime.contentType("html"),
-        isStale,
-        isGarbage,
-        hash: cacheHash
-      };
-    });
+  async get(context) {
+    const cacheKey = this.generateRequestKey(context);
+    const data = this.cache.get(cacheKey);
+    if (!data) {
+      return null;
+    }
+    const dest = await this.best(context, cacheKey, data);
+    if (!dest) {
+      return null;
+    }
+    const { expireTime, limitTime, html, cacheHash } = dest;
+    const isStale = Date.now() - expireTime > 0;
+    const isGarbage = limitTime ? Date.now() - limitTime > 0 : false;
+    return {
+      content: html || "",
+      contentType: import_utils.mime.contentType("html"),
+      isStale,
+      isGarbage,
+      hash: cacheHash
+    };
   }
-  set(context, html, cacheConfig, sync = false) {
-    return __async(this, null, function* () {
-      if (!cacheConfig) {
-        return false;
-      }
-      const cacheKey = this.generateRequestKey(context);
-      let data = this.cache.get(cacheKey);
-      if (!data) {
-        const caches = yield (0, import_page_caches.createPageCaches)(MAX_CACHE_EACH_REQ);
-        data = this.createCacheContent(cacheConfig, caches);
-      }
-      const cacheHash = this.find[(0, import_util.fname)(cacheConfig.level)](
-        context,
-        cacheKey,
-        data
-      );
-      if (!cacheHash) {
-        return false;
-      }
-      const cacheSyncOrAsync = () => __async(this, null, function* () {
-        const next = data;
-        const limit = cacheConfig.staleLimit;
-        const storeHTML = (0, import_util.cacheAddition)(html, cacheHash);
-        const size = storeHTML.length;
-        yield next.caches.set(cacheHash, {
-          expireTime: Date.now() + cacheConfig.interval * 1e3,
-          limitTime: typeof limit === "number" ? Date.now() + limit * 1e3 : null,
-          cacheHash,
-          html: storeHTML,
-          size
-        });
-        this.cache.set(cacheKey, next);
-        return true;
+  async set(context, html, cacheConfig, sync = false) {
+    if (!cacheConfig) {
+      return false;
+    }
+    const cacheKey = this.generateRequestKey(context);
+    let data = this.cache.get(cacheKey);
+    if (!data) {
+      const caches = await (0, import_page_caches.createPageCaches)(MAX_CACHE_EACH_REQ);
+      data = this.createCacheContent(cacheConfig, caches);
+    }
+    const cacheHash = this.find[(0, import_util.fname)(cacheConfig.level)](
+      context,
+      cacheKey,
+      data
+    );
+    if (!cacheHash) {
+      return false;
+    }
+    const cacheSyncOrAsync = async () => {
+      const next = data;
+      const limit = cacheConfig.staleLimit;
+      const storeHTML = (0, import_util.cacheAddition)(html, cacheHash);
+      const size = storeHTML.length;
+      await next.caches.set(cacheHash, {
+        expireTime: Date.now() + cacheConfig.interval * 1e3,
+        limitTime: typeof limit === "number" ? Date.now() + limit * 1e3 : null,
+        cacheHash,
+        html: storeHTML,
+        size
       });
-      const doCache = (0, import_util.withCoalescedInvoke)(cacheSyncOrAsync).bind(
-        null,
-        (0, import_util.namespaceHash)("stream", cacheHash),
-        []
-      );
-      return (0, import_util.maybeSync)(doCache)(sync);
-    });
+      this.cache.set(cacheKey, next);
+      return true;
+    };
+    const doCache = (0, import_util.withCoalescedInvoke)(cacheSyncOrAsync).bind(
+      null,
+      (0, import_util.namespaceHash)("stream", cacheHash),
+      []
+    );
+    return (0, import_util.maybeSync)(doCache)(sync);
   }
-  del(context, cacheHash) {
-    return __async(this, null, function* () {
-      const cacheKey = this.generateRequestKey(context);
-      const data = this.cache.get(cacheKey);
-      data == null ? void 0 : data.caches.del(cacheHash);
-    });
+  async del(context, cacheHash) {
+    const cacheKey = this.generateRequestKey(context);
+    const data = this.cache.get(cacheKey);
+    data == null ? void 0 : data.caches.del(cacheHash);
   }
 }
 let manager;

package/dist/{js/node → cjs}/libs/render/cache/util.js

@@ -21,26 +21,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var __async = (__this, __arguments, generator) => {
-  return new Promise((resolve, reject) => {
-    var fulfilled = (value) => {
-      try {
-        step(generator.next(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var rejected = (value) => {
-      try {
-        step(generator.throw(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
-    step((generator = generator.apply(__this, __arguments)).next());
-  });
-};
 var util_exports = {};
 __export(util_exports, {
   cacheAddition: () => cacheAddition,
@@ -91,28 +71,26 @@ function cacheAddition(html, hash) {
 }
 const globalInvokeCache = /* @__PURE__ */ new Map();
 function withCoalescedInvoke(func) {
-  return function(key, args) {
-    return __async(this, null, function* () {
-      const entry = globalInvokeCache.get(key);
-      if (entry) {
-        return entry.then((res) => ({
-          isOrigin: false,
-          value: res.value
-        }));
-      }
-      function __wrapper() {
-        return func(...args);
-      }
-      const future = __wrapper().then((res) => {
-        globalInvokeCache.delete(key);
-        return { isOrigin: true, value: res };
-      }).catch((err) => {
-        globalInvokeCache.delete(key);
-        throw err;
-      });
-      globalInvokeCache.set(key, future);
-      return future;
+  return async function(key, args) {
+    const entry = globalInvokeCache.get(key);
+    if (entry) {
+      return entry.then((res) => ({
+        isOrigin: false,
+        value: res.value
+      }));
+    }
+    function __wrapper() {
+      return func(...args);
+    }
+    const future = __wrapper().then((res) => {
+      globalInvokeCache.delete(key);
+      return { isOrigin: true, value: res };
+    }).catch((err) => {
+      globalInvokeCache.delete(key);
+      throw err;
     });
+    globalInvokeCache.set(key, future);
+    return future;
   };
 }
 function maybeSync(fn) {

package/dist/cjs/libs/render/index.js

@@ -0,0 +1,93 @@
+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(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var render_exports = {};
+__export(render_exports, {
+  createRenderHandler: () => createRenderHandler
+});
+module.exports = __toCommonJS(render_exports);
+var import_path = __toESM(require("path"));
+var import_utils = require("@modern-js/utils");
+var import_constants = require("../../constants");
+var import_static = require("./static");
+var import_reader = require("./reader");
+var ssr = __toESM(require("./ssr"));
+const createRenderHandler = ({
+  distDir,
+  staticGenerate,
+  forceCSR
+}) => async function render({
+  ctx,
+  route,
+  runner
+}) {
+  if (ctx.resHasHandled()) {
+    return null;
+  }
+  const { entryPath, urlPath } = route;
+  const entry = import_path.default.join(distDir, entryPath);
+  if (!route.isSPA) {
+    const result = await (0, import_static.handleDirectory)(ctx, entry, urlPath);
+    return result;
+  }
+  const templatePath = entry;
+  if (!import_utils.fs.existsSync(templatePath)) {
+    throw new Error(`Could not find template file: ${templatePath}`);
+  }
+  const content = await (0, import_reader.readFile)(templatePath);
+  if (!content) {
+    return null;
+  }
+  const useCSR = forceCSR && ctx.query.csr;
+  if (route.isSSR && !useCSR) {
+    try {
+      const result = await ssr.render(
+        ctx,
+        {
+          distDir,
+          entryName: route.entryName,
+          urlPath: route.urlPath,
+          bundle: route.bundle,
+          template: content.toString(),
+          staticGenerate
+        },
+        runner
+      );
+      return result;
+    } catch (err) {
+      ctx.error(
+        import_constants.ERROR_DIGEST.ERENDER,
+        err.stack || err.message
+      );
+      ctx.res.setHeader("x-modern-ssr-fallback", "1");
+    }
+  }
+  return {
+    content,
+    contentType: import_utils.mime.contentType(import_path.default.extname(templatePath))
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createRenderHandler
+});

package/dist/{js/node → cjs}/libs/render/measure.js

@@ -1,24 +1,7 @@
 var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -43,16 +26,18 @@ const createMetrics = (context, metrics) => {
   const { entryName: entry, request } = context;
   const { pathname = "" } = request || {};
   const emitTimer = (name, cost, tags = {}) => {
-    metrics.emitTimer(name, cost, __spreadProps(__spreadValues({}, tags), {
+    metrics.emitTimer(name, cost, {
+      ...tags,
       pathname,
       entry
-    }));
+    });
   };
   const emitCounter = (name, counter, tags = {}) => {
-    metrics.emitCounter(name, counter, __spreadProps(__spreadValues({}, tags), {
+    metrics.emitCounter(name, counter, {
+      ...tags,
       pathname,
       entry
-    }));
+    });
   };
   return { emitTimer, emitCounter };
 };

package/dist/{js/node → cjs}/libs/render/reader.js

@@ -21,26 +21,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var __async = (__this, __arguments, generator) => {
-  return new Promise((resolve, reject) => {
-    var fulfilled = (value) => {
-      try {
-        step(generator.next(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var rejected = (value) => {
-      try {
-        step(generator.throw(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
-    step((generator = generator.apply(__this, __arguments)).next());
-  });
-};
 var reader_exports = {};
 __export(reader_exports, {
   LruReader: () => LruReader,
@@ -56,13 +36,13 @@ const Byte = 1;
 const KB = 1024 * Byte;
 const MB = 1024 * KB;
 const getContentLength = (cache) => cache.content.length;
-const createCacheItem = (filepath, mtime) => __async(void 0, null, function* () {
-  const content = yield import_utils.fs.readFile(filepath);
+const createCacheItem = async (filepath, mtime) => {
+  const content = await import_utils.fs.readFile(filepath);
   return {
     content,
     mtime
   };
-});
+};
 class LruReader {
   constructor() {
     this.cache = new import_lru_cache.default({
@@ -75,26 +55,24 @@ class LruReader {
   }
   close() {
   }
-  read(filepath) {
-    return __async(this, null, function* () {
-      if (this.cache.has(filepath)) {
-        const { content } = this.cache.get(filepath);
-        return { content };
-      }
-      if (!import_utils.fs.existsSync(filepath)) {
-        return null;
-      }
-      const stat = import_utils.fs.statSync(filepath);
-      if (stat.isDirectory()) {
-        return null;
-      }
-      if (stat.size > 20 * MB) {
-        return null;
-      }
-      const item = yield createCacheItem(filepath, stat.mtime);
-      this.cache.set(filepath, item);
-      return item;
-    });
+  async read(filepath) {
+    if (this.cache.has(filepath)) {
+      const { content } = this.cache.get(filepath);
+      return { content };
+    }
+    if (!import_utils.fs.existsSync(filepath)) {
+      return null;
+    }
+    const stat = import_utils.fs.statSync(filepath);
+    if (stat.isDirectory()) {
+      return null;
+    }
+    if (stat.size > 20 * MB) {
+      return null;
+    }
+    const item = await createCacheItem(filepath, stat.mtime);
+    this.cache.set(filepath, item);
+    return item;
   }
   update() {
     const { cache } = this;
@@ -117,10 +95,10 @@ class LruReader {
   }
 }
 const reader = new LruReader();
-const readFile = (filepath) => __async(void 0, null, function* () {
-  const file = yield reader.read(filepath);
+const readFile = async (filepath) => {
+  const file = await reader.read(filepath);
   return file == null ? void 0 : file.content;
-});
+};
 const updateFile = () => {
   reader.update();
 };