@modern-js/prod-server 2.42.2 → 2.43.0

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
-          ];
-      }
-    });
-  }));
-});