rxtutils 1.1.4-beta.9 → 1.1.6

package/es/cache/index.d.ts

@@ -1,12 +1,11 @@
-import { IndexedDBStorage } from './indexDB.js';
-
+import { IndexedDBStorage } from './indexDB';
 /**
  * 缓存存储类型
  * - sessionStorage: 会话存储，浏览器关闭后清除
  * - localStorage: 本地存储，永久保存
  * - indexedDB: IndexedDB 数据库存储
  */
-type StorageType = "sessionStorage" | "localStorage" | "indexedDB";
+export type StorageType = 'sessionStorage' | 'localStorage' | 'indexedDB';
 /**
  * 缓存项接口定义
  * 定义了单个缓存项的数据结构
@@ -14,7 +13,7 @@ type StorageType = "sessionStorage" | "localStorage" | "indexedDB";
  * @template Param 缓存参数类型
  * @template Data 缓存数据类型
  */
-interface ICache<Param, Data> {
+export interface ICache<Param, Data> {
     /**
      * 缓存的参数
      * 用于标识和查找缓存项
@@ -28,7 +27,7 @@ interface ICache<Param, Data> {
     /**
      * 过期时间
      * - ISO 8601 格式的字符串
-     * - 由 moment().add(cacheTime, 'seconds').toJSON() 生成
+     * - 由 addSeconds(new Date(), cacheTime).toISOString() 生成
      * - 示例：'2025-06-12T10:30:00.000Z'
      */
     expireTime: string;
@@ -37,7 +36,7 @@ interface ICache<Param, Data> {
  * 缓存选项接口
  * @template Param 缓存参数类型
  */
-interface ICacheOptions<Param> {
+export interface ICacheOptions<Param> {
     /**
      * 存储类型
      * - 'sessionStorage': 会话存储，浏览器关闭后清除
@@ -77,13 +76,13 @@ interface ICacheOptions<Param> {
     indexDBName?: string;
 }
 /** 存储类型映射表 */
-declare const StorageMap: Record<StorageType | string, Storage>;
+export declare const StorageMap: Record<StorageType | string, Storage>;
 /**
  * 缓存类
  * @template Param 缓存参数类型
  * @template Data 缓存数据类型
  */
-declare class Cache<Param, Data> {
+export default class Cache<Param, Data> {
     /** 内存中的缓存数组 */
     cache: ICache<Param, Data>[];
     /** 缓存选项 */
@@ -123,19 +122,16 @@ declare class Cache<Param, Data> {
      * @param data 要缓存的数据
      * @param cacheOptions 可选的缓存配置，可以覆盖默认的缓存时间
      */
-    setCache(params: Param, data: Data, cacheOptions?: Omit<ICacheOptions<Param>, "storageType" | "cacheKey" | "cacheKeyEquals">): void;
+    setCache(params: Param, data: Data, cacheOptions?: Omit<ICacheOptions<Param>, 'storageType' | 'cacheKey' | 'cacheKeyEquals'>): void;
     /**
      * 获取缓存数据
      * @param params 查询参数
      * @returns 如果找到有效的缓存数据则返回数据，否则返回 null
      */
-    getCache(params: Param): Data;
+    getCache(params: Param): Data | null;
     /**
      * 清空所有缓存数据
      * 清空内存中的缓存数组并同步到存储中
      */
     clear(): void;
 }
-
-export { StorageMap, Cache as default };
-export type { ICache, ICacheOptions, StorageType };

package/es/cache/index.mjs

@@ -1,165 +1,137 @@
-import { __awaiter, __generator, __assign } from 'tslib';
-import moment from 'moment';
-import { IndexedDBStorage } from './indexDB.mjs';
-import defaultEquals from '../_utils/defaultEquals.mjs';
-
-/** 存储类型映射表 */
-var StorageMap = {
-    localStorage: localStorage,
-    sessionStorage: sessionStorage,
+import { isAfter, parseISO, addSeconds } from "date-fns";
+import { IndexedDBStorage } from "./indexDB.mjs";
+import defaultEquals from "../_utils/defaultEquals.mjs";
+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 IndexedDBStorage(indexDBName, "cacheStore");
-        }
-        else if (typeof cacheType === "string") {
-            this.storage = StorageMap[cacheType];
-        }
-        this._init();
-    }
-    /**
-     * 初始化缓存
-     * 从存储中加载已保存的缓存数据，并进行解析和过期处理
-     * @private
-     */
-    Cache.prototype._init = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var _a, cacheType, cacheKey, _b, _c, _d;
-            return __generator(this, function (_e) {
-                switch (_e.label) {
-                    case 0:
-                        _a = this.cacheOptions, cacheType = _a.storageType, cacheKey = _a.cacheKey;
-                        if (!(this.storage instanceof 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;
-    };
-    /**
-     * 将当前缓存数据保存到存储中
-     * 如果设置了缓存键名且存储实例存在，则将缓存数据序列化后保存
-     * @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 = __assign(__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();
+class Cache {
+  /**
+   * 构造函数
+   * @param cacheType 存储类型
+   * @param cacheKey 缓存键名
+   * @param cacheTime 缓存时间（秒）
+   * @param indexDBName IndexedDB 数据库名称，默认值为 '__apiCacheDatabase__'
+   * @param cacheKeyEquals 缓存键比较函数，默认使用 defaultEquals
+   */
+  constructor(cacheType, cacheKey, cacheTime, indexDBName = "__apiCacheDatabase__", cacheKeyEquals = defaultEquals) {
+    this.cache = [];
+    this.cacheOptions = {
+      storageType: cacheType,
+      cacheKey,
+      cacheTime,
+      indexDBName,
+      cacheKeyEquals
     };
-    /**
-     * 获取缓存数据
-     * @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 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 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 isAfter(parseISO(item.expireTime), /* @__PURE__ */ new Date());
+    });
+    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 } = {
+      ...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: addSeconds(/* @__PURE__ */ new Date(), cacheTime ?? 0).toISOString()
+    });
+    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 (isAfter(parseISO(item.expireTime), /* @__PURE__ */ new Date())) {
+        return item.data;
+      } else {
+        this.cache.splice(itemIndex, 1);
         this._saveToStorage();
-    };
-    return Cache;
-}());
-
-export { StorageMap, Cache as default };
+      }
+    }
+    return null;
+  }
+  /**
+   * 清空所有缓存数据
+   * 清空内存中的缓存数组并同步到存储中
+   */
+  clear() {
+    this.cache = [];
+    this._saveToStorage();
+  }
+}
+export {
+  StorageMap,
+  Cache as default
+};

package/es/cache/indexDB.d.ts

@@ -2,7 +2,7 @@
  * IndexedDB 存储类
  * 提供了对 IndexedDB 数据库操作的简单封装
  */
-declare class IndexedDBStorage {
+export declare class IndexedDBStorage {
     /** 数据库名称 */
     private dbName;
     /** 存储对象名称 */
@@ -48,5 +48,3 @@ declare class IndexedDBStorage {
      */
     getItem<T = any>(key: string): Promise<T>;
 }
-
-export { IndexedDBStorage };

package/es/cache/indexDB.mjs

@@ -1,98 +1,87 @@
-/**
- * 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;
-}());
-
-export { IndexedDBStorage };
+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}`);
+      });
+    });
+  }
+}
+export {
+  IndexedDBStorage
+};

package/es/downloadBlob.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @desc 通过创建 a 标签下载 blob 文件
+ * @param blob blob 文件
+ * @param fileName 下载后的文件名
+ * @param autoRevoke 是否自动回收 url
+ * @returns url
+ */
+export declare const downloadBlob: (blob: Blob, fileName: string, autoRevoke?: boolean) => string;

package/es/downloadBlob.mjs

@@ -0,0 +1,14 @@
+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;
+};
+export {
+  downloadBlob
+};

package/es/hooks/index.d.ts

@@ -1 +1 @@
-export { useCombineControlValue } from './useCombineControlValue.js';
+export { useCombineControlValue } from './useCombineControlValue';

package/es/hooks/index.mjs

@@ -1 +1,4 @@
-export { useCombineControlValue } from './useCombineControlValue.mjs';
+import { useCombineControlValue } from "./useCombineControlValue.mjs";
+export {
+  useCombineControlValue
+};

package/es/hooks/useCombineControlValue.d.ts

@@ -1,21 +1,18 @@
-type UseCombineControlValueOptions<V> = {
+export type UseCombineControlValueOptions<V> = {
     props: Record<string, any>;
     valueKey?: string;
     defaultValue?: V;
     onChange?: (val: V) => void;
 };
-type UseCombineControlValueEasyResult<V> = {
+export type UseCombineControlValueEasyResult<V> = {
     value: V;
     onChange: (nextVal: V) => void;
 };
-type UseCombineControlValueResolveResult<V, R extends (...args: any[]) => any> = {
+export type UseCombineControlValueResolveResult<V, R extends (...args: any[]) => any> = {
     value: V;
     onChange: (...args: Parameters<R>) => void;
 };
-declare function useCombineControlValue<V>(options: UseCombineControlValueOptions<V>): UseCombineControlValueEasyResult<V>;
-declare function useCombineControlValue<V, R extends (...args: any[]) => any>(options: Omit<UseCombineControlValueOptions<V>, 'onChange'> & {
+export declare function useCombineControlValue<V>(options: UseCombineControlValueOptions<V>): UseCombineControlValueEasyResult<V>;
+export declare function useCombineControlValue<V, R extends (...args: any[]) => any>(options: Omit<UseCombineControlValueOptions<V>, 'onChange'> & {
     onChange?: (...args: Parameters<R>) => void;
 }, resolveFn: (...args: Parameters<R>) => V): UseCombineControlValueResolveResult<V, R>;
-
-export { useCombineControlValue };
-export type { UseCombineControlValueEasyResult, UseCombineControlValueOptions, UseCombineControlValueResolveResult };