util-helpers 4.23.0 → 4.23.2

package/dist/util-helpers.js

@@ -200,6 +200,11 @@
         return isNil(value) ? '' : baseToString(value);
     }
 
+    var defaultTo = function (value, defaultValue) {
+        return value == null || value !== value ? defaultValue : value;
+    };
+    var defaultTo$1 = defaultTo;
+
     var blobExisted = typeof Blob !== stringUndefined;
     function isBlob(value) {
         if (blobExisted && value instanceof Blob) {
@@ -1637,81 +1642,401 @@
         return EmitterPro;
     }());
 
-    var Cache$1 = (function (_super) {
+    // 随机字符串
+    function randomString$1() {
+        return Math.random().toString(16).substring(2, 8);
+    }
+    // 内部自增id
+    var uid = 1;
+    // 返回唯一标识
+    function getUniqueId() {
+        return "".concat(randomString$1(), "_").concat(uid++);
+    }
+    // 是否支持 storage
+    function isStorageSupported(storage) {
+        try {
+            var isSupport = typeof storage === 'object' &&
+                storage !== null &&
+                !!storage.setItem &&
+                !!storage.getItem &&
+                !!storage.removeItem;
+            if (isSupport) {
+                var key = getUniqueId();
+                var value = '1';
+                storage.setItem(key, value);
+                if (storage.getItem(key) !== value) {
+                    return false;
+                }
+                storage.removeItem(key);
+            }
+            return isSupport;
+        }
+        catch (e) {
+            console.error("[cache2] ".concat(storage, " is not supported. The default memory cache will be used."));
+            return false;
+        }
+    }
+    function parse(value, reviver) {
+        try {
+            return JSON.parse(value, reviver);
+        }
+        catch (e) {
+            return value;
+        }
+    }
+    function stringify(value, replacer) {
+        return JSON.stringify(value, replacer);
+    }
+
+    var cache = {};
+    var MemoryStorage = /** @class */ (function () {
+        function MemoryStorage(scope) {
+            if (scope === void 0) { scope = 'default'; }
+            this.scope = scope;
+            if (!cache[this.scope]) {
+                cache[this.scope] = {};
+            }
+            this.data = cache[this.scope];
+        }
+        MemoryStorage.prototype.getItem = function (key) {
+            return key in this.data ? this.data[key] : null;
+        };
+        MemoryStorage.prototype.setItem = function (key, value) {
+            this.data[key] = value;
+        };
+        MemoryStorage.prototype.removeItem = function (key) {
+            delete this.data[key];
+        };
+        MemoryStorage.prototype.clear = function () {
+            cache[this.scope] = {};
+            this.data = cache[this.scope];
+        };
+        return MemoryStorage;
+    }());
+
+    var Storage = /** @class */ (function () {
+        function Storage(storage, options) {
+            if (options === void 0) { options = {}; }
+            var isSupported = storage ? isStorageSupported(storage) : false;
+            this.options = __assign({ needParsed: isSupported }, options);
+            this.storage = isSupported ? storage : new MemoryStorage(this.options.memoryScope);
+        }
+        Storage.prototype.get = function (key) {
+            var data = this.storage.getItem(key);
+            return this.options.needParsed ? parse(data, this.options.reviver) : data;
+        };
+        Storage.prototype.set = function (key, data) {
+            this.storage.setItem(key, this.options.needParsed ? stringify(data, this.options.replacer) : data);
+        };
+        Storage.prototype.del = function (key) {
+            this.storage.removeItem(key);
+        };
+        Storage.prototype.clear = function () {
+            if (typeof this.storage.clear === 'function') {
+                this.storage.clear();
+            }
+        };
+        return Storage;
+    }());
+
+    var defaultPrefix = 'cache2_'; // 命名空间缓存键前缀，默认 cache2_ 。
+    var defaultNamespace = 'default';
+    var Cache = /** @class */ (function (_super) {
         __extends(Cache, _super);
-        function Cache(options) {
+        function Cache(namespace, options) {
             var _this = _super.call(this) || this;
-            _this.data = [];
-            _this.options = __assign({ max: 10 }, options);
+            var ns = defaultNamespace, opts;
+            if (typeof namespace === 'string') {
+                ns = namespace;
+            }
+            else if (typeof namespace === 'object') {
+                opts = namespace;
+            }
+            if (!opts && typeof options === 'object') {
+                opts = options;
+            }
+            _this.options = __assign({ max: -1, stdTTL: 0, maxStrategy: 'limited', checkperiod: 0, prefix: defaultPrefix }, opts);
+            _this.storage = new Storage(_this.options.storage, __assign({ memoryScope: ns }, opts));
+            _this.cacheKey = (_this.options.prefix || '') + (ns || '') || getUniqueId();
+            _this.startCheckperiod();
             return _this;
         }
-        Cache.prototype.has = function (k) {
-            return !!this.data.find(function (item) { return item.k === k; });
+        // 检查当前键值是否过期，如果过期将会自动删除
+        Cache.prototype._check = function (key, data) {
+            var ret = true;
+            if (data.t !== 0 && data.t < Date.now()) {
+                ret = false;
+                this.del(key);
+                this.emit('expired', key, data.v);
+            }
+            return ret;
         };
-        Cache.prototype.get = function (k) {
-            var _a;
-            return (_a = this.data.find(function (item) { return item.k === k; })) === null || _a === void 0 ? void 0 : _a.v;
+        Cache.prototype._wrap = function (value, ttl) {
+            var now = Date.now();
+            var currentTtl = typeof ttl === 'number' ? ttl : this.options.stdTTL;
+            var livetime = currentTtl > 0 ? now + currentTtl : 0;
+            return {
+                v: value,
+                t: livetime,
+                n: now
+            };
         };
-        Cache.prototype.checkLimit = function () {
-            var _this = this;
-            if (this.options.max !== 0) {
-                var limit = this.data.length - this.options.max;
-                if (limit >= 0) {
-                    var delArr = this.data.splice(0, limit + 1);
-                    forEach$1(delArr, function (item) {
-                        _this.emit('del', item.v, item.k);
-                    });
+        Cache.prototype._isLimited = function (len) {
+            return this.options.max > -1 && len >= this.options.max;
+        };
+        Cache.prototype._getReplaceKey = function (keys, cacheValues) {
+            var retkey = keys[0];
+            keys.forEach(function (key) {
+                if (cacheValues[key].t < cacheValues[retkey].t ||
+                    (cacheValues[key].t === cacheValues[retkey].t && cacheValues[key].n < cacheValues[retkey].n)) {
+                    retkey = key;
                 }
-            }
+            });
+            return retkey;
+        };
+        Object.defineProperty(Cache.prototype, "cacheValues", {
+            // 获取全部缓存数据，不处理过期数据和排序
+            get: function () {
+                return this.storage.get(this.cacheKey) || {};
+            },
+            enumerable: false,
+            configurable: true
+        });
+        // 设置缓存数据
+        Cache.prototype.setCacheValues = function (values) {
+            this.storage.set(this.cacheKey, values);
         };
-        Cache.prototype.set = function (k, v) {
-            var newData = { k: k, v: v };
-            if (this.has(k)) {
-                var index = this.data.findIndex(function (item) { return item.k === k; });
-                this.data.splice(index, 1, newData);
+        // 从缓存中获取保存的值。如果未找到或已过期，则返回 undefined 。如果找到该值，则返回该值。
+        Cache.prototype.get = function (key) {
+            var data = this.cacheValues[key];
+            if (data && this._check(key, data)) {
+                return data.v;
             }
-            else {
-                this.checkLimit();
-                this.data.push(newData);
+            return;
+        };
+        // 从缓存中获取多个保存的值。如果未找到或已过期，则返回一个空对象。如果找到该值，它会返回一个具有键值对的对象。
+        Cache.prototype.mget = function (keys) {
+            var _this = this;
+            var ret = {};
+            if (!Array.isArray(keys)) {
+                return ret;
             }
+            var cacheValues = this.cacheValues;
+            keys.forEach(function (key) {
+                var data = cacheValues[key];
+                if (data && _this._check(key, data)) {
+                    ret[key] = data.v;
+                }
+            });
+            return ret;
         };
-        return Cache;
-    }(EmitterPro));
-
-    var cache$3 = new Cache$1({ max: 1 });
-    cache$3.on('del', function (v) {
-        if (v.r) {
-            try {
-                revokeObjectURL(v.data.image.src);
+        // 从缓存中获取全部保存的值。返回一个具有键值对的对象。
+        Cache.prototype.getAll = function () {
+            var keys = Object.keys(this.cacheValues);
+            return this.mget(keys);
+        };
+        // 设置键值对。设置成功返回 true 。
+        Cache.prototype.set = function (key, value, ttl) {
+            if (this.options.max === 0) {
+                return false;
             }
-            catch (_a) {
+            var cacheValues = this.cacheValues;
+            var keys = Object.keys(cacheValues);
+            // 当前不存在该键值，并且数据量超过最大限制
+            if (!cacheValues[key] && this._isLimited(keys.length)) {
+                var validKeys = this.keys();
+                if (this._isLimited(validKeys.length)) {
+                    // 如果最大限制策略是替换，将优先替换快过期的数据，如果都是一样的过期时间(0)，按照先入先出规则处理。
+                    if (this.options.maxStrategy === 'replaced') {
+                        var replaceKey = this._getReplaceKey(validKeys, cacheValues);
+                        this.del(replaceKey);
+                    }
+                    else {
+                        // 如果是最大限制策略是不允许添加，返回 false 。
+                        return false;
+                    }
+                }
             }
-        }
-    });
-    function loadImageWithBlob(img, cacheOptions, ajaxOptions) {
-        if (cacheOptions === void 0) { cacheOptions = true; }
-        var _cacheOptions = {
-            useCache: typeof cacheOptions === 'object' ? cacheOptions.useCache !== false : cacheOptions !== false,
-            autoRevokeOnDel: typeof cacheOptions === 'object' ? cacheOptions.autoRevokeOnDel !== false : !!cacheOptions
+            cacheValues[key] = this._wrap(value, ttl);
+            this.setCacheValues(cacheValues);
+            this.emit('set', key, cacheValues[key].v);
+            return true;
         };
-        return new Promise(function (resolve, reject) {
-            if (_cacheOptions.useCache && cache$3.has(img)) {
-                resolve(cache$3.get(img).data);
+        // 设置多个键值对。全部设置成功返回 true 。
+        Cache.prototype.mset = function (keyValueSet) {
+            var _this = this;
+            // 该处不使用数组 some 方法，是因为不能某个失败，而导致其他就不在更新。
+            var ret = true;
+            keyValueSet.forEach(function (item) {
+                var itemSetResult = _this.set(item.key, item.value, item.ttl);
+                if (ret && !itemSetResult) {
+                    ret = false;
+                }
+            });
+            return ret;
+        };
+        // 删除一个或多个键。返回已删除条目的数量。删除永远不会失败。
+        Cache.prototype.del = function (key) {
+            var _this = this;
+            var cacheValues = this.cacheValues;
+            var count = 0;
+            var keys = Array.isArray(key) ? key : [key];
+            keys.forEach(function (key) {
+                if (cacheValues[key]) {
+                    count++;
+                    var oldData = cacheValues[key];
+                    delete cacheValues[key];
+                    _this.emit('del', key, oldData.v);
+                }
+            });
+            if (count > 0) {
+                this.setCacheValues(cacheValues);
             }
-            else {
-                getFileBlob(img, ajaxOptions)
-                    .then(function (blob) {
-                    var url = createObjectURL(blob);
-                    var image = new Image();
+            return count;
+        };
+        // 删除当前所有缓存。
+        Cache.prototype.clear = function () {
+            this.storage.del(this.cacheKey);
+        };
+        // 返回所有现有键的数组。
+        Cache.prototype.keys = function () {
+            var _this = this;
+            var cacheValues = this.cacheValues;
+            var keys = Object.keys(cacheValues);
+            return keys.filter(function (key) { return _this._check(key, cacheValues[key]); });
+        };
+        // 当前缓存是否包含某个键。
+        Cache.prototype.has = function (key) {
+            var data = this.cacheValues[key];
+            return !!(data && this._check(key, data));
+        };
+        // 获取缓存值并从缓存中删除键。
+        Cache.prototype.take = function (key) {
+            var ret;
+            var data = this.cacheValues[key];
+            if (data && this._check(key, data)) {
+                ret = data.v;
+                this.del(key);
+            }
+            return ret;
+        };
+        // 重新定义一个键的 ttl 。如果找到并更新成功，则返回 true 。
+        Cache.prototype.ttl = function (key, ttl) {
+            var cacheValues = this.cacheValues;
+            var data = cacheValues[key];
+            if (data && this._check(key, data)) {
+                cacheValues[key] = this._wrap(data.v, ttl);
+                return true;
+            }
+            return false;
+        };
+        // 获取某个键的 ttl 。
+        // 如果未找到键或已过期，返回 undefined 。
+        // 如果 ttl 为 0 ，返回 0 。
+        // 否则返回一个以毫秒为单位的时间戳，表示键值将过期的时间。
+        Cache.prototype.getTtl = function (key) {
+            var cacheValues = this.cacheValues;
+            var data = cacheValues[key];
+            if (data && this._check(key, data)) {
+                return cacheValues[key].t;
+            }
+            return;
+        };
+        // 获取某个键值的最后修改时间
+        // 如果未找到键或已过期，返回 undefined 。
+        // 否则返回一个以毫秒为单位的时间戳，表示键值将过期的时间。
+        Cache.prototype.getLastModified = function (key) {
+            var cacheValues = this.cacheValues;
+            var data = cacheValues[key];
+            if (data && this._check(key, data)) {
+                return cacheValues[key].n;
+            }
+            return;
+        };
+        // 启动定时校验过期数据
+        Cache.prototype.startCheckperiod = function () {
+            var _this = this;
+            // 触发全部缓存数据是否过期校验
+            this.keys();
+            if (this.options.checkperiod > 0) {
+                clearTimeout(this._checkTimeout);
+                this._checkTimeout = setTimeout(function () {
+                    _this.startCheckperiod();
+                }, this.options.checkperiod);
+            }
+        };
+        // 停止定时校验过期数据
+        Cache.prototype.stopCheckperiod = function () {
+            clearTimeout(this._checkTimeout);
+        };
+        return Cache;
+    }(EmitterPro));
+
+    var AsyncMemo = (function () {
+        function AsyncMemo(options) {
+            this.promiseCache = {};
+            this.cache = new Cache(uniqueId('uh_async_memo'), options);
+        }
+        AsyncMemo.prototype.run = function (asyncFn, key, options) {
+            var _this = this;
+            if (!key || !isString(key)) {
+                return asyncFn();
+            }
+            var opts = __assign({ persisted: true }, options);
+            if (opts.persisted) {
+                var data = this.cache.get(key);
+                if (data) {
+                    return Promise.resolve(data);
+                }
+            }
+            if (!this.promiseCache[key]) {
+                this.promiseCache[key] = asyncFn()
+                    .then(function (res) {
+                    delete _this.promiseCache[key];
+                    _this.cache.set(key, res, opts.ttl);
+                    return res;
+                })
+                    .catch(function (err) {
+                    delete _this.promiseCache[key];
+                    return Promise.reject(err);
+                });
+            }
+            return this.promiseCache[key];
+        };
+        return AsyncMemo;
+    }());
+
+    var asyncMemo$2 = new AsyncMemo({ max: 1, maxStrategy: 'replaced' });
+    asyncMemo$2.cache.on('del', function (k, v) {
+        try {
+            if (v.r) {
+                revokeObjectURL(v.data.image.src);
+            }
+        }
+        catch (_a) {
+        }
+    });
+    function loadImageWithBlob(img, cacheOptions, ajaxOptions) {
+        if (cacheOptions === void 0) { cacheOptions = true; }
+        var cacheOptionsIsObject = typeof cacheOptions === 'object';
+        var _cacheOptions = {
+            useCache: cacheOptionsIsObject ? cacheOptions.useCache !== false : cacheOptions !== false,
+            autoRevokeOnDel: cacheOptionsIsObject ? cacheOptions.autoRevokeOnDel !== false : !!cacheOptions,
+            cacheKey: defaultTo$1(cacheOptionsIsObject ? cacheOptions.cacheKey : undefined, typeof img === 'string' ? img : undefined)
+        };
+        return asyncMemo$2
+            .run(function () {
+            return new Promise(function (resolve, reject) {
+                getFileBlob(img, ajaxOptions)
+                    .then(function (blob) {
+                    var url = createObjectURL(blob);
+                    var image = new Image();
                     image.onload = function () {
-                        var result = { blob: blob, image: image };
-                        if (_cacheOptions.useCache) {
-                            cache$3.set(img, {
-                                data: result,
-                                r: _cacheOptions.autoRevokeOnDel
-                            });
-                        }
-                        resolve(result);
+                        var data = { blob: blob, image: image };
+                        resolve({
+                            data: data,
+                            r: _cacheOptions.autoRevokeOnDel
+                        });
                     };
                     image.onerror = function (err) {
                         revokeObjectURL(url);
@@ -1721,8 +2046,9 @@
                     image.src = url;
                 })
                     .catch(reject);
-            }
-        });
+            });
+        }, _cacheOptions.useCache && _cacheOptions.cacheKey ? _cacheOptions.cacheKey : undefined)
+            .then(function (res) { return res.data; });
     }
 
     function canvasToBlob(canvas, type, quality) {
@@ -1873,14 +2199,14 @@
         });
     }
 
-    var cache$2 = new Cache$1({ max: 1 });
-    cache$2.on('del', function (v) {
-        if (v.r) {
-            try {
+    var asyncMemo$1 = new AsyncMemo({ max: 1, maxStrategy: 'replaced' });
+    asyncMemo$1.cache.on('del', function (k, v) {
+        try {
+            if (v.r) {
                 revokeObjectURL(v.data.image.src);
             }
-            catch (_a) {
-            }
+        }
+        catch (_a) {
         }
     });
     function calcContrast(w, h) {
@@ -1889,88 +2215,80 @@
     }
     function getImageInfo(img, cacheOptions, ajaxOptions) {
         if (cacheOptions === void 0) { cacheOptions = true; }
+        var cacheOptionsIsObject = typeof cacheOptions === 'object';
         var _cacheOptions = {
-            useCache: typeof cacheOptions === 'object' ? cacheOptions.useCache !== false : cacheOptions !== false,
-            autoRevokeOnDel: typeof cacheOptions === 'object' ? cacheOptions.autoRevokeOnDel !== false : !!cacheOptions
+            useCache: cacheOptionsIsObject ? cacheOptions.useCache !== false : cacheOptions !== false,
+            autoRevokeOnDel: cacheOptionsIsObject ? cacheOptions.autoRevokeOnDel !== false : !!cacheOptions,
+            cacheKey: defaultTo$1(cacheOptionsIsObject ? cacheOptions.cacheKey : undefined, typeof img === 'string' ? img : undefined)
         };
-        return new Promise(function (resolve, reject) {
-            if (_cacheOptions.useCache && cache$2.has(img)) {
-                resolve(cache$2.get(img).data);
-            }
-            else {
-                loadImageWithBlob(img, false, ajaxOptions)
-                    .then(function (_a) {
-                    var image = _a.image, blob = _a.blob;
-                    var width = image.width, height = image.height;
-                    var result = {
-                        width: width,
-                        height: height,
-                        contrast: calcContrast(width, height),
-                        measure: "".concat(width, " \u00D7 ").concat(height, " px"),
-                        size: bytesToSize(blob.size),
-                        bytes: blob.size,
-                        image: image,
-                        blob: blob
-                    };
-                    if (_cacheOptions.useCache) {
-                        cache$2.set(img, {
-                            data: result,
-                            r: _cacheOptions.autoRevokeOnDel
-                        });
-                    }
-                    resolve(result);
-                })
-                    .catch(reject);
-            }
-        });
+        return asyncMemo$1
+            .run(function () {
+            return loadImageWithBlob(img, false, ajaxOptions).then(function (_a) {
+                var image = _a.image, blob = _a.blob;
+                var width = image.width, height = image.height;
+                var data = {
+                    width: width,
+                    height: height,
+                    contrast: calcContrast(width, height),
+                    measure: "".concat(width, " \u00D7 ").concat(height, " px"),
+                    size: bytesToSize(blob.size),
+                    bytes: blob.size,
+                    image: image,
+                    blob: blob
+                };
+                return {
+                    data: data,
+                    r: _cacheOptions.autoRevokeOnDel
+                };
+            });
+        }, _cacheOptions.useCache && _cacheOptions.cacheKey ? _cacheOptions.cacheKey : undefined)
+            .then(function (res) { return res.data; });
     }
 
-    var cache$1 = new Cache$1({ max: 1 });
-    cache$1.on('del', function (v) {
-        if (v.r) {
-            try {
+    var asyncMemo = new AsyncMemo({ max: 1, maxStrategy: 'replaced' });
+    asyncMemo.cache.on('del', function (k, v) {
+        try {
+            if (v.r) {
                 revokeObjectURL(v.data.src);
             }
-            catch (_a) {
-            }
+        }
+        catch (_a) {
         }
     });
     function loadImage(img, cacheOptions) {
         if (cacheOptions === void 0) { cacheOptions = true; }
+        var cacheOptionsIsObject = typeof cacheOptions === 'object';
         var _cacheOptions = {
-            useCache: typeof cacheOptions === 'object' ? cacheOptions.useCache !== false : cacheOptions !== false,
-            autoRevokeOnDel: typeof cacheOptions === 'object' ? cacheOptions.autoRevokeOnDel !== false : !!cacheOptions
+            useCache: cacheOptionsIsObject ? cacheOptions.useCache !== false : cacheOptions !== false,
+            autoRevokeOnDel: cacheOptionsIsObject ? cacheOptions.autoRevokeOnDel !== false : !!cacheOptions,
+            cacheKey: defaultTo$1(cacheOptionsIsObject ? cacheOptions.cacheKey : undefined, typeof img === 'string' ? img : undefined)
         };
-        return new Promise(function (resolve, reject) {
-            if (_cacheOptions.useCache && cache$1.has(img)) {
-                resolve(cache$1.get(img).data);
-            }
-            else {
-                var imgIsBlob_1 = isBlob(img);
-                var url_1 = imgIsBlob_1 ? createObjectURL(img) : img;
-                var image_1 = new Image();
-                if (!imgIsBlob_1) {
-                    image_1.crossOrigin = 'anonymous';
+        return asyncMemo
+            .run(function () {
+            return new Promise(function (resolve, reject) {
+                var imgIsBlob = isBlob(img);
+                var url = imgIsBlob ? createObjectURL(img) : img;
+                var image = new Image();
+                if (!imgIsBlob) {
+                    image.crossOrigin = 'anonymous';
                 }
-                image_1.onload = function () {
-                    if (_cacheOptions.useCache) {
-                        cache$1.set(img, {
-                            data: image_1,
-                            r: _cacheOptions.autoRevokeOnDel
-                        });
-                    }
-                    resolve(image_1);
+                image.onload = function () {
+                    resolve({
+                        data: image,
+                        r: _cacheOptions.autoRevokeOnDel
+                    });
                 };
-                image_1.onerror = function (err) {
-                    if (imgIsBlob_1) {
-                        revokeObjectURL(url_1);
+                image.onerror = function (err) {
+                    if (imgIsBlob) {
+                        revokeObjectURL(url);
                     }
                     console.error("[loadImage] The image load failed, '".concat(img, "'."));
                     reject(err);
                 };
-                image_1.src = url_1;
-            }
-        });
+                image.src = url;
+            });
+        }, _cacheOptions.useCache && _cacheOptions.cacheKey ? _cacheOptions.cacheKey : undefined)
+            .then(function (res) { return res.data; });
     }
 
     function loadScript(src, options) {
@@ -2024,7 +2342,7 @@
         }
         return prefix;
     }
-    var randomString$1 = function (len, pool) {
+    var randomString = function (len, pool) {
         if (len === void 0) { len = 0; }
         var _pool;
         if (typeof pool !== 'string') {
@@ -2322,378 +2640,9 @@
         return internalFindTreeSelect(tree, predicate, childrenField);
     }
 
-    var VERSION = "4.23.0";
-
-    // 随机字符串
-    function randomString() {
-        return Math.random().toString(16).substring(2, 8);
-    }
-    // 内部自增id
-    var uid = 1;
-    // 返回唯一标识
-    function getUniqueId() {
-        return "".concat(randomString(), "_").concat(uid++);
-    }
-    // 是否支持 storage
-    function isStorageSupported(storage) {
-        try {
-            var isSupport = typeof storage === 'object' &&
-                storage !== null &&
-                !!storage.setItem &&
-                !!storage.getItem &&
-                !!storage.removeItem;
-            if (isSupport) {
-                var key = getUniqueId();
-                var value = '1';
-                storage.setItem(key, value);
-                if (storage.getItem(key) !== value) {
-                    return false;
-                }
-                storage.removeItem(key);
-            }
-            return isSupport;
-        }
-        catch (e) {
-            console.error("[cache2] ".concat(storage, " is not supported. The default memory cache will be used."));
-            return false;
-        }
-    }
-    function parse(value, reviver) {
-        try {
-            return JSON.parse(value, reviver);
-        }
-        catch (e) {
-            return value;
-        }
-    }
-    function stringify(value, replacer) {
-        return JSON.stringify(value, replacer);
-    }
-    var inWindow = typeof window !== 'undefined' && typeof window === 'object' && window.window === window;
-
-    var cache = {};
-    var MemoryStorage = /** @class */ (function () {
-        function MemoryStorage(scope) {
-            if (scope === void 0) { scope = 'default'; }
-            this.scope = scope;
-            if (!cache[this.scope]) {
-                cache[this.scope] = {};
-            }
-            this.data = cache[this.scope];
-        }
-        MemoryStorage.prototype.getItem = function (key) {
-            return key in this.data ? this.data[key] : null;
-        };
-        MemoryStorage.prototype.setItem = function (key, value) {
-            this.data[key] = value;
-        };
-        MemoryStorage.prototype.removeItem = function (key) {
-            delete this.data[key];
-        };
-        MemoryStorage.prototype.clear = function () {
-            cache[this.scope] = {};
-            this.data = cache[this.scope];
-        };
-        return MemoryStorage;
-    }());
-
-    var Storage = /** @class */ (function () {
-        function Storage(storage, options) {
-            if (options === void 0) { options = {}; }
-            var isSupported = storage ? isStorageSupported(storage) : false;
-            this.options = __assign({ needParsed: isSupported }, options);
-            this.storage = isSupported ? storage : new MemoryStorage(this.options.memoryScope);
-        }
-        Storage.prototype.get = function (key) {
-            var data = this.storage.getItem(key);
-            return this.options.needParsed ? parse(data, this.options.reviver) : data;
-        };
-        Storage.prototype.set = function (key, data) {
-            this.storage.setItem(key, this.options.needParsed ? stringify(data, this.options.replacer) : data);
-        };
-        Storage.prototype.del = function (key) {
-            this.storage.removeItem(key);
-        };
-        Storage.prototype.clear = function () {
-            if (typeof this.storage.clear === 'function') {
-                this.storage.clear();
-            }
-        };
-        return Storage;
-    }());
-
-    var defaultPrefix = 'cache2_'; // 命名空间缓存键前缀，默认 cache2_ 。
-    var defaultNamespace = 'default';
-    var Cache = /** @class */ (function (_super) {
-        __extends(Cache, _super);
-        function Cache(namespace, options) {
-            var _this = _super.call(this) || this;
-            var ns = defaultNamespace, opts;
-            if (typeof namespace === 'string') {
-                ns = namespace;
-            }
-            else if (typeof namespace === 'object') {
-                opts = namespace;
-            }
-            if (!opts && typeof options === 'object') {
-                opts = options;
-            }
-            _this.options = __assign({ max: -1, stdTTL: 0, maxStrategy: 'limited', checkperiod: 0, prefix: defaultPrefix }, opts);
-            _this.storage = new Storage(_this.options.storage, __assign({ memoryScope: ns }, opts));
-            _this.cacheKey = (_this.options.prefix || '') + (ns || '') || getUniqueId();
-            _this.startCheckperiod();
-            return _this;
-        }
-        // 检查当前键值是否过期，如果过期将会自动删除
-        Cache.prototype._check = function (key, data) {
-            var ret = true;
-            if (data.t !== 0 && data.t < Date.now()) {
-                ret = false;
-                this.del(key);
-                this.emit('expired', key, data.v);
-            }
-            return ret;
-        };
-        Cache.prototype._wrap = function (value, ttl) {
-            var now = Date.now();
-            var currentTtl = typeof ttl === 'number' ? ttl : this.options.stdTTL;
-            var livetime = currentTtl > 0 ? now + currentTtl : 0;
-            return {
-                v: value,
-                t: livetime,
-                n: now
-            };
-        };
-        Cache.prototype._isLimited = function (len) {
-            return this.options.max > -1 && len >= this.options.max;
-        };
-        Cache.prototype._getReplaceKey = function (keys, cacheValues) {
-            var retkey = keys[0];
-            keys.forEach(function (key) {
-                if (cacheValues[key].t < cacheValues[retkey].t ||
-                    (cacheValues[key].t === cacheValues[retkey].t && cacheValues[key].n < cacheValues[retkey].n)) {
-                    retkey = key;
-                }
-            });
-            return retkey;
-        };
-        Object.defineProperty(Cache.prototype, "cacheValues", {
-            // 获取全部缓存数据，不处理过期数据和排序
-            get: function () {
-                return this.storage.get(this.cacheKey) || {};
-            },
-            enumerable: false,
-            configurable: true
-        });
-        // 设置缓存数据
-        Cache.prototype.setCacheValues = function (values) {
-            this.storage.set(this.cacheKey, values);
-        };
-        // 从缓存中获取保存的值。如果未找到或已过期，则返回 undefined 。如果找到该值，则返回该值。
-        Cache.prototype.get = function (key) {
-            var data = this.cacheValues[key];
-            if (data && this._check(key, data)) {
-                return data.v;
-            }
-            return;
-        };
-        // 从缓存中获取多个保存的值。如果未找到或已过期，则返回一个空对象。如果找到该值，它会返回一个具有键值对的对象。
-        Cache.prototype.mget = function (keys) {
-            var _this = this;
-            var ret = {};
-            if (!Array.isArray(keys)) {
-                return ret;
-            }
-            var cacheValues = this.cacheValues;
-            keys.forEach(function (key) {
-                var data = cacheValues[key];
-                if (data && _this._check(key, data)) {
-                    ret[key] = data.v;
-                }
-            });
-            return ret;
-        };
-        // 从缓存中获取全部保存的值。返回一个具有键值对的对象。
-        Cache.prototype.getAll = function () {
-            var keys = Object.keys(this.cacheValues);
-            return this.mget(keys);
-        };
-        // 设置键值对。设置成功返回 true 。
-        Cache.prototype.set = function (key, value, ttl) {
-            if (this.options.max === 0) {
-                return false;
-            }
-            var cacheValues = this.cacheValues;
-            var keys = Object.keys(cacheValues);
-            // 当前不存在该键值，并且数据量超过最大限制
-            if (!cacheValues[key] && this._isLimited(keys.length)) {
-                var validKeys = this.keys();
-                if (this._isLimited(validKeys.length)) {
-                    // 如果最大限制策略是替换，将优先替换快过期的数据，如果都是一样的过期时间(0)，按照先入先出规则处理。
-                    if (this.options.maxStrategy === 'replaced') {
-                        var replaceKey = this._getReplaceKey(validKeys, cacheValues);
-                        this.del(replaceKey);
-                    }
-                    else {
-                        // 如果是最大限制策略是不允许添加，返回 false 。
-                        return false;
-                    }
-                }
-            }
-            cacheValues[key] = this._wrap(value, ttl);
-            this.setCacheValues(cacheValues);
-            this.emit('set', key, cacheValues[key].v);
-            return true;
-        };
-        // 设置多个键值对。全部设置成功返回 true 。
-        Cache.prototype.mset = function (keyValueSet) {
-            var _this = this;
-            // 该处不使用数组 some 方法，是因为不能某个失败，而导致其他就不在更新。
-            var ret = true;
-            keyValueSet.forEach(function (item) {
-                var itemSetResult = _this.set(item.key, item.value, item.ttl);
-                if (ret && !itemSetResult) {
-                    ret = false;
-                }
-            });
-            return ret;
-        };
-        // 删除一个或多个键。返回已删除条目的数量。删除永远不会失败。
-        Cache.prototype.del = function (key) {
-            var _this = this;
-            var cacheValues = this.cacheValues;
-            var count = 0;
-            var keys = Array.isArray(key) ? key : [key];
-            keys.forEach(function (key) {
-                if (cacheValues[key]) {
-                    count++;
-                    var oldData = cacheValues[key];
-                    delete cacheValues[key];
-                    _this.emit('del', key, oldData.v);
-                }
-            });
-            if (count > 0) {
-                this.setCacheValues(cacheValues);
-            }
-            return count;
-        };
-        // 删除当前所有缓存。
-        Cache.prototype.clear = function () {
-            this.storage.del(this.cacheKey);
-        };
-        // 返回所有现有键的数组。
-        Cache.prototype.keys = function () {
-            var _this = this;
-            var cacheValues = this.cacheValues;
-            var keys = Object.keys(cacheValues);
-            return keys.filter(function (key) { return _this._check(key, cacheValues[key]); });
-        };
-        // 当前缓存是否包含某个键。
-        Cache.prototype.has = function (key) {
-            var data = this.cacheValues[key];
-            return !!(data && this._check(key, data));
-        };
-        // 获取缓存值并从缓存中删除键。
-        Cache.prototype.take = function (key) {
-            var ret;
-            var data = this.cacheValues[key];
-            if (data && this._check(key, data)) {
-                ret = data.v;
-                this.del(key);
-            }
-            return ret;
-        };
-        // 重新定义一个键的 ttl 。如果找到并更新成功，则返回 true 。
-        Cache.prototype.ttl = function (key, ttl) {
-            var cacheValues = this.cacheValues;
-            var data = cacheValues[key];
-            if (data && this._check(key, data)) {
-                cacheValues[key] = this._wrap(data.v, ttl);
-                return true;
-            }
-            return false;
-        };
-        // 获取某个键的 ttl 。
-        // 如果未找到键或已过期，返回 undefined 。
-        // 如果 ttl 为 0 ，返回 0 。
-        // 否则返回一个以毫秒为单位的时间戳，表示键值将过期的时间。
-        Cache.prototype.getTtl = function (key) {
-            var cacheValues = this.cacheValues;
-            var data = cacheValues[key];
-            if (data && this._check(key, data)) {
-                return cacheValues[key].t;
-            }
-            return;
-        };
-        // 获取某个键值的最后修改时间
-        // 如果未找到键或已过期，返回 undefined 。
-        // 否则返回一个以毫秒为单位的时间戳，表示键值将过期的时间。
-        Cache.prototype.getLastModified = function (key) {
-            var cacheValues = this.cacheValues;
-            var data = cacheValues[key];
-            if (data && this._check(key, data)) {
-                return cacheValues[key].n;
-            }
-            return;
-        };
-        // 启动定时校验过期数据
-        Cache.prototype.startCheckperiod = function () {
-            var _this = this;
-            // 触发全部缓存数据是否过期校验
-            this.keys();
-            if (this.options.checkperiod > 0) {
-                clearTimeout(this._checkTimeout);
-                this._checkTimeout = setTimeout(function () {
-                    _this.startCheckperiod();
-                }, this.options.checkperiod);
-            }
-        };
-        // 停止定时校验过期数据
-        Cache.prototype.stopCheckperiod = function () {
-            clearTimeout(this._checkTimeout);
-        };
-        return Cache;
-    }(EmitterPro));
-
-    new Storage(inWindow ? window.localStorage : undefined);
-
-    new Storage(inWindow ? window.sessionStorage : undefined);
-
-    var AsyncMemo = (function () {
-        function AsyncMemo(options) {
-            this.promiseCache = {};
-            this.cache = new Cache(uniqueId('uh_async_memo'), options);
-        }
-        AsyncMemo.prototype.run = function (asyncFn, key, options) {
-            var _this = this;
-            if (!key || !isString(key)) {
-                return asyncFn();
-            }
-            var opts = __assign({ persisted: true }, options);
-            if (opts.persisted) {
-                var data = this.cache.get(key);
-                if (data) {
-                    return Promise.resolve(data);
-                }
-            }
-            if (!this.promiseCache[key]) {
-                this.promiseCache[key] = asyncFn()
-                    .then(function (res) {
-                    delete _this.promiseCache[key];
-                    _this.cache.set(key, res, opts.ttl);
-                    return res;
-                })
-                    .catch(function (err) {
-                    delete _this.promiseCache[key];
-                    return Promise.reject(err);
-                });
-            }
-            return this.promiseCache[key];
-        };
-        return AsyncMemo;
-    }());
+    var VERSION = "4.23.2";
 
-    var version = "4.23.0";
+    var version = "4.23.2";
 
     exports.AsyncMemo = AsyncMemo;
     exports.VERSION = VERSION;
@@ -2749,7 +2698,7 @@
     exports.padZero = padZero;
     exports.parseIdCard = parseIdCard;
     exports.plus = plus;
-    exports.randomString = randomString$1;
+    exports.randomString = randomString;
     exports.replaceChar = replaceChar;
     exports.round = _round;
     exports.safeDate = safeDate;