util-helpers 4.21.7 → 4.22.1

package/dist/util-helpers.js

@@ -4,16 +4,21 @@
     (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.utilHelpers = {}));
 })(this, (function (exports) { 'use strict';
 
+    var nativeUndefined$1 = void 0;
+    var stringUndefined = 'undefined';
+    var stringObject = 'object';
     var objectProto = Object.prototype;
     var objectProtoToString = objectProto.toString;
+    var objectProtoPropertyIsEnumerable = objectProto.propertyIsEnumerable;
+    var objectGetOwnPropertySymbols = Object.getOwnPropertySymbols;
     var objectKeys$1 = Object.keys;
-    var symbolExisted = typeof Symbol !== 'undefined';
-    var symbolProto = symbolExisted ? Symbol.prototype : undefined;
+    var symbolExisted = typeof Symbol !== stringUndefined;
+    var symbolProto = symbolExisted ? Symbol.prototype : nativeUndefined$1;
     var mathMin = Math.min;
     var numberIsFinite = Number.isFinite;
-    var globalThisExisted = typeof globalThis === 'object' && globalThis;
-    var globalExisted = typeof global === 'object' && global;
-    var selfExisted = typeof self === 'object' && self;
+    var globalThisExisted = typeof globalThis === stringObject && globalThis;
+    var globalExisted = typeof global === stringObject && global;
+    var selfExisted = typeof self === stringObject && self;
     var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || 9007199254740991;
     var MIN_SAFE_INTEGER = Number.MIN_SAFE_INTEGER || -9007199254740991;
     var numberTag = '[object Number]';
@@ -93,19 +98,26 @@
         return value != null && isLength(value.length) && !isFunction(value);
     }
 
-    function keys(object) {
+    function getSymbols(object) {
+        if (!objectGetOwnPropertySymbols || object === null) {
+            return [];
+        }
+        return objectGetOwnPropertySymbols(object).filter(function (item) { return objectProtoPropertyIsEnumerable.call(object, item); });
+    }
+
+    function allKeys(object) {
         if (!isObject(object)) {
             return [];
         }
-        return objectKeys$1(object);
+        return objectKeys$1(object).concat(getSymbols(object));
     }
 
     function createForEach(dir) {
-        function forEach(collection, iteratee) {
+        var forEach = function (collection, iteratee) {
             if (iteratee === void 0) { iteratee = identity; }
-            var _keys = !isArrayLike(collection) && keys(collection);
+            var _keys = !isArrayLike(collection) && allKeys(collection);
             var len = (_keys || collection).length;
-            var i = dir > 0 ? 0 : len - 1;
+            var i = 0 ;
             while (i >= 0 && i < len) {
                 var currentKey = _keys ? _keys[i] : i;
                 if (iteratee(collection[currentKey], currentKey, collection) === false) {
@@ -114,18 +126,22 @@
                 i += dir;
             }
             return collection;
-        }
+        };
         return forEach;
     }
 
     var forEach = createForEach(1);
     var forEach$1 = forEach;
 
+    function isNumber(value) {
+        return typeof value === 'number' || getTag(value) === numberTag;
+    }
+
     function isNil(value) {
         return value == null;
     }
 
-    var symbolToString = symbolProto ? symbolProto.toString : undefined;
+    var symbolToString = symbolProto ? symbolProto.toString : nativeUndefined$1;
     function baseToString(value) {
         if (typeof value === 'string') {
             return value;
@@ -143,7 +159,7 @@
         return isNil(value) ? '' : baseToString(value);
     }
 
-    var blobExisted = typeof Blob !== 'undefined';
+    var blobExisted = typeof Blob !== stringUndefined;
     function isBlob(value) {
         if (blobExisted && value instanceof Blob) {
             return true;
@@ -161,10 +177,6 @@
         return numberIsFinite ? numberIsFinite(value) : typeof value === 'number' && root$1.isFinite(value);
     }
 
-    function isNumber(value) {
-        return typeof value === 'number' || getTag(value) === numberTag;
-    }
-
     function isNaN(value) {
         return isNumber(value) && root$1.isNaN(value);
     }
@@ -210,6 +222,12 @@
         });
     }
 
+    var idCounter = 0;
+    function uniqueId(prefix) {
+        var id = ++idCounter;
+        return toString(prefix) + id;
+    }
+
     var reg$b = /^1[3456789]\d{9}$/;
     function isMobile(value) {
         var valueStr = toString(value);
@@ -1553,7 +1571,7 @@
         return EmitterPro;
     }());
 
-    var Cache = (function (_super) {
+    var Cache$1 = (function (_super) {
         __extends(Cache, _super);
         function Cache(options) {
             var _this = _super.call(this) || this;
@@ -1594,8 +1612,8 @@
         return Cache;
     }(EmitterPro));
 
-    var cache$2 = new Cache({ max: 1 });
-    cache$2.on('del', function (v) {
+    var cache$3 = new Cache$1({ max: 1 });
+    cache$3.on('del', function (v) {
         if (v.r) {
             try {
                 revokeObjectURL(v.data.image.src);
@@ -1611,8 +1629,8 @@
             autoRevokeOnDel: typeof cacheOptions === 'object' ? cacheOptions.autoRevokeOnDel !== false : !!cacheOptions
         };
         return new Promise(function (resolve, reject) {
-            if (_cacheOptions.useCache && cache$2.has(img)) {
-                resolve(cache$2.get(img).data);
+            if (_cacheOptions.useCache && cache$3.has(img)) {
+                resolve(cache$3.get(img).data);
             }
             else {
                 getFileBlob(img, ajaxOptions)
@@ -1622,7 +1640,7 @@
                     image.onload = function () {
                         var result = { blob: blob, image: image };
                         if (_cacheOptions.useCache) {
-                            cache$2.set(img, {
+                            cache$3.set(img, {
                                 data: result,
                                 r: _cacheOptions.autoRevokeOnDel
                             });
@@ -1789,8 +1807,8 @@
         });
     }
 
-    var cache$1 = new Cache({ max: 1 });
-    cache$1.on('del', function (v) {
+    var cache$2 = new Cache$1({ max: 1 });
+    cache$2.on('del', function (v) {
         if (v.r) {
             try {
                 revokeObjectURL(v.data.image.src);
@@ -1810,8 +1828,8 @@
             autoRevokeOnDel: typeof cacheOptions === 'object' ? cacheOptions.autoRevokeOnDel !== false : !!cacheOptions
         };
         return new Promise(function (resolve, reject) {
-            if (_cacheOptions.useCache && cache$1.has(img)) {
-                resolve(cache$1.get(img).data);
+            if (_cacheOptions.useCache && cache$2.has(img)) {
+                resolve(cache$2.get(img).data);
             }
             else {
                 loadImageWithBlob(img, false, ajaxOptions)
@@ -1829,7 +1847,7 @@
                         blob: blob
                     };
                     if (_cacheOptions.useCache) {
-                        cache$1.set(img, {
+                        cache$2.set(img, {
                             data: result,
                             r: _cacheOptions.autoRevokeOnDel
                         });
@@ -1841,8 +1859,8 @@
         });
     }
 
-    var cache = new Cache({ max: 1 });
-    cache.on('del', function (v) {
+    var cache$1 = new Cache$1({ max: 1 });
+    cache$1.on('del', function (v) {
         if (v.r) {
             try {
                 revokeObjectURL(v.data.src);
@@ -1858,8 +1876,8 @@
             autoRevokeOnDel: typeof cacheOptions === 'object' ? cacheOptions.autoRevokeOnDel !== false : !!cacheOptions
         };
         return new Promise(function (resolve, reject) {
-            if (_cacheOptions.useCache && cache.has(img)) {
-                resolve(cache.get(img).data);
+            if (_cacheOptions.useCache && cache$1.has(img)) {
+                resolve(cache$1.get(img).data);
             }
             else {
                 var imgIsBlob_1 = isBlob(img);
@@ -1870,7 +1888,7 @@
                 }
                 image_1.onload = function () {
                     if (_cacheOptions.useCache) {
-                        cache.set(img, {
+                        cache$1.set(img, {
                             data: image_1,
                             r: _cacheOptions.autoRevokeOnDel
                         });
@@ -1936,7 +1954,7 @@
         }
         return prefix;
     }
-    function randomString(len, optionalChars) {
+    function randomString$1(len, optionalChars) {
         if (len === void 0) { len = 0; }
         var realChars = typeof optionalChars === 'string' && optionalChars ? optionalChars : defaultChars;
         return internalRandomString(toNumber(len), realChars);
@@ -2225,10 +2243,380 @@
         return internalFindTreeSelect(tree, predicate, childrenField);
     }
 
-    var VERSION = "4.21.7";
+    var VERSION = "4.22.1";
+
+    // 随机字符串
+    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 (!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.21.7";
+    var version = "4.22.1";
 
+    exports.AsyncMemo = AsyncMemo;
     exports.VERSION = VERSION;
     exports.ajax = ajax;
     exports.blobToDataURL = blobToDataURL;
@@ -2282,7 +2670,7 @@
     exports.padZero = padZero;
     exports.parseIdCard = parseIdCard;
     exports.plus = plus;
-    exports.randomString = randomString;
+    exports.randomString = randomString$1;
     exports.replaceChar = replaceChar;
     exports.round = _round;
     exports.safeDate = safeDate;