rxtutils 1.1.4-beta.8 → 1.1.5

package/cjs/_utils/defaultEquals.cjs

@@ -1,21 +1,6 @@
-'use strict';
-
-/**
- * 默认的相等性比较函数
- * 通过将两个值序列化为 JSON 字符串来比较它们是否相等
- *
- * @template Param 比较值的类型，默认为 any
- * @param prev 前一个值
- * @param next 后一个值
- * @returns {boolean} 如果两个值相等则返回 true，否则返回 false
- *
- * @remarks
- * - 这个函数通过 JSON.stringify 进行比较，适用于大多数简单的数据结构
- * - 不适用于包含函数、undefined、Symbol 等无法序列化的值
- * - 对于循环引用的对象会抛出错误
- */
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
 function defaultEquals(prev, next) {
-    return JSON.stringify(prev) === JSON.stringify(next);
+  return JSON.stringify(prev) === JSON.stringify(next);
 }
-
-module.exports = defaultEquals;
+exports.default = defaultEquals;

package/cjs/cache/index.cjs

@@ -1,170 +1,144 @@
-'use strict';
-
-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 = {
-    localStorage: localStorage,
-    sessionStorage: sessionStorage,
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const moment = require("moment");
+const indexDB = require("./indexDB.cjs");
+const defaultEquals = require("../_utils/defaultEquals.cjs");
+const StorageMap = {
+  localStorage,
+  sessionStorage
 };
-/**
- * 缓存类
- * @template Param 缓存参数类型
- * @template Data 缓存数据类型
- */
-var Cache = /** @class */ (function () {
-    /**
-     * 构造函数
-     * @param cacheType 存储类型
-     * @param cacheKey 缓存键名
-     * @param cacheTime 缓存时间（秒）
-     * @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; }
-        /** 内存中的缓存数组 */
-        this.cache = [];
-        this.cacheOptions = {
-            storageType: cacheType,
-            cacheKey: cacheKey,
-            cacheTime: cacheTime,
-            indexDBName: indexDBName,
-            cacheKeyEquals: cacheKeyEquals,
-        };
-        if (cacheType === "indexedDB") {
-            this.storage = new indexDB.IndexedDBStorage(indexDBName, "cacheStore");
-        }
-        else if (typeof cacheType === "string") {
-            this.storage = StorageMap[cacheType];
-        }
-        this._init();
-    }
-    /**
-     * 初始化缓存
-     * 从存储中加载已保存的缓存数据，并进行解析和过期处理
-     * @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*/];
-                }
-            });
-        });
-    };
-    /**
-     * 过滤掉已过期的缓存项
-     * 通过比较当前时间和过期时间，移除过期的缓存项
-     * @private
-     */
-    Cache.prototype._filterExpired = function () {
-        var newCache = this.cache.filter(function (item) {
-            return moment(item.expireTime).isAfter(moment());
-        });
-        this.cache = newCache;
+class Cache {
+  /**
+   * 构造函数
+   * @param cacheType 存储类型
+   * @param cacheKey 缓存键名
+   * @param cacheTime 缓存时间（秒）
+   * @param indexDBName IndexedDB 数据库名称，默认值为 '__apiCacheDatabase__'
+   * @param cacheKeyEquals 缓存键比较函数，默认使用 defaultEquals
+   */
+  constructor(cacheType, cacheKey, cacheTime, indexDBName = "__apiCacheDatabase__", cacheKeyEquals = defaultEquals.default) {
+    this.cache = [];
+    this.cacheOptions = {
+      storageType: cacheType,
+      cacheKey,
+      cacheTime,
+      indexDBName,
+      cacheKeyEquals
     };
-    /**
-     * 将当前缓存数据保存到存储中
-     * 如果设置了缓存键名且存储实例存在，则将缓存数据序列化后保存
-     * @private
-     */
-    Cache.prototype._saveToStorage = function () {
-        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) {
-            return cacheKeyEquals(item.params, params);
-        });
-        if (cacheItemIndex > -1) {
-            this.cache.splice(cacheItemIndex, 1);
-        }
-        this.cache.push({
-            params: params,
-            data: 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);
-        });
-        var item = this.cache[itemIndex];
-        if (item) {
-            if (moment(item.expireTime).isAfter(moment())) {
-                return item.data;
-            }
-            else {
-                this.cache.splice(itemIndex, 1);
-                this._saveToStorage();
-            }
+    if (cacheType === "indexedDB") {
+      this.storage = new indexDB.IndexedDBStorage(indexDBName, "cacheStore");
+    } else if (typeof cacheType === "string") {
+      this.storage = StorageMap[cacheType];
+    }
+    this._init();
+  }
+  /**
+   * 初始化缓存
+   * 从存储中加载已保存的缓存数据，并进行解析和过期处理
+   * @private
+   */
+  async _init() {
+    const { storageType: cacheType, 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}`);
+          }
         }
-        return null;
+      }
+    }
+    this._filterExpired();
+    this._saveToStorage();
+  }
+  /**
+   * 过滤掉已过期的缓存项
+   * 通过比较当前时间和过期时间，移除过期的缓存项
+   * @private
+   */
+  _filterExpired() {
+    const newCache = this.cache.filter((item) => {
+      return moment(item.expireTime).isAfter(moment());
+    });
+    this.cache = newCache;
+  }
+  /**
+   * 将当前缓存数据保存到存储中
+   * 如果设置了缓存键名且存储实例存在，则将缓存数据序列化后保存
+   * @private
+   */
+  _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 可选的缓存配置，可以覆盖默认的缓存时间
+   */
+  setCache(params, data, cacheOptions) {
+    const { cacheTime, cacheKeyEquals = defaultEquals.default } = {
+      ...this.cacheOptions,
+      ...cacheOptions
     };
-    /**
-     * 清空所有缓存数据
-     * 清空内存中的缓存数组并同步到存储中
-     */
-    Cache.prototype.clear = function () {
-        this.cache = [];
+    const cacheItemIndex = this.cache.findIndex((item) => {
+      return cacheKeyEquals(item.params, params);
+    });
+    if (cacheItemIndex > -1) {
+      this.cache.splice(cacheItemIndex, 1);
+    }
+    this.cache.push({
+      params,
+      data,
+      expireTime: moment().add(cacheTime, "seconds").toJSON()
+    });
+    this._saveToStorage();
+  }
+  /**
+   * 获取缓存数据
+   * @param params 查询参数
+   * @returns 如果找到有效的缓存数据则返回数据，否则返回 null
+   */
+  getCache(params) {
+    const itemIndex = this.cache.findIndex((item2) => {
+      return this.cacheOptions.cacheKeyEquals(item2.params, params);
+    });
+    const item = this.cache[itemIndex];
+    if (item) {
+      if (moment(item.expireTime).isAfter(moment())) {
+        return item.data;
+      } else {
+        this.cache.splice(itemIndex, 1);
         this._saveToStorage();
-    };
-    return Cache;
-}());
-
+      }
+    }
+    return null;
+  }
+  /**
+   * 清空所有缓存数据
+   * 清空内存中的缓存数组并同步到存储中
+   */
+  clear() {
+    this.cache = [];
+    this._saveToStorage();
+  }
+}
 exports.StorageMap = StorageMap;
 exports.default = Cache;

package/cjs/cache/indexDB.cjs

@@ -1,100 +1,87 @@
-'use strict';
-
-/**
- * IndexedDB 存储类
- * 提供了对 IndexedDB 数据库操作的简单封装
- */
-var IndexedDBStorage = /** @class */ (function () {
-    /**
-     * 构造函数
-     * @param dbName 数据库名称
-     * @param storeName 存储对象名称
-     */
-    function IndexedDBStorage(dbName, storeName) {
-        /** 数据库连接实例 */
-        this.db = null;
-        this.dbName = dbName;
-        this.storeName = storeName;
-    }
-    /**
-     * 打开数据库连接
-     * 如果数据库不存在则创建新的数据库和存储对象
-     * @private
-     * @returns Promise<IDBDatabase> 数据库连接实例
-     */
-    IndexedDBStorage.prototype._open = function () {
-        var _this = this;
-        return new Promise(function (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' });
-            };
-            request.onerror = function () {
-                var _a;
-                reject("IndexedDB open request error: ".concat((_a = request.error) === null || _a === void 0 ? void 0 : _a.message));
-            };
-            request.onsuccess = function (event) {
-                _this.db = event.target.result;
-                resolve(_this.db);
-            };
-        });
-    };
-    /**
-     * 获取存储对象
-     * @param mode 事务模式，默认为只读模式
-     * - readonly: 只读模式
-     * - readwrite: 读写模式
-     * @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);
-        });
-    };
-    /**
-     * 设置键值对
-     * @param key 键名
-     * @param value 要存储的值
-     * @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)); };
-            });
-        });
-    };
-    /**
-     * 获取键对应的值
-     * @param key 要获取的键名
-     * @returns Promise<T> 返回存储的值，如果不存在则返回 undefined
-     * @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)); };
-            });
-        });
-    };
-    return IndexedDBStorage;
-}());
-
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+class IndexedDBStorage {
+  /**
+   * 构造函数
+   * @param dbName 数据库名称
+   * @param storeName 存储对象名称
+   */
+  constructor(dbName, storeName) {
+    this.db = null;
+    this.dbName = dbName;
+    this.storeName = storeName;
+  }
+  /**
+   * 打开数据库连接
+   * 如果数据库不存在则创建新的数据库和存储对象
+   * @private
+   * @returns Promise<IDBDatabase> 数据库连接实例
+   */
+  _open() {
+    return new Promise((resolve, reject) => {
+      if (this.db) {
+        resolve(this.db);
+        return;
+      }
+      const request = indexedDB.open(this.dbName);
+      request.onupgradeneeded = (event) => {
+        const db = event.target.result;
+        db.createObjectStore(this.storeName, { keyPath: "key" });
+      };
+      request.onerror = () => {
+        reject(`IndexedDB open request error: ${request.error?.message}`);
+      };
+      request.onsuccess = (event) => {
+        this.db = event.target.result;
+        resolve(this.db);
+      };
+    });
+  }
+  /**
+   * 获取存储对象
+   * @param mode 事务模式，默认为只读模式
+   * - readonly: 只读模式
+   * - readwrite: 读写模式
+   * @private
+   * @returns Promise<IDBObjectStore> 存储对象实例
+   */
+  _getStore(mode = "readonly") {
+    return this._open().then((db) => {
+      const transaction = db.transaction(this.storeName, mode);
+      return transaction.objectStore(this.storeName);
+    });
+  }
+  /**
+   * 设置键值对
+   * @param key 键名
+   * @param value 要存储的值
+   * @returns Promise<void> 存储操作的结果
+   * @throws 当存储操作失败时抛出错误
+   */
+  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 要获取的键名
+   * @returns Promise<T> 返回存储的值，如果不存在则返回 undefined
+   * @throws 当获取操作失败时抛出错误
+   * @template T 存储值的类型，默认为 any
+   */
+  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 : void 0);
+        request.onerror = () => reject(`Could not get the item: ${request.error?.message}`);
+      });
+    });
+  }
+}
 exports.IndexedDBStorage = IndexedDBStorage;

package/cjs/downloadBlob.cjs

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const downloadBlob = (blob, fileName, autoRevoke = true) => {
+  const url = URL.createObjectURL(blob);
+  const a = document.createElement("a");
+  a.href = url;
+  a.download = fileName;
+  a.click();
+  if (autoRevoke) {
+    URL.revokeObjectURL(url);
+  }
+  return url;
+};
+exports.downloadBlob = downloadBlob;

package/cjs/hooks/index.cjs

@@ -1,7 +1,4 @@
-'use strict';
-
-var useCombineControlValue = require('./useCombineControlValue.cjs');
-
-
-
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const useCombineControlValue = require("./useCombineControlValue.cjs");
 exports.useCombineControlValue = useCombineControlValue.useCombineControlValue;

package/cjs/hooks/useCombineControlValue.cjs

@@ -1,43 +1,32 @@
-'use strict';
-
-var react = require('react');
-
-/**
- * @param param props 组件属性
- * @param param valueKey 组件值的key，默认value, undefined 被认为是有值，只有当 key 不存在时，转换为非受控模式
- * @param param defaultValue 默认值，当 value 和 defaultValue 同时存在时，以 value 为默认值
- * @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;
-        if (typeof resolveFn === 'function') {
-            realNextVal = resolveFn.apply(void 0, params);
-        }
-        else {
-            realNextVal = params[0];
-        }
-        setInternalValue(realNextVal);
-        onChange === null || onChange === void 0 ? void 0 : onChange.apply(void 0, params);
-    }, [onChange, resolveFn]);
-    var finalValue = react.useMemo(function () {
-        if (hasValue)
-            return value;
-        return internalValue;
-    }, [hasValue, internalValue, value]);
-    return {
-        value: finalValue,
-        onChange: handleChange
-    };
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const react = require("react");
+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(...params);
+    } else {
+      realNextVal = params[0];
+    }
+    setInternalValue(realNextVal);
+    onChange?.(...params);
+  }, [onChange, resolveFn]);
+  const finalValue = react.useMemo(() => {
+    if (hasValue) return value;
+    return internalValue;
+  }, [hasValue, internalValue, value]);
+  return {
+    value: finalValue,
+    onChange: handleChange
+  };
 }
-
 exports.useCombineControlValue = useCombineControlValue;