rxtutils 1.1.4-beta.14 → 1.1.4-beta.16

package/cjs/cache/index.cjs

@@ -2,13 +2,12 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var tslib = require('tslib');
 var moment = require('moment');
 var indexDB = require('./indexDB.cjs');
 var defaultEquals = require('../_utils/defaultEquals.cjs');
 
 /** 存储类型映射表 */
-var StorageMap = {
+const StorageMap = {
     localStorage: localStorage,
     sessionStorage: sessionStorage,
 };
@@ -17,7 +16,7 @@ var StorageMap = {
  * @template Param 缓存参数类型
  * @template Data 缓存数据类型
  */
-var Cache = /** @class */ (function () {
+class Cache {
     /**
      * 构造函数
      * @param cacheType 存储类型
@@ -26,17 +25,15 @@ var Cache = /** @class */ (function () {
      * @param indexDBName IndexedDB 数据库名称，默认值为 '__apiCacheDatabase__'
      * @param cacheKeyEquals 缓存键比较函数，默认使用 defaultEquals
      */
-    function Cache(cacheType, cacheKey, cacheTime, indexDBName, cacheKeyEquals) {
-        if (indexDBName === void 0) { indexDBName = "__apiCacheDatabase__"; }
-        if (cacheKeyEquals === void 0) { cacheKeyEquals = defaultEquals; }
+    constructor(cacheType, cacheKey, cacheTime, indexDBName = "__apiCacheDatabase__", cacheKeyEquals = defaultEquals) {
         /** 内存中的缓存数组 */
         this.cache = [];
         this.cacheOptions = {
             storageType: cacheType,
             cacheKey: cacheKey,
             cacheTime: cacheTime,
-            indexDBName: indexDBName,
-            cacheKeyEquals: cacheKeyEquals,
+            indexDBName,
+            cacheKeyEquals,
         };
         if (cacheType === "indexedDB") {
             this.storage = new indexDB.IndexedDBStorage(indexDBName, "cacheStore");
@@ -51,99 +48,85 @@ var Cache = /** @class */ (function () {
      * 从存储中加载已保存的缓存数据，并进行解析和过期处理
      * @private
      */
-    Cache.prototype._init = function () {
-        return tslib.__awaiter(this, void 0, void 0, function () {
-            var _a, cacheType, cacheKey, _b, _c, _d;
-            return tslib.__generator(this, function (_e) {
-                switch (_e.label) {
-                    case 0:
-                        _a = this.cacheOptions, cacheType = _a.storageType, cacheKey = _a.cacheKey;
-                        if (!(this.storage instanceof indexDB.IndexedDBStorage)) return [3 /*break*/, 2];
-                        _b = this;
-                        _d = (_c = JSON).parse;
-                        return [4 /*yield*/, this.storage.getItem(cacheKey)];
-                    case 1:
-                        _b.cache = _d.apply(_c, [(_e.sent()) || "[]"]);
-                        return [3 /*break*/, 3];
-                    case 2:
-                        if (this.storage instanceof Storage) {
-                            this.storage = StorageMap[cacheType];
-                            if (this.storage) {
-                                if (typeof cacheKey === "string") {
-                                    try {
-                                        this.cache = JSON.parse(this.storage.getItem(cacheKey) || "[]");
-                                    }
-                                    catch (e) {
-                                        this.cache = [];
-                                        console.error("\u7F13\u5B58\u6570\u636E\u89E3\u6790\u5931\u8D25\uFF0Ckey:".concat(cacheKey));
-                                    }
-                                }
-                            }
-                        }
-                        _e.label = 3;
-                    case 3:
-                        this._filterExpired();
-                        this._saveToStorage();
-                        return [2 /*return*/];
+    async _init() {
+        const { storageType: cacheType, cacheKey: cacheKey } = this.cacheOptions;
+        if (this.storage instanceof indexDB.IndexedDBStorage) {
+            this.cache = JSON.parse((await this.storage.getItem(cacheKey)) || "[]");
+        }
+        else if (this.storage instanceof Storage) {
+            this.storage = StorageMap[cacheType];
+            if (this.storage) {
+                if (typeof cacheKey === "string") {
+                    try {
+                        this.cache = JSON.parse(this.storage.getItem(cacheKey) || "[]");
+                    }
+                    catch (e) {
+                        this.cache = [];
+                        console.error(`缓存数据解析失败，key:${cacheKey}`);
+                    }
                 }
-            });
-        });
-    };
+            }
+        }
+        this._filterExpired();
+        this._saveToStorage();
+    }
     /**
      * 过滤掉已过期的缓存项
      * 通过比较当前时间和过期时间，移除过期的缓存项
      * @private
      */
-    Cache.prototype._filterExpired = function () {
-        var newCache = this.cache.filter(function (item) {
+    _filterExpired() {
+        const newCache = this.cache.filter((item) => {
             return moment(item.expireTime).isAfter(moment());
         });
         this.cache = newCache;
-    };
+    }
     /**
      * 将当前缓存数据保存到存储中
      * 如果设置了缓存键名且存储实例存在，则将缓存数据序列化后保存
      * @private
      */
-    Cache.prototype._saveToStorage = function () {
+    _saveToStorage() {
         if (this.storage) {
             if (typeof this.cacheOptions.cacheKey === "string") {
                 this.storage.setItem(this.cacheOptions.cacheKey, JSON.stringify(this.cache));
             }
         }
-    };
+    }
     /**
      * 设置缓存数据
      * @param params 缓存的参数
      * @param data 要缓存的数据
      * @param cacheOptions 可选的缓存配置，可以覆盖默认的缓存时间
      */
-    Cache.prototype.setCache = function (params, data, cacheOptions) {
-        var _a = tslib.__assign(tslib.__assign({}, this.cacheOptions), cacheOptions), cacheTime = _a.cacheTime, _b = _a.cacheKeyEquals, cacheKeyEquals = _b === void 0 ? defaultEquals : _b;
-        var cacheItemIndex = this.cache.findIndex(function (item) {
+    setCache(params, data, cacheOptions) {
+        const { cacheTime, cacheKeyEquals = defaultEquals } = {
+            ...this.cacheOptions,
+            ...cacheOptions,
+        };
+        const cacheItemIndex = this.cache.findIndex((item) => {
             return cacheKeyEquals(item.params, params);
         });
         if (cacheItemIndex > -1) {
             this.cache.splice(cacheItemIndex, 1);
         }
         this.cache.push({
-            params: params,
-            data: data,
+            params,
+            data,
             expireTime: moment().add(cacheTime, "seconds").toJSON(),
         });
         this._saveToStorage();
-    };
+    }
     /**
      * 获取缓存数据
      * @param params 查询参数
      * @returns 如果找到有效的缓存数据则返回数据，否则返回 null
      */
-    Cache.prototype.getCache = function (params) {
-        var _this = this;
-        var itemIndex = this.cache.findIndex(function (item) {
-            return _this.cacheOptions.cacheKeyEquals(item.params, params);
+    getCache(params) {
+        const itemIndex = this.cache.findIndex((item) => {
+            return this.cacheOptions.cacheKeyEquals(item.params, params);
         });
-        var item = this.cache[itemIndex];
+        const item = this.cache[itemIndex];
         if (item) {
             if (moment(item.expireTime).isAfter(moment())) {
                 return item.data;
@@ -154,17 +137,16 @@ var Cache = /** @class */ (function () {
             }
         }
         return null;
-    };
+    }
     /**
      * 清空所有缓存数据
      * 清空内存中的缓存数组并同步到存储中
      */
-    Cache.prototype.clear = function () {
+    clear() {
         this.cache = [];
         this._saveToStorage();
-    };
-    return Cache;
-}());
+    }
+}
 
 exports.StorageMap = StorageMap;
 exports.default = Cache;

package/cjs/cache/index.d.ts

@@ -129,7 +129,7 @@ declare class Cache<Param, Data> {
      * @param params 查询参数
      * @returns 如果找到有效的缓存数据则返回数据，否则返回 null
      */
-    getCache(params: Param): Data;
+    getCache(params: Param): Data | null;
     /**
      * 清空所有缓存数据
      * 清空内存中的缓存数组并同步到存储中

package/cjs/cache/indexDB.cjs

@@ -4,13 +4,13 @@
  * IndexedDB 存储类
  * 提供了对 IndexedDB 数据库操作的简单封装
  */
-var IndexedDBStorage = /** @class */ (function () {
+class IndexedDBStorage {
     /**
      * 构造函数
      * @param dbName 数据库名称
      * @param storeName 存储对象名称
      */
-    function IndexedDBStorage(dbName, storeName) {
+    constructor(dbName, storeName) {
         /** 数据库连接实例 */
         this.db = null;
         this.dbName = dbName;
@@ -22,28 +22,26 @@ var IndexedDBStorage = /** @class */ (function () {
      * @private
      * @returns Promise<IDBDatabase> 数据库连接实例
      */
-    IndexedDBStorage.prototype._open = function () {
-        var _this = this;
-        return new Promise(function (resolve, reject) {
-            if (_this.db) {
-                resolve(_this.db);
+    _open() {
+        return new Promise((resolve, reject) => {
+            if (this.db) {
+                resolve(this.db);
                 return;
             }
-            var request = indexedDB.open(_this.dbName);
-            request.onupgradeneeded = function (event) {
-                var db = event.target.result;
-                db.createObjectStore(_this.storeName, { keyPath: 'key' });
+            const request = indexedDB.open(this.dbName);
+            request.onupgradeneeded = (event) => {
+                const db = event.target.result;
+                db.createObjectStore(this.storeName, { keyPath: 'key' });
             };
-            request.onerror = function () {
-                var _a;
-                reject("IndexedDB open request error: ".concat((_a = request.error) === null || _a === void 0 ? void 0 : _a.message));
+            request.onerror = () => {
+                reject(`IndexedDB open request error: ${request.error?.message}`);
             };
-            request.onsuccess = function (event) {
-                _this.db = event.target.result;
-                resolve(_this.db);
+            request.onsuccess = (event) => {
+                this.db = event.target.result;
+                resolve(this.db);
             };
         });
-    };
+    }
     /**
      * 获取存储对象
      * @param mode 事务模式，默认为只读模式
@@ -52,14 +50,12 @@ var IndexedDBStorage = /** @class */ (function () {
      * @private
      * @returns Promise<IDBObjectStore> 存储对象实例
      */
-    IndexedDBStorage.prototype._getStore = function (mode) {
-        var _this = this;
-        if (mode === void 0) { mode = 'readonly'; }
-        return this._open().then(function (db) {
-            var transaction = db.transaction(_this.storeName, mode);
-            return transaction.objectStore(_this.storeName);
+    _getStore(mode = 'readonly') {
+        return this._open().then((db) => {
+            const transaction = db.transaction(this.storeName, mode);
+            return transaction.objectStore(this.storeName);
         });
-    };
+    }
     /**
      * 设置键值对
      * @param key 键名
@@ -67,15 +63,15 @@ var IndexedDBStorage = /** @class */ (function () {
      * @returns Promise<void> 存储操作的结果
      * @throws 当存储操作失败时抛出错误
      */
-    IndexedDBStorage.prototype.setItem = function (key, value) {
-        return this._getStore('readwrite').then(function (store) {
-            return new Promise(function (resolve, reject) {
-                var request = store.put({ key: key, value: value });
-                request.onsuccess = function () { return resolve(); };
-                request.onerror = function () { var _a; return reject("Could not set the item: ".concat((_a = request.error) === null || _a === void 0 ? void 0 : _a.message)); };
+    setItem(key, value) {
+        return this._getStore('readwrite').then((store) => {
+            return new Promise((resolve, reject) => {
+                const request = store.put({ key, value });
+                request.onsuccess = () => resolve();
+                request.onerror = () => reject(`Could not set the item: ${request.error?.message}`);
             });
         });
-    };
+    }
     /**
      * 获取键对应的值
      * @param key 要获取的键名
@@ -83,18 +79,15 @@ var IndexedDBStorage = /** @class */ (function () {
      * @throws 当获取操作失败时抛出错误
      * @template T 存储值的类型，默认为 any
      */
-    IndexedDBStorage.prototype.getItem = function (key) {
-        return this._getStore().then(function (store) {
-            return new Promise(function (resolve, reject) {
-                var request = store.get(key);
-                request.onsuccess = function () {
-                    return resolve(request.result ? request.result.value : undefined);
-                };
-                request.onerror = function () { var _a; return reject("Could not get the item: ".concat((_a = request.error) === null || _a === void 0 ? void 0 : _a.message)); };
+    getItem(key) {
+        return this._getStore().then((store) => {
+            return new Promise((resolve, reject) => {
+                const request = store.get(key);
+                request.onsuccess = () => resolve(request.result ? request.result.value : undefined);
+                request.onerror = () => reject(`Could not get the item: ${request.error?.message}`);
             });
         });
-    };
-    return IndexedDBStorage;
-}());
+    }
+}
 
 exports.IndexedDBStorage = IndexedDBStorage;

package/cjs/hooks/useCombineControlValue.cjs

@@ -9,27 +9,22 @@ var react = require('react');
  * @param param onChange 值改变时的回调
  * @returns value: 组件应该采用的值，onChange：值改变时的回调，处理非受控值与向父组件传递值的逻辑
  */
-function useCombineControlValue(_a, resolveFn) {
-    var props = _a.props, _b = _a.valueKey, valueKey = _b === void 0 ? 'value' : _b, defaultValue = _a.defaultValue, onChange = _a.onChange;
-    var _c = props, _d = valueKey, value = _c[_d];
-    var hasValue = Object.prototype.hasOwnProperty.call(props, valueKey);
-    var _e = react.useState(value !== null && value !== void 0 ? value : defaultValue), internalValue = _e[0], setInternalValue = _e[1];
-    var handleChange = react.useCallback(function () {
-        var params = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            params[_i] = arguments[_i];
-        }
-        var realNextVal;
+function useCombineControlValue({ props, valueKey = 'value', defaultValue, onChange }, resolveFn) {
+    const { [valueKey]: value } = props;
+    const hasValue = Object.prototype.hasOwnProperty.call(props, valueKey);
+    const [internalValue, setInternalValue] = react.useState(value ?? defaultValue);
+    const handleChange = react.useCallback((...params) => {
+        let realNextVal;
         if (typeof resolveFn === 'function') {
-            realNextVal = resolveFn.apply(void 0, params);
+            realNextVal = resolveFn(...params);
         }
         else {
             realNextVal = params[0];
         }
         setInternalValue(realNextVal);
-        onChange === null || onChange === void 0 ? void 0 : onChange.apply(void 0, params);
+        onChange?.(...params);
     }, [onChange, resolveFn]);
-    var finalValue = react.useMemo(function () {
+    const finalValue = react.useMemo(() => {
         if (hasValue)
             return value;
         return internalValue;

package/cjs/request/defaultHandlers.cjs

@@ -8,7 +8,7 @@
  * @param code 业务错误码
  */
 function _defaultErrorCodeHandler(defaultMessageShower, code) {
-    defaultMessageShower("\u8BF7\u6C42\u51FA\u9519\uFF0C\u9519\u8BEF\u7801\uFF1A".concat(code, "\uFF0C\u8BF7\u7A0D\u540E\u518D\u8BD5"));
+    defaultMessageShower(`请求出错，错误码：${code}，请稍后再试`);
 }
 /**
  * 默认 HTTP 错误码处理函数
@@ -18,7 +18,7 @@ function _defaultErrorCodeHandler(defaultMessageShower, code) {
  * @param code HTTP 状态码
  */
 function _defaultHttpErrorCodeHandler(defaultMessageShower, code) {
-    defaultMessageShower("\u670D\u52A1\u7AEF\u8BF7\u6C42\u51FA\u9519\uFF0CHttp\u9519\u8BEF\u7801\uFF1A".concat(String(code), "\uFF0C\u8BF7\u7A0D\u540E\u518D\u8BD5"));
+    defaultMessageShower(`服务端请求出错，Http错误码：${String(code)}，请稍后再试`);
 }
 /**
  * 默认其他错误处理函数
@@ -28,7 +28,7 @@ function _defaultHttpErrorCodeHandler(defaultMessageShower, code) {
  * @param error 错误对象
  */
 function _defaultOtherErrorCodeHandler(defaultMessageShower, error) {
-    defaultMessageShower("\u672A\u77E5\u8BF7\u6C42\u51FA\u9519\uFF0C\u8BF7\u7A0D\u540E\u518D\u8BD5");
+    defaultMessageShower(`未知请求出错，请稍后再试`);
 }
 
 exports._defaultErrorCodeHandler = _defaultErrorCodeHandler;

package/cjs/request/error.cjs

@@ -1,7 +1,5 @@
 'use strict';
 
-var tslib = require('tslib');
-
 /**
  * 请求错误类
  * 用于统一处理请求过程中的各种错误
@@ -9,22 +7,19 @@ var tslib = require('tslib');
  * @template Data 错误数据类型
  * @extends Error
  */
-var RequestError = /** @class */ (function (_super) {
-    tslib.__extends(RequestError, _super);
+class RequestError extends Error {
     /**
      * 构造函数
      * @param message 错误消息
      * @param type 错误类型
      * @param data 错误相关的数据
      */
-    function RequestError(message, type, data) {
-        var _this = _super.call(this, message) || this;
-        _this.name = 'RequestError';
-        _this.type = type;
-        _this.data = data;
-        return _this;
+    constructor(message, type, data) {
+        super(message);
+        this.name = 'RequestError';
+        this.type = type;
+        this.data = data;
     }
-    return RequestError;
-}(Error));
+}
 
 module.exports = RequestError;