@modern-js/prod-server 2.42.2 → 2.44.0

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

@@ -1,247 +0,0 @@
-"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 spr_exports = {};
-__export(spr_exports, {
-  createCache: () => createCache,
-  destroyCache: () => destroyCache
-});
-module.exports = __toCommonJS(spr_exports);
-var import_define_property = require("@swc/helpers/_/_define_property");
-var import_crypto = __toESM(require("crypto"));
-var import_lru_cache = __toESM(require("lru-cache"));
-var import_utils = require("@modern-js/utils");
-var import_util = require("./util");
-var import_page_caches = require("./page-caches");
-const MAX_CACHE_EACH_REQ = Number(process.env.ROUTE_CACHE_LIMIT) || 10;
-const MAX_SIZE_EACH_CLUSTER = Number(process.env.CLUSTER_CACHE_LIMIT) || 100;
-const BASE_LEVEL = 0;
-const QUERY_LEVEL = 1;
-const HEADER_LEVEL = 2;
-const QUERY_HEADER_LEVEL = 3;
-class CacheManager {
-  md5(content) {
-    const md5 = import_crypto.default.createHash("md5");
-    return md5.update(content).digest("hex");
-  }
-  generateRequestKey(context) {
-    const { pathname, entry } = context;
-    return this.md5(`${pathname}_${entry}`);
-  }
-  replaceValue(value, matcher) {
-    let final = value;
-    Object.keys(matcher).some((replacer) => {
-      const reg = new RegExp(matcher[replacer]);
-      if (reg.test(value)) {
-        final = replacer;
-        return true;
-      }
-      return false;
-    });
-    return final;
-  }
-  factor(keys, obj, matches = {}) {
-    keys.sort();
-    const getValue = (0, import_util.valueFactory)(obj);
-    const factorAry = keys.reduce((ary, key) => {
-      let value = getValue(key) || "";
-      const matcher = matches[key];
-      if (matcher) {
-        value = this.replaceValue(value, matcher);
-      }
-      return ary.concat([
-        key,
-        value
-      ]);
-    }, []);
-    return factorAry.join(",");
-  }
-  queryFactor(context, data) {
-    var _data_includes, _data_matches;
-    const queryKeys = (_data_includes = data.includes) === null || _data_includes === void 0 ? void 0 : _data_includes.query;
-    const queryMatches = (_data_matches = data.matches) === null || _data_matches === void 0 ? void 0 : _data_matches.query;
-    if (!queryKeys || queryKeys.length === 0) {
-      return null;
-    }
-    const requestQuery = context.query;
-    const queryFactor = this.factor(queryKeys, requestQuery, queryMatches);
-    return queryFactor;
-  }
-  headerFactor(context, data) {
-    var _data_includes, _data_matches;
-    const headerKeys = (_data_includes = data.includes) === null || _data_includes === void 0 ? void 0 : _data_includes.header;
-    const headerMatches = (_data_matches = data.matches) === null || _data_matches === void 0 ? void 0 : _data_matches.header;
-    if (!headerKeys || headerKeys.length === 0) {
-      return null;
-    }
-    const requestHeader = context.headers;
-    const headerFactor = this.factor(headerKeys, requestHeader, headerMatches);
-    return headerFactor;
-  }
-  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 {
-      level: config.level,
-      interval: config.interval,
-      includes: config.includes || null,
-      limit: config.staleLimit,
-      matches: config.matches || null,
-      caches
-    };
-  }
-  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
-    };
-  }
-  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
-      });
-      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);
-  }
-  async del(context, cacheHash) {
-    const cacheKey = this.generateRequestKey(context);
-    const data = this.cache.get(cacheKey);
-    data === null || data === void 0 ? void 0 : data.caches.del(cacheHash);
-  }
-  constructor(cacheOptions) {
-    (0, import_define_property._)(this, "cache", void 0);
-    (0, import_define_property._)(this, "cacheOptions", void 0);
-    (0, import_define_property._)(this, "find", (() => {
-      {
-        const _this = this;
-        return {
-          [(0, import_util.fname)(BASE_LEVEL)](context, cacheKey) {
-            return _this.md5(cacheKey);
-          },
-          [(0, import_util.fname)(QUERY_LEVEL)](context, cacheKey, data) {
-            const queryFactor = _this.queryFactor(context, data);
-            if (!queryFactor) {
-              return null;
-            }
-            return _this.md5((0, import_util.connectFactor)(cacheKey, queryFactor));
-          },
-          [(0, import_util.fname)(HEADER_LEVEL)](context, cacheKey, data) {
-            const headerFactor = _this.headerFactor(context, data);
-            if (!headerFactor) {
-              return null;
-            }
-            return _this.md5((0, import_util.connectFactor)(cacheKey, headerFactor));
-          },
-          [(0, import_util.fname)(QUERY_HEADER_LEVEL)](context, cacheKey, data) {
-            const queryFactor = _this.queryFactor(context, data);
-            const headerFactor = _this.headerFactor(context, data);
-            if (!queryFactor || !headerFactor) {
-              return null;
-            }
-            return _this.md5((0, import_util.connectFactor)(cacheKey, headerFactor, queryFactor));
-          }
-        };
-      }
-    })());
-    this.cacheOptions = cacheOptions;
-    this.cache = new import_lru_cache.default({
-      max: Math.min(MAX_SIZE_EACH_CLUSTER, 600) * 1024 * 1024,
-      length(n) {
-        const len = n.caches.keys().reduce((total, cur) => {
-          var _n_caches_peek;
-          return total + (((_n_caches_peek = n.caches.peek(cur)) === null || _n_caches_peek === void 0 ? void 0 : _n_caches_peek.size) || 0);
-        }, 1);
-        return len;
-      }
-    });
-  }
-}
-let manager;
-function createCache() {
-  if (manager) {
-    return manager;
-  }
-  manager = new CacheManager({
-    max: 0
-  });
-  return manager;
-}
-function destroyCache() {
-  manager = null;
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  createCache,
-  destroyCache
-});

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

@@ -1,16 +0,0 @@
-"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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var type_exports = {};
-module.exports = __toCommonJS(type_exports);

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

@@ -1,121 +0,0 @@
-"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 util_exports = {};
-__export(util_exports, {
-  cacheAddition: () => cacheAddition,
-  connectFactor: () => connectFactor,
-  fname: () => fname,
-  getTime: () => getTime,
-  maybeSync: () => maybeSync,
-  namespaceHash: () => namespaceHash,
-  valueFactory: () => valueFactory,
-  withCoalescedInvoke: () => withCoalescedInvoke
-});
-module.exports = __toCommonJS(util_exports);
-var import_url = __toESM(require("url"));
-function namespaceHash(namespace, hash) {
-  return `${namespace}/${hash}`;
-}
-function fname(lv) {
-  return `f${lv}`;
-}
-function connectFactor(...args) {
-  return args.join("-");
-}
-function valueFactory(obj) {
-  if (obj instanceof import_url.default.URLSearchParams) {
-    return function(key) {
-      return obj.get(key);
-    };
-  } else {
-    return function(key) {
-      const value = obj[key];
-      if (Array.isArray(value)) {
-        return value.join(",");
-      }
-      return value;
-    };
-  }
-}
-function getTime([s, ns]) {
-  return Math.floor(s * 1e3 + ns / 1e6);
-}
-const RE_START_IN_HEAD = /<head>/;
-function cacheAddition(html, hash) {
-  const additionHtml = html.replace(RE_START_IN_HEAD, `<head><meta name="x-moden-spr" content="${hash}">`);
-  return additionHtml;
-}
-const globalInvokeCache = /* @__PURE__ */ new Map();
-function withCoalescedInvoke(func) {
-  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) {
-  return (sync) => {
-    if (sync) {
-      return fn();
-    } else {
-      fn();
-      return Promise.resolve();
-    }
-  };
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  cacheAddition,
-  connectFactor,
-  fname,
-  getTime,
-  maybeSync,
-  namespaceHash,
-  valueFactory,
-  withCoalescedInvoke
-});

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

@@ -1,131 +0,0 @@
-"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 reader_exports = {};
-__export(reader_exports, {
-  LruReader: () => LruReader,
-  close: () => close,
-  init: () => init,
-  readFile: () => readFile,
-  updateFile: () => updateFile
-});
-module.exports = __toCommonJS(reader_exports);
-var import_define_property = require("@swc/helpers/_/_define_property");
-var import_utils = require("@modern-js/utils");
-var import_lru_cache = __toESM(require("lru-cache"));
-const Byte = 1;
-const KB = 1024 * Byte;
-const MB = 1024 * KB;
-const getContentLength = (cache) => cache.content.length;
-const createCacheItem = async (content, mtime) => {
-  return {
-    content,
-    mtime
-  };
-};
-class LruReader {
-  init(fs) {
-    this.fs = fs || import_utils.fs;
-  }
-  close() {
-  }
-  async read(filepath) {
-    const { fs } = this;
-    if (this.cache.has(filepath)) {
-      const { content: content2 } = this.cache.get(filepath);
-      return {
-        content: content2
-      };
-    }
-    if (!fs.existsSync(filepath)) {
-      return null;
-    }
-    const stat = fs.statSync(filepath);
-    if (stat.isDirectory()) {
-      return null;
-    }
-    if (stat.size > 20 * MB) {
-      return null;
-    }
-    const content = await fs.promises.readFile(filepath);
-    const item = await createCacheItem(content, stat.mtime);
-    this.cache.set(filepath, item);
-    return item;
-  }
-  update() {
-    const { cache, fs } = this;
-    const files = cache.keys();
-    for (const filepath of files) {
-      if (!fs.existsSync(filepath)) {
-        cache.del(filepath);
-      }
-      try {
-        const item = cache.get(filepath);
-        const stat = fs.statSync(filepath);
-        const { mtime } = stat;
-        if (item.mtime < mtime) {
-          cache.del(filepath);
-        }
-      } catch (e) {
-        cache.del(filepath);
-      }
-    }
-  }
-  constructor() {
-    (0, import_define_property._)(this, "cache", void 0);
-    (0, import_define_property._)(this, "fs", void 0);
-    this.cache = new import_lru_cache.default({
-      max: 256 * MB,
-      length: getContentLength,
-      maxAge: 5 * 60 * 5e3
-    });
-    this.fs = import_utils.fs;
-  }
-}
-const reader = new LruReader();
-const readFile = async (filepath) => {
-  const file = await reader.read(filepath);
-  return file === null || file === void 0 ? void 0 : file.content;
-};
-const updateFile = () => {
-  reader.update();
-};
-const init = (fs) => {
-  reader.init(fs);
-};
-const close = () => {
-  reader.close();
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  LruReader,
-  close,
-  init,
-  readFile,
-  updateFile
-});

package/dist/esm/libs/render/cache/__tests__/cache.fun.test.js

@@ -1,124 +0,0 @@
-import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
-import { _ as _sliced_to_array } from "@swc/helpers/_/_sliced_to_array";
-import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
-import url from "url";
-import { createCache, destroyCache } from "../spr";
-import { cacheAddition, connectFactor, fname, maybeSync, namespaceHash, valueFactory, withCoalescedInvoke } from "../util";
-describe("test spr util functions", function() {
-  it("should return value correctly", function() {
-    expect(connectFactor("bar", "foo")).toBe("bar-foo");
-    expect(fname(1)).toBe("f1");
-    expect(namespaceHash("modern", "!@#$%^&")).toBe("modern/!@#$%^&");
-  });
-  it("should create or destroy instance correctly", function() {
-    var ins1 = createCache();
-    var ins2 = createCache();
-    expect(ins1 === ins2).toBe(true);
-    destroyCache();
-    var ins3 = createCache();
-    expect(ins1 === ins3).toBe(false);
-    expect(ins2 === ins3).toBe(false);
-  });
-  it("should return function correctly", function() {
-    var urlParams = function() {
-      return new url.URLSearchParams();
-    }();
-    urlParams.set("name", "modern");
-    var getParam = valueFactory(urlParams);
-    expect(getParam("name")).toBe("modern");
-    var headers = {
-      age: "12345"
-    };
-    var getHeader = valueFactory(headers);
-    expect(getHeader("age")).toBe("12345");
-  });
-  it("should add target html content", function() {
-    var contentNoHead = "<div>123</div>";
-    var html = cacheAddition(contentNoHead, Math.random().toString());
-    expect(html).toBe(contentNoHead);
-    var contentWithHead = "<head></head><div>123</div>";
-    var hash = Math.random().toString();
-    var htmlWithHead = cacheAddition(contentWithHead, hash);
-    expect(htmlWithHead).toBe('<head><meta name="x-moden-spr" content="'.concat(hash, '"></head><div>123</div>'));
-  });
-  it("should only invoke func one time", /* @__PURE__ */ _async_to_generator(function() {
-    var index, fn, key, _ref, res1, res2;
-    return _ts_generator(this, function(_state) {
-      switch (_state.label) {
-        case 0:
-          index = 0;
-          fn = withCoalescedInvoke(/* @__PURE__ */ _async_to_generator(function() {
-            return _ts_generator(this, function(_state2) {
-              return [
-                2,
-                new Promise(function(resolve) {
-                  setTimeout(function() {
-                    index += 1;
-                    resolve(index);
-                  }, 500);
-                })
-              ];
-            });
-          }));
-          key = "test";
-          return [
-            4,
-            Promise.all([
-              fn(key, []),
-              fn(key, [])
-            ])
-          ];
-        case 1:
-          _ref = _sliced_to_array.apply(void 0, [
-            _state.sent(),
-            2
-          ]), res1 = _ref[0], res2 = _ref[1];
-          expect(res1.isOrigin && res2.isOrigin).toBe(false);
-          expect(res1.isOrigin || res2.isOrigin).toBe(true);
-          expect(res1.value).toBe(1);
-          expect(res2.value).toBe(1);
-          return [
-            2
-          ];
-      }
-    });
-  }));
-  it("should invoke sync or async", /* @__PURE__ */ _async_to_generator(function() {
-    var foo, async, sync;
-    return _ts_generator(this, function(_state) {
-      switch (_state.label) {
-        case 0:
-          foo = "";
-          return [
-            4,
-            maybeSync(function() {
-              return new Promise(function(resolve) {
-                setTimeout(function() {
-                  resolve(foo);
-                }, 100);
-              });
-            })(false)
-          ];
-        case 1:
-          async = _state.sent();
-          expect(async).toBeUndefined();
-          return [
-            4,
-            maybeSync(function() {
-              return new Promise(function(resolve) {
-                setTimeout(function() {
-                  resolve(foo);
-                }, 100);
-              });
-            })(true)
-          ];
-        case 2:
-          sync = _state.sent();
-          expect(sync).toBe(foo);
-          return [
-            2
-          ];
-      }
-    });
-  }));
-});