@modern-js/runtime-utils 2.42.1 → 2.43.0

package/dist/cjs/node/fileReader.js

@@ -0,0 +1,93 @@
+"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 fileReader_exports = {};
+__export(fileReader_exports, {
+  FileReader: () => FileReader,
+  fileReader: () => fileReader
+});
+module.exports = __toCommonJS(fileReader_exports);
+var import_fs_extra = __toESM(require("@modern-js/utils/fs-extra"));
+var import_storer = require("./storer");
+class FileReader {
+  async readFile(path, encoding = "utf-8") {
+    const { fs } = this;
+    const cache = await this.storage.get(path);
+    if (cache === null) {
+      return null;
+    }
+    if (cache) {
+      return this.encodingContent(cache, encoding);
+    }
+    const isExistFile = await new Promise((resolve) => {
+      fs.stat(path, (err, stats) => {
+        if (err) {
+          resolve(false);
+          return;
+        }
+        if (stats.isFile()) {
+          resolve(true);
+        } else {
+          resolve(false);
+        }
+      });
+    });
+    if (isExistFile) {
+      const content = await fs.promises.readFile(path);
+      this.storage.set(path, content);
+      return this.encodingContent(content, encoding);
+    } else {
+      this.storage.set(path, null);
+      return null;
+    }
+  }
+  /**
+  * Clear the fileCache entriely.
+  */
+  reset(fs) {
+    var _this_storage_clear, _this_storage;
+    fs && (this.fs = fs);
+    return (_this_storage_clear = (_this_storage = this.storage).clear) === null || _this_storage_clear === void 0 ? void 0 : _this_storage_clear.call(_this_storage);
+  }
+  encodingContent(value, encoding) {
+    if (encoding === "utf-8") {
+      return value.toString();
+    }
+    return value;
+  }
+  constructor(storage) {
+    this.fs = import_fs_extra.default;
+    this.storage = storage;
+  }
+}
+const fileReader = new FileReader((0, import_storer.createMemoryStorage)("__file__system"));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FileReader,
+  fileReader
+});

package/dist/cjs/node/storer/container.js

@@ -0,0 +1,75 @@
+"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 container_exports = {};
+__export(container_exports, {
+  MemoryContainer: () => MemoryContainer
+});
+module.exports = __toCommonJS(container_exports);
+var import_lru_cache = __toESM(require("lru-cache"));
+class MemoryContainer {
+  async get(key) {
+    return this.cache.get(key);
+  }
+  async set(key, value) {
+    this.cache.set(key, value);
+    return this;
+  }
+  async has(key) {
+    return this.cache.has(key);
+  }
+  async delete(key) {
+    const exist = await this.has(key);
+    if (exist) {
+      this.cache.del(key);
+    }
+    return exist;
+  }
+  forEach(callbackFn) {
+    this.cache.forEach((value, key) => {
+      callbackFn(value, key, this);
+    });
+  }
+  constructor({ max, maxAge } = {}) {
+    this.cache = new import_lru_cache.default({
+      max: (max || 256) * MemoryContainer.MB,
+      maxAge: maxAge || MemoryContainer.hour
+    });
+  }
+}
+MemoryContainer.BYTE = 1;
+MemoryContainer.KB = 1024 * MemoryContainer.BYTE;
+MemoryContainer.MB = 1024 * MemoryContainer.KB;
+MemoryContainer.ms = 1;
+MemoryContainer.second = MemoryContainer.ms * 1e3;
+MemoryContainer.minute = MemoryContainer.second * 60;
+MemoryContainer.hour = MemoryContainer.minute * 60;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MemoryContainer
+});

package/dist/cjs/node/storer/index.js

@@ -0,0 +1,36 @@
+"use strict";
+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 storer_exports = {};
+__export(storer_exports, {
+  Storage: () => import_storage2.Storage,
+  createMemoryStorage: () => createMemoryStorage
+});
+module.exports = __toCommonJS(storer_exports);
+var import_container = require("./container");
+var import_storage = require("./storage");
+var import_storage2 = require("./storage");
+const memoryContainer = new import_container.MemoryContainer();
+function createMemoryStorage(namespace) {
+  return new import_storage.Storage(namespace, memoryContainer);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Storage,
+  createMemoryStorage
+});

package/dist/cjs/node/storer/storage.js

@@ -0,0 +1,97 @@
+"use strict";
+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 storage_exports = {};
+__export(storage_exports, {
+  Storage: () => Storage
+});
+module.exports = __toCommonJS(storage_exports);
+class Storage {
+  async keys() {
+    var _this_forEach, _this;
+    const _keys = [];
+    (_this_forEach = (_this = this).forEach) === null || _this_forEach === void 0 ? void 0 : _this_forEach.call(_this, (_, k) => {
+      _keys.push(k);
+    });
+    return _keys;
+  }
+  async values() {
+    var _this_forEach, _this;
+    const _values = [];
+    (_this_forEach = (_this = this).forEach) === null || _this_forEach === void 0 ? void 0 : _this_forEach.call(_this, (v) => {
+      _values.push(v);
+    });
+    return _values;
+  }
+  /**
+  * Returns a specified element from the containter. If the value that is associated to the provided key is an object, then you will get a reference to that object and any change made to that object will effectively modify it inside the Containter.
+  * @returns Returns the element associated with the specified key. If no element is associated with the specified key, undefined is returned.
+  */
+  get(key) {
+    const uniqueKey = this.computedUniqueKey(key);
+    return this.container.get(uniqueKey);
+  }
+  /**
+  * Adds a new element with a specified key and value to the storage. If an element with the same key already exists, the element will be updated.
+  */
+  async set(key, value) {
+    const uniqueKey = this.computedUniqueKey(key);
+    await this.container.set(uniqueKey, value);
+    return this;
+  }
+  /**
+  * @returns boolean indicating whether an element with the specified key exists or not.
+  */
+  has(key) {
+    const uniqueKey = this.computedUniqueKey(key);
+    return this.container.has(uniqueKey);
+  }
+  delete(key) {
+    const uniqueKey = this.computedUniqueKey(key);
+    return this.container.delete(uniqueKey);
+  }
+  async clear() {
+    var _this_keys, _this;
+    const keys = await ((_this_keys = (_this = this).keys) === null || _this_keys === void 0 ? void 0 : _this_keys.call(_this));
+    await Promise.all((keys === null || keys === void 0 ? void 0 : keys.map(async (key) => {
+      return this.delete(key);
+    })) || []);
+  }
+  forEach(fallbackFn) {
+    var _this_container_forEach, _this_container;
+    (_this_container_forEach = (_this_container = this.container).forEach) === null || _this_container_forEach === void 0 ? void 0 : _this_container_forEach.call(_this_container, (v, k) => {
+      if (this.checkIsOwnkey(k)) {
+        fallbackFn(v, k, this);
+      }
+    });
+  }
+  computedUniqueKey(k) {
+    return `${this.namespace}:${k}`;
+  }
+  checkIsOwnkey(k) {
+    return k.startsWith(this.namespace);
+  }
+  constructor(namespace, containter) {
+    this.namespace = namespace;
+    this.container = containter;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Storage
+});

package/dist/esm/node/fileReader.js

@@ -0,0 +1,106 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _class_call_check } from "@swc/helpers/_/_class_call_check";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import Fs from "@modern-js/utils/fs-extra";
+import { createMemoryStorage } from "./storer";
+var FileReader = /* @__PURE__ */ function() {
+  "use strict";
+  function FileReader2(storage) {
+    _class_call_check(this, FileReader2);
+    this.fs = Fs;
+    this.storage = storage;
+  }
+  var _proto = FileReader2.prototype;
+  _proto.readFile = function readFile(path) {
+    var encoding = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "utf-8";
+    var _this = this;
+    return _async_to_generator(function() {
+      var fs, cache, isExistFile, content;
+      return _ts_generator(this, function(_state) {
+        switch (_state.label) {
+          case 0:
+            fs = _this.fs;
+            return [
+              4,
+              _this.storage.get(path)
+            ];
+          case 1:
+            cache = _state.sent();
+            if (cache === null) {
+              return [
+                2,
+                null
+              ];
+            }
+            if (cache) {
+              return [
+                2,
+                _this.encodingContent(cache, encoding)
+              ];
+            }
+            return [
+              4,
+              new Promise(function(resolve) {
+                fs.stat(path, function(err, stats) {
+                  if (err) {
+                    resolve(false);
+                    return;
+                  }
+                  if (stats.isFile()) {
+                    resolve(true);
+                  } else {
+                    resolve(false);
+                  }
+                });
+              })
+            ];
+          case 2:
+            isExistFile = _state.sent();
+            if (!isExistFile)
+              return [
+                3,
+                4
+              ];
+            return [
+              4,
+              fs.promises.readFile(path)
+            ];
+          case 3:
+            content = _state.sent();
+            _this.storage.set(path, content);
+            return [
+              2,
+              _this.encodingContent(content, encoding)
+            ];
+          case 4:
+            _this.storage.set(path, null);
+            return [
+              2,
+              null
+            ];
+          case 5:
+            return [
+              2
+            ];
+        }
+      });
+    })();
+  };
+  _proto.reset = function reset(fs) {
+    var _this_storage_clear, _this_storage;
+    fs && (this.fs = fs);
+    return (_this_storage_clear = (_this_storage = this.storage).clear) === null || _this_storage_clear === void 0 ? void 0 : _this_storage_clear.call(_this_storage);
+  };
+  _proto.encodingContent = function encodingContent(value, encoding) {
+    if (encoding === "utf-8") {
+      return value.toString();
+    }
+    return value;
+  };
+  return FileReader2;
+}();
+var fileReader = new FileReader(createMemoryStorage("__file__system"));
+export {
+  FileReader,
+  fileReader
+};

package/dist/esm/node/storer/container.js

@@ -0,0 +1,91 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _class_call_check } from "@swc/helpers/_/_class_call_check";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import LRU from "lru-cache";
+var MemoryContainer = /* @__PURE__ */ function() {
+  "use strict";
+  function MemoryContainer2() {
+    var _ref = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}, max = _ref.max, maxAge = _ref.maxAge;
+    _class_call_check(this, MemoryContainer2);
+    this.cache = new LRU({
+      max: (max || 256) * MemoryContainer2.MB,
+      maxAge: maxAge || MemoryContainer2.hour
+    });
+  }
+  var _proto = MemoryContainer2.prototype;
+  _proto.get = function get(key) {
+    var _this = this;
+    return _async_to_generator(function() {
+      return _ts_generator(this, function(_state) {
+        return [
+          2,
+          _this.cache.get(key)
+        ];
+      });
+    })();
+  };
+  _proto.set = function set(key, value) {
+    var _this = this;
+    return _async_to_generator(function() {
+      return _ts_generator(this, function(_state) {
+        _this.cache.set(key, value);
+        return [
+          2,
+          _this
+        ];
+      });
+    })();
+  };
+  _proto.has = function has(key) {
+    var _this = this;
+    return _async_to_generator(function() {
+      return _ts_generator(this, function(_state) {
+        return [
+          2,
+          _this.cache.has(key)
+        ];
+      });
+    })();
+  };
+  _proto.delete = function _delete(key) {
+    var _this = this;
+    return _async_to_generator(function() {
+      var exist;
+      return _ts_generator(this, function(_state) {
+        switch (_state.label) {
+          case 0:
+            return [
+              4,
+              _this.has(key)
+            ];
+          case 1:
+            exist = _state.sent();
+            if (exist) {
+              _this.cache.del(key);
+            }
+            return [
+              2,
+              exist
+            ];
+        }
+      });
+    })();
+  };
+  _proto.forEach = function forEach(callbackFn) {
+    var _this = this;
+    this.cache.forEach(function(value, key) {
+      callbackFn(value, key, _this);
+    });
+  };
+  return MemoryContainer2;
+}();
+MemoryContainer.BYTE = 1;
+MemoryContainer.KB = 1024 * MemoryContainer.BYTE;
+MemoryContainer.MB = 1024 * MemoryContainer.KB;
+MemoryContainer.ms = 1;
+MemoryContainer.second = MemoryContainer.ms * 1e3;
+MemoryContainer.minute = MemoryContainer.second * 60;
+MemoryContainer.hour = MemoryContainer.minute * 60;
+export {
+  MemoryContainer
+};

package/dist/esm/node/storer/index.js

@@ -0,0 +1,11 @@
+import { MemoryContainer } from "./container";
+import { Storage } from "./storage";
+import { Storage as Storage2 } from "./storage";
+var memoryContainer = new MemoryContainer();
+function createMemoryStorage(namespace) {
+  return new Storage(namespace, memoryContainer);
+}
+export {
+  Storage2 as Storage,
+  createMemoryStorage
+};

package/dist/esm/node/storer/storage.js

@@ -0,0 +1,135 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _class_call_check } from "@swc/helpers/_/_class_call_check";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+var Storage = /* @__PURE__ */ function() {
+  "use strict";
+  function Storage2(namespace, containter) {
+    _class_call_check(this, Storage2);
+    this.namespace = namespace;
+    this.container = containter;
+  }
+  var _proto = Storage2.prototype;
+  _proto.keys = function keys() {
+    var _this = this;
+    return _async_to_generator(function() {
+      var _this_forEach, _this1, _keys;
+      return _ts_generator(this, function(_state) {
+        _keys = [];
+        (_this_forEach = (_this1 = _this).forEach) === null || _this_forEach === void 0 ? void 0 : _this_forEach.call(_this1, function(_, k) {
+          _keys.push(k);
+        });
+        return [
+          2,
+          _keys
+        ];
+      });
+    })();
+  };
+  _proto.values = function values() {
+    var _this = this;
+    return _async_to_generator(function() {
+      var _this_forEach, _this1, _values;
+      return _ts_generator(this, function(_state) {
+        _values = [];
+        (_this_forEach = (_this1 = _this).forEach) === null || _this_forEach === void 0 ? void 0 : _this_forEach.call(_this1, function(v) {
+          _values.push(v);
+        });
+        return [
+          2,
+          _values
+        ];
+      });
+    })();
+  };
+  _proto.get = function get(key) {
+    var uniqueKey = this.computedUniqueKey(key);
+    return this.container.get(uniqueKey);
+  };
+  _proto.set = function set(key, value) {
+    var _this = this;
+    return _async_to_generator(function() {
+      var uniqueKey;
+      return _ts_generator(this, function(_state) {
+        switch (_state.label) {
+          case 0:
+            uniqueKey = _this.computedUniqueKey(key);
+            return [
+              4,
+              _this.container.set(uniqueKey, value)
+            ];
+          case 1:
+            _state.sent();
+            return [
+              2,
+              _this
+            ];
+        }
+      });
+    })();
+  };
+  _proto.has = function has(key) {
+    var uniqueKey = this.computedUniqueKey(key);
+    return this.container.has(uniqueKey);
+  };
+  _proto.delete = function _delete(key) {
+    var uniqueKey = this.computedUniqueKey(key);
+    return this.container.delete(uniqueKey);
+  };
+  _proto.clear = function clear() {
+    var _this = this;
+    return _async_to_generator(function() {
+      var _this_keys, _this1, keys;
+      return _ts_generator(this, function(_state) {
+        switch (_state.label) {
+          case 0:
+            return [
+              4,
+              (_this_keys = (_this1 = _this).keys) === null || _this_keys === void 0 ? void 0 : _this_keys.call(_this1)
+            ];
+          case 1:
+            keys = _state.sent();
+            return [
+              4,
+              Promise.all((keys === null || keys === void 0 ? void 0 : keys.map(function() {
+                var _ref = _async_to_generator(function(key) {
+                  return _ts_generator(this, function(_state2) {
+                    return [
+                      2,
+                      _this.delete(key)
+                    ];
+                  });
+                });
+                return function(key) {
+                  return _ref.apply(this, arguments);
+                };
+              }())) || [])
+            ];
+          case 2:
+            _state.sent();
+            return [
+              2
+            ];
+        }
+      });
+    })();
+  };
+  _proto.forEach = function forEach(fallbackFn) {
+    var _this = this;
+    var _this_container_forEach, _this_container;
+    (_this_container_forEach = (_this_container = this.container).forEach) === null || _this_container_forEach === void 0 ? void 0 : _this_container_forEach.call(_this_container, function(v, k) {
+      if (_this.checkIsOwnkey(k)) {
+        fallbackFn(v, k, _this);
+      }
+    });
+  };
+  _proto.computedUniqueKey = function computedUniqueKey(k) {
+    return "".concat(this.namespace, ":").concat(k);
+  };
+  _proto.checkIsOwnkey = function checkIsOwnkey(k) {
+    return k.startsWith(this.namespace);
+  };
+  return Storage2;
+}();
+export {
+  Storage
+};

package/dist/esm-node/node/fileReader.js

@@ -0,0 +1,58 @@
+import Fs from "@modern-js/utils/fs-extra";
+import { createMemoryStorage } from "./storer";
+class FileReader {
+  async readFile(path, encoding = "utf-8") {
+    const { fs } = this;
+    const cache = await this.storage.get(path);
+    if (cache === null) {
+      return null;
+    }
+    if (cache) {
+      return this.encodingContent(cache, encoding);
+    }
+    const isExistFile = await new Promise((resolve) => {
+      fs.stat(path, (err, stats) => {
+        if (err) {
+          resolve(false);
+          return;
+        }
+        if (stats.isFile()) {
+          resolve(true);
+        } else {
+          resolve(false);
+        }
+      });
+    });
+    if (isExistFile) {
+      const content = await fs.promises.readFile(path);
+      this.storage.set(path, content);
+      return this.encodingContent(content, encoding);
+    } else {
+      this.storage.set(path, null);
+      return null;
+    }
+  }
+  /**
+  * Clear the fileCache entriely.
+  */
+  reset(fs) {
+    var _this_storage_clear, _this_storage;
+    fs && (this.fs = fs);
+    return (_this_storage_clear = (_this_storage = this.storage).clear) === null || _this_storage_clear === void 0 ? void 0 : _this_storage_clear.call(_this_storage);
+  }
+  encodingContent(value, encoding) {
+    if (encoding === "utf-8") {
+      return value.toString();
+    }
+    return value;
+  }
+  constructor(storage) {
+    this.fs = Fs;
+    this.storage = storage;
+  }
+}
+const fileReader = new FileReader(createMemoryStorage("__file__system"));
+export {
+  FileReader,
+  fileReader
+};

package/dist/esm-node/node/storer/container.js

@@ -0,0 +1,41 @@
+import LRU from "lru-cache";
+class MemoryContainer {
+  async get(key) {
+    return this.cache.get(key);
+  }
+  async set(key, value) {
+    this.cache.set(key, value);
+    return this;
+  }
+  async has(key) {
+    return this.cache.has(key);
+  }
+  async delete(key) {
+    const exist = await this.has(key);
+    if (exist) {
+      this.cache.del(key);
+    }
+    return exist;
+  }
+  forEach(callbackFn) {
+    this.cache.forEach((value, key) => {
+      callbackFn(value, key, this);
+    });
+  }
+  constructor({ max, maxAge } = {}) {
+    this.cache = new LRU({
+      max: (max || 256) * MemoryContainer.MB,
+      maxAge: maxAge || MemoryContainer.hour
+    });
+  }
+}
+MemoryContainer.BYTE = 1;
+MemoryContainer.KB = 1024 * MemoryContainer.BYTE;
+MemoryContainer.MB = 1024 * MemoryContainer.KB;
+MemoryContainer.ms = 1;
+MemoryContainer.second = MemoryContainer.ms * 1e3;
+MemoryContainer.minute = MemoryContainer.second * 60;
+MemoryContainer.hour = MemoryContainer.minute * 60;
+export {
+  MemoryContainer
+};

package/dist/esm-node/node/storer/index.js

@@ -0,0 +1,11 @@
+import { MemoryContainer } from "./container";
+import { Storage } from "./storage";
+import { Storage as Storage2 } from "./storage";
+const memoryContainer = new MemoryContainer();
+function createMemoryStorage(namespace) {
+  return new Storage(namespace, memoryContainer);
+}
+export {
+  Storage2 as Storage,
+  createMemoryStorage
+};

package/dist/esm-node/node/storer/storage.js

@@ -0,0 +1,73 @@
+class Storage {
+  async keys() {
+    var _this_forEach, _this;
+    const _keys = [];
+    (_this_forEach = (_this = this).forEach) === null || _this_forEach === void 0 ? void 0 : _this_forEach.call(_this, (_, k) => {
+      _keys.push(k);
+    });
+    return _keys;
+  }
+  async values() {
+    var _this_forEach, _this;
+    const _values = [];
+    (_this_forEach = (_this = this).forEach) === null || _this_forEach === void 0 ? void 0 : _this_forEach.call(_this, (v) => {
+      _values.push(v);
+    });
+    return _values;
+  }
+  /**
+  * Returns a specified element from the containter. If the value that is associated to the provided key is an object, then you will get a reference to that object and any change made to that object will effectively modify it inside the Containter.
+  * @returns Returns the element associated with the specified key. If no element is associated with the specified key, undefined is returned.
+  */
+  get(key) {
+    const uniqueKey = this.computedUniqueKey(key);
+    return this.container.get(uniqueKey);
+  }
+  /**
+  * Adds a new element with a specified key and value to the storage. If an element with the same key already exists, the element will be updated.
+  */
+  async set(key, value) {
+    const uniqueKey = this.computedUniqueKey(key);
+    await this.container.set(uniqueKey, value);
+    return this;
+  }
+  /**
+  * @returns boolean indicating whether an element with the specified key exists or not.
+  */
+  has(key) {
+    const uniqueKey = this.computedUniqueKey(key);
+    return this.container.has(uniqueKey);
+  }
+  delete(key) {
+    const uniqueKey = this.computedUniqueKey(key);
+    return this.container.delete(uniqueKey);
+  }
+  async clear() {
+    var _this_keys, _this;
+    const keys = await ((_this_keys = (_this = this).keys) === null || _this_keys === void 0 ? void 0 : _this_keys.call(_this));
+    await Promise.all((keys === null || keys === void 0 ? void 0 : keys.map(async (key) => {
+      return this.delete(key);
+    })) || []);
+  }
+  forEach(fallbackFn) {
+    var _this_container_forEach, _this_container;
+    (_this_container_forEach = (_this_container = this.container).forEach) === null || _this_container_forEach === void 0 ? void 0 : _this_container_forEach.call(_this_container, (v, k) => {
+      if (this.checkIsOwnkey(k)) {
+        fallbackFn(v, k, this);
+      }
+    });
+  }
+  computedUniqueKey(k) {
+    return `${this.namespace}:${k}`;
+  }
+  checkIsOwnkey(k) {
+    return k.startsWith(this.namespace);
+  }
+  constructor(namespace, containter) {
+    this.namespace = namespace;
+    this.container = containter;
+  }
+}
+export {
+  Storage
+};

package/dist/types/node/fileReader.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="node" />
+import Fs from '@modern-js/utils/fs-extra';
+import { Storage } from './storer/storage';
+export declare class FileReader {
+    private storage;
+    private fs;
+    constructor(storage: Storage<Buffer | null>);
+    readFile(path: string, encoding?: 'utf-8' | 'buffer'): Promise<string | Buffer | null>;
+    /**
+     * Clear the fileCache entriely.
+     */
+    reset(fs?: typeof Fs): Promise<void>;
+    private encodingContent;
+}
+export declare const fileReader: FileReader;

package/dist/types/node/storer/container.d.ts

@@ -0,0 +1,27 @@
+import { Container } from '@modern-js/types';
+interface MemoryContainerOptions {
+    /** The maximum size of the cache, unit(MB). The default of value is 256. */
+    max?: number;
+    maxAge?: number;
+}
+/**
+ * MemoryContainer, it use lur-cache as cahe layer.
+ * It has a Time to Live, by default as 1 hour.
+ */
+export declare class MemoryContainer<K, V = unknown> implements Container<K, V> {
+    private static BYTE;
+    private static KB;
+    private static MB;
+    private static ms;
+    private static second;
+    private static minute;
+    private static hour;
+    private cache;
+    constructor({ max, maxAge }?: MemoryContainerOptions);
+    get(key: K): Promise<V | undefined>;
+    set(key: K, value: V): Promise<this>;
+    has(key: K): Promise<boolean>;
+    delete(key: K): Promise<boolean>;
+    forEach(callbackFn: (v: V, k: K, container: this) => void): void;
+}
+export {};

package/dist/types/node/storer/index.d.ts

@@ -0,0 +1,3 @@
+import { Storage } from './storage';
+export { Storage } from './storage';
+export declare function createMemoryStorage<V = unknown>(namespace: string): Storage<V>;

package/dist/types/node/storer/storage.d.ts

@@ -0,0 +1,26 @@
+import { Container } from '@modern-js/types';
+export declare class Storage<V = unknown> {
+    private namespace;
+    private container;
+    constructor(namespace: string, containter: Container<string, V>);
+    keys?(): Promise<string[]>;
+    values?(): Promise<V[]>;
+    /**
+     * Returns a specified element from the containter. If the value that is associated to the provided key is an object, then you will get a reference to that object and any change made to that object will effectively modify it inside the Containter.
+     * @returns Returns the element associated with the specified key. If no element is associated with the specified key, undefined is returned.
+     */
+    get(key: string): Promise<V | undefined>;
+    /**
+     * Adds a new element with a specified key and value to the storage. If an element with the same key already exists, the element will be updated.
+     */
+    set(key: string, value: V): Promise<this>;
+    /**
+     * @returns boolean indicating whether an element with the specified key exists or not.
+     */
+    has(key: string): Promise<boolean>;
+    delete(key: string): Promise<boolean>;
+    clear?(): Promise<void>;
+    forEach?(fallbackFn: (v: V, k: string, storage: this) => void): void;
+    private computedUniqueKey;
+    private checkIsOwnkey;
+}

package/package.json

@@ -15,7 +15,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "2.42.1",
+  "version": "2.43.0",
   "_comment": "Provide ESM and CJS exports, ESM is used by runtime package, for treeshaking",
   "exports": {
     "./router": {
@@ -52,6 +52,16 @@
       "types": "./dist/types/parsed.d.ts",
       "require": "./dist/cjs/parsed.js",
       "default": "./dist/esm/parsed.js"
+    },
+    "./storer": {
+      "types": "./dist/types/node/storer/index.d.ts",
+      "require": "./dist/cjs/node/storer/index.js",
+      "default": "./dist/esm/node/storer/index.js"
+    },
+    "./fileReader": {
+      "types": "./dist/types/node/fileReader.d.ts",
+      "require": "./dist/cjs/node/fileReader.js",
+      "default": "./dist/esm/node/fileReader.js"
     }
   },
   "publishConfig": {
@@ -81,15 +91,22 @@
       ],
       "parsed": [
         "./dist/types/parsed.d.ts"
+      ],
+      "storer": [
+        "./dist/types/node/storer/index.d.ts"
+      ],
+      "fileReader": [
+        "./dist/types/node/fileReader.d.ts"
       ]
     }
   },
   "dependencies": {
+    "lru-cache": "^6.0.0",
     "serialize-javascript": "^6.0.0",
     "react-router-dom": "6.17.0",
     "@remix-run/router": "1.10.0",
     "@swc/helpers": "0.5.3",
-    "@modern-js/utils": "2.42.1"
+    "@modern-js/utils": "2.43.0"
   },
   "peerDependencies": {
     "react": ">=17.0.0",
@@ -108,12 +125,13 @@
     "react-dom": "^18.2.0",
     "@types/jest": "^29",
     "@types/node": "^14",
+    "@types/lru-cache": "^5.1.1",
     "jest": "^29",
     "typescript": "^5",
     "@types/serialize-javascript": "^5.0.1",
-    "@modern-js/types": "2.42.1",
-    "@scripts/build": "2.42.1",
-    "@scripts/jest-config": "2.42.1"
+    "@modern-js/types": "2.43.0",
+    "@scripts/build": "2.43.0",
+    "@scripts/jest-config": "2.43.0"
   },
   "sideEffects": false,
   "scripts": {