@lesnoypudge/utils/build/Cache/Cache.js

lesnoypudge's utils

var __defProp = Object.defineProperty;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
import "ts-deepmerge";
import autoBind from "auto-bind";
import "is-callable";
import "react-fast-compare";
class CacheLayer {
  constructor() {
    __publicField(this, "data", {
      isComputed: false,
      value: void 0,
      cleanupTimeoutId: null
    });
    __publicField(this, "map");
  }
  getOrCreateMap() {
    if (!this.map) {
      this.map = /* @__PURE__ */ new Map();
    }
    return this.map;
  }
  setValue(value, lifespan) {
    if (this.data.cleanupTimeoutId !== null) {
      clearTimeout(this.data.cleanupTimeoutId);
    }
    this.data.isComputed = true;
    this.data.value = value;
    if (lifespan !== Infinity) {
      this.data.cleanupTimeoutId = setTimeout(() => {
        this.data.isComputed = false;
        this.data.value = void 0;
        this.data.cleanupTimeoutId = null;
      }, lifespan);
    }
    return value;
  }
}
class Cache {
  constructor() {
    __publicField(this, "layer");
    autoBind(this);
  }
  getOrCreateLayer(key) {
    if (!this.layer) {
      this.layer = new CacheLayer();
    }
    let currentLayer = this.layer;
    key.forEach((keyPart) => {
      const map = currentLayer.getOrCreateMap();
      const layer = map.get(keyPart);
      if (!layer) {
        currentLayer = new CacheLayer();
        map.set(keyPart, currentLayer);
        return;
      }
      currentLayer = layer;
    });
    return currentLayer;
  }
  getLayer(key) {
    let currentLayer = this.layer;
    if (!this.layer) return void 0;
    const bail = () => {
      currentLayer = void 0;
    };
    key.forEach((keyPart) => {
      if (!currentLayer) return bail();
      const map = currentLayer.map;
      if (!map) return bail();
      if (!map.has(keyPart)) return bail();
      currentLayer = map.get(keyPart);
    });
    return currentLayer;
  }
  has(key) {
    var _a;
    return !!((_a = this.getLayer(key)) == null ? void 0 : _a.data.isComputed);
  }
  set(key, value, lifespan = Infinity) {
    return this.getOrCreateLayer(key).setValue(value, lifespan);
  }
  get(key) {
    var _a;
    return (_a = this.getLayer(key)) == null ? void 0 : _a.data.value;
  }
  getOrSet(key, getNewValueIfEmpty, lifespan = Infinity) {
    const layer = this.getOrCreateLayer(key);
    if (layer.data.isComputed) return layer.data.value;
    return layer.setValue(getNewValueIfEmpty(), lifespan);
  }
  getSize() {
    var _a;
    let size = 0;
    if ((_a = this.layer) == null ? void 0 : _a.data.isComputed) {
      size++;
    }
    const loop = (layer) => {
      if (!layer) return;
      if (!layer.map) return;
      size += layer.map.size;
      layer.map.forEach(loop);
    };
    loop(this.layer);
    return size;
  }
  destroy() {
    this.layer = void 0;
  }
}
export {
  Cache
};
//# sourceMappingURL=Cache.js.map