drip-table/lib/utils/cache.js

A tiny and powerful enterprise-class solution for building tables.

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }

function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

/**
 * This file is part of the drip-table project.
 * @link     : https://drip-table.jd.com/
 * @author   : Emil Zhai (root@derzh.com)
 * @modifier : Emil Zhai (root@derzh.com)
 * @copyright: Copyright (c) 2021 JD Network Technology Co., Ltd.
 */
var createItem = function createItem() {
  return {
    hasValue: false,
    value: void 0,
    children: new Map()
  };
};
/**
 * 支持嵌套的缓存对象
 */


var RecursiveCache = /*#__PURE__*/function () {
  function RecursiveCache() {
    _classCallCheck(this, RecursiveCache);

    _defineProperty(this, "root", createItem());
  }

  _createClass(RecursiveCache, [{
    key: "set",
    value:
    /**
     * 设置缓存值
     *
     * @param kvs 递归键名数组 + 值
     */
    function set() {
      for (var _len = arguments.length, kvs = new Array(_len), _key = 0; _key < _len; _key++) {
        kvs[_key] = arguments[_key];
      }

      var keys = kvs;
      var value = keys.pop();
      var item = this.root;

      for (var _i = 0, _keys = keys; _i < _keys.length; _i++) {
        var key = _keys[_i];
        var child = item.children.get(key);

        if (!child) {
          child = createItem();
          item.children.set(key, child);
        }

        item = child;
      }

      item.value = value;
      item.hasValue = true;
    }
    /**
     * 检查缓存值是否存在
     *
     * @param keys 递归键名数组
     * @returns 是否存在值
     */

  }, {
    key: "has",
    value: function has() {
      var item = this.root;

      for (var _len2 = arguments.length, keys = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
        keys[_key2] = arguments[_key2];
      }

      for (var _i2 = 0, _keys2 = keys; _i2 < _keys2.length; _i2++) {
        var key = _keys2[_i2];
        var child = item.children.get(key);

        if (!child) {
          return false;
        }

        item = child;
      }

      return item.hasValue;
    }
    /**
     * 获取缓存值
     *
     * @template T 数据类型
     * @param keys 递归键名数组
     * @returns 值
     */

  }, {
    key: "get",
    value: function get() {
      var item = this.root;

      for (var _len3 = arguments.length, keys = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
        keys[_key3] = arguments[_key3];
      }

      for (var _i3 = 0, _keys3 = keys; _i3 < _keys3.length; _i3++) {
        var key = _keys3[_i3];
        var child = item.children.get(key);

        if (!child) {
          return void 0;
        }

        item = child;
      }

      if (!item.hasValue) {
        return void 0;
      }

      return item.value;
    }
    /**
     * 清除缓存
     */

  }, {
    key: "clear",
    value: function clear() {
      this.root = createItem();
    }
  }]);

  return RecursiveCache;
}();

var _default = RecursiveCache;
exports.default = _default;