rxtutils 1.0.8 → 1.1.0

package/dist/cjs/cache/index.cjs

@@ -7,14 +7,21 @@ var moment = require('moment');
 var indexDB = require('./indexDB.cjs');
 var defaultEquals = require('../defaultEquals.cjs');
 
+/** 存储类型映射表 */
 var StorageMap = {
     localStorage: localStorage,
     sessionStorage: sessionStorage,
 };
+/**
+ * 缓存类
+ * @template Param 缓存参数类型
+ * @template Data 缓存数据类型
+ */
 var Cache = /** @class */ (function () {
     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,
@@ -31,6 +38,11 @@ var Cache = /** @class */ (function () {
         }
         this._init();
     }
+    /**
+     * 初始化缓存
+     * 从存储中加载已保存的缓存数据，并进行解析和过期处理
+     * @private
+     */
     Cache.prototype._init = function () {
         return tslib_es6_js.__awaiter(this, void 0, void 0, function () {
             var _a, cacheType, cacheKey, _b, _c, _d;
@@ -68,20 +80,33 @@ var Cache = /** @class */ (function () {
                 }
             });
         });
-    };
+    }; /**
+     * 过滤掉已过期的缓存项
+     * 通过比较当前时间和过期时间，移除过期的缓存项
+     * @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 = tslib_es6_js.__assign(tslib_es6_js.__assign({}, this.cacheOptions), cacheOptions), cacheTime = _a.cacheTime, _b = _a.cacheKeyEquals, cacheKeyEquals = _b === void 0 ? defaultEquals : _b;
         var cacheItemIndex = this.cache.findIndex(function (item) {
@@ -96,10 +121,13 @@ var Cache = /** @class */ (function () {
             expireTime: moment().add(cacheTime, 'seconds').toJSON(),
         });
         this._saveToStorage();
-    };
+    }; /**
+     * 获取缓存数据
+     * @param params 查询参数
+     * @returns 如果找到有效的缓存数据则返回数据，否则返回 null
+     */
     Cache.prototype.getCache = function (params) {
         var _this = this;
-        // debugger;
         var itemIndex = this.cache.findIndex(function (item) {
             return _this.cacheOptions.cacheKeyEquals(item.params, params);
         });
@@ -114,7 +142,10 @@ var Cache = /** @class */ (function () {
             }
         }
         return null;
-    };
+    }; /**
+     * 清空所有缓存数据
+     * 清空内存中的缓存数组并同步到存储中
+     */
     Cache.prototype.clear = function () {
         this.cache = [];
         this._saveToStorage();

package/dist/cjs/cache/indexDB.cjs

@@ -1,13 +1,27 @@
 'use strict';
 
-// IndexedDB的简易封装类
+/**
+ * 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) {
@@ -30,7 +44,14 @@ var IndexedDBStorage = /** @class */ (function () {
             };
         });
     };
-    // 获取存储对象
+    /**
+     * 获取存储对象
+     * @param mode 事务模式，默认为只读模式
+     * - readonly: 只读模式
+     * - readwrite: 读写模式
+     * @private
+     * @returns Promise<IDBObjectStore> 存储对象实例
+     */
     IndexedDBStorage.prototype._getStore = function (mode) {
         var _this = this;
         if (mode === void 0) { mode = 'readonly'; }
@@ -39,7 +60,13 @@ var IndexedDBStorage = /** @class */ (function () {
             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) {
@@ -49,7 +76,13 @@ var IndexedDBStorage = /** @class */ (function () {
             });
         });
     };
-    // 获取键对应的值
+    /**
+     * 获取键对应的值
+     * @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) {

package/dist/cjs/createStateStore/index.cjs

@@ -12,12 +12,33 @@ function resolveHookState(nextState, currentState) {
     }
     return nextState;
 }
+/** 判断当前环境是否为浏览器 */
 var isBrowser = typeof window !== 'undefined';
+/**
+ * 只执行一次的 useEffect hook
+ * @param effect 要执行的副作用函数
+ */
 var useEffectOnce = function (effect) {
     react.useEffect(effect, []);
 };
+/**
+ * 同构的 useLayoutEffect
+ * 在服务端渲染时使用 useEffect，在浏览器环境使用 useLayoutEffect
+ */
 var useIsomorphicLayoutEffect = isBrowser ? react.useLayoutEffect : react.useEffect;
+/**
+ * 创建状态存储
+ * 提供一个简单的状态管理解决方案，支持组件间状态共享
+ *
+ * @template S 状态类型
+ * @param initialState 初始状态值或初始化函数
+ * @returns 包含状态操作方法的对象
+ */
 function createStateStore(initialState) {
+    /**
+     * 状态存储对象
+     * 包含当前状态、设置状态的方法、状态更新器和监听器列表
+     */
     var store = {
         state: initialState instanceof Function ? initialState() : initialState,
         setState: function (nextState) {
@@ -28,11 +49,20 @@ function createStateStore(initialState) {
         setters: [],
         watchers: [],
     };
+    /**
+     * 使用状态的 Hook
+     * 返回当前状态和更新状态的函数
+     *
+     * @returns [当前状态, 状态更新函数]
+     */
     var use = function () {
+        // 使用 React 的 useState 创建组件本地状态
         var _a = react.useState(store.state), globalState = _a[0], stateSetter = _a[1];
+        // 组件卸载时清理状态更新器
         useEffectOnce(function () { return function () {
             store.setters = store.setters.filter(function (setter) { return setter !== stateSetter; });
         }; });
+        // 在组件挂载和更新时注册状态更新器
         useIsomorphicLayoutEffect(function () {
             if (!store.setters.includes(stateSetter)) {
                 store.setters.push(stateSetter);
@@ -40,8 +70,15 @@ function createStateStore(initialState) {
         });
         return [globalState, store.setState];
     };
+    /** 获取当前状态值 */
     var get = function () { return store.state; };
+    /** 设置状态的函数引用 */
     var set = store.setState;
+    /**
+     * 监听状态变化
+     * @param callback 状态变化时的回调函数
+     * @returns 取消监听的函数
+     */
     var watch = function (callback) {
         store.watchers.push(callback);
         var close = function () {

package/dist/cjs/defaultEquals.cjs

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

package/dist/cjs/request/defaultHandlers.cjs

@@ -1,11 +1,32 @@
 'use strict';
 
+/**
+ * 默认业务错误码处理函数
+ * 用于处理业务错误码的默认行为
+ *
+ * @param defaultMessageShower 消息展示函数
+ * @param code 业务错误码
+ */
 function _defaultErrorCodeHandler(defaultMessageShower, code) {
     defaultMessageShower("\u8BF7\u6C42\u51FA\u9519\uFF0C\u9519\u8BEF\u7801\uFF1A".concat(code, "\uFF0C\u8BF7\u7A0D\u540E\u518D\u8BD5"));
 }
+/**
+ * 默认 HTTP 错误码处理函数
+ * 用于处理 HTTP 状态码错误的默认行为
+ *
+ * @param defaultMessageShower 消息展示函数
+ * @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"));
 }
+/**
+ * 默认其他错误处理函数
+ * 用于处理未知错误或非标准错误的默认行为
+ *
+ * @param defaultMessageShower 消息展示函数
+ * @param error 错误对象
+ */
 function _defaultOtherErrorCodeHandler(defaultMessageShower, error) {
     defaultMessageShower("\u672A\u77E5\u8BF7\u6C42\u51FA\u9519\uFF0C\u8BF7\u7A0D\u540E\u518D\u8BD5");
 }

package/dist/cjs/request/error.cjs

@@ -2,8 +2,21 @@
 
 var tslib_es6_js = require('C:\\Users\\ruixutong\\code\\RUtils\\node_modules\\tslib\\tslib.es6.js');
 
+/**
+ * 请求错误类
+ * 用于统一处理请求过程中的各种错误
+ *
+ * @template Data 错误数据类型
+ * @extends Error
+ */
 var RequestError = /** @class */ (function (_super) {
     tslib_es6_js.__extends(RequestError, _super);
+    /**
+     * 构造函数
+     * @param message 错误消息
+     * @param type 错误类型
+     * @param data 错误相关的数据
+     */
     function RequestError(message, type, data) {
         var _this = _super.call(this, message) || this;
         _this.name = 'RequestError';

package/dist/cjs/request/index.cjs

@@ -8,23 +8,40 @@ var defaultEquals = require('../defaultEquals.cjs');
 var index = require('../cache/index.cjs');
 var error = require('./error.cjs');
 
+/**
+ * 创建基础请求实例
+ * @param baseOptions 基础配置选项
+ * @returns 请求创建函数
+ */
 function createBaseRequest(baseOptions) {
     var baseURL = Object(baseOptions).baseURL;
-    // 创建新的 Axios 实例
+    // 创建新的 Axios 实例并配置基础URL和跨域凭证
     var instance = axios.create({
         baseURL: baseURL,
         withCredentials: true,
     });
+    /**
+     * 创建请求函数
+     * @template Param 请求参数类型
+     * @template Data 响应数据类型，必须是对象类型
+     * @param requestOptions 请求配置
+     * @param createOptions 创建选项（覆盖基础配置）
+     * @returns 发送请求的函数
+     */
     return function createRequest(requestOptions, createOptions) {
         var _a = tslib_es6_js.__assign({}, requestOptions), method = _a.method, url = _a.url;
         var _b = tslib_es6_js.__assign(tslib_es6_js.__assign({}, baseOptions), createOptions), baseURL = _b.baseURL, _c = _b.cacheDataKey, cacheDataKey = _c === void 0 ? "".concat(method, ":").concat(baseURL).concat(url) : _c, cacheDataInStorage = _b.cacheDataInStorage, _d = _b.cacheKeyEquals, cacheKeyEquals = _d === void 0 ? defaultEquals : _d, cacheTime = _b.cacheTime, _e = _b.indexDBName, indexDBName = _e === void 0 ? '__apiCacheDatabase__' : _e;
         var cache = new index.default(cacheDataInStorage, cacheDataKey, cacheTime, indexDBName, cacheKeyEquals);
         function request(requestParam, options) {
             var _a = tslib_es6_js.__assign(tslib_es6_js.__assign({}, requestOptions), requestParam), method = _a.method, url = _a.url, _b = _a.data, data = _b === void 0 ? {} : _b, _c = _a.params, params = _c === void 0 ? {} : _c;
+            var requestDataOrParams = params;
+            if (method.toLowerCase() === 'post') {
+                requestDataOrParams = data;
+            }
             var _d = tslib_es6_js.__assign(tslib_es6_js.__assign(tslib_es6_js.__assign({}, baseOptions), createOptions), options).defaultMessageShower, defaultMessageShower = _d === void 0 ? alert : _d;
             var _e = tslib_es6_js.__assign(tslib_es6_js.__assign(tslib_es6_js.__assign({}, baseOptions), createOptions), options), _f = _e.enableCache, enableCache = _f === void 0 ? false : _f, _g = _e.cacheData, cacheData = _g === void 0 ? false : _g, _h = _e.defaultErrorCodeHandler, defaultErrorCodeHandler = _h === void 0 ? defaultHandlers._defaultErrorCodeHandler.bind(null, defaultMessageShower) : _h, _j = _e.defaultHttpErrorCodeHandler, defaultHttpErrorCodeHandler = _j === void 0 ? defaultHandlers._defaultHttpErrorCodeHandler.bind(null, defaultMessageShower) : _j, _k = _e.otherErrorHandler, otherErrorHandler = _k === void 0 ? defaultHandlers._defaultOtherErrorCodeHandler.bind(null, defaultMessageShower) : _k, _l = _e.errorCodePath, errorCodePath = _l === void 0 ? 'code' : _l, _m = _e.cacheTime, cacheTime = _m === void 0 ? 60 : _m, _o = _e.errorCodeMap, errorCodeMap = _o === void 0 ? {} : _o, _p = _e.successCodes, successCodes = _p === void 0 ? ['0', '200'] : _p, _q = _e.httpErrorCodeMap, httpErrorCodeMap = _q === void 0 ? {} : _q, _r = _e.axiosOptions, axiosOptions = _r === void 0 ? {} : _r, _s = _e.throwError, throwError = _s === void 0 ? true : _s;
             if (enableCache) {
-                var cacheItem = cache.getCache(params);
+                var cacheItem = cache.getCache(requestDataOrParams);
                 if (cacheItem) {
                     return Promise.resolve(cacheItem);
                 }
@@ -35,7 +52,7 @@ function createBaseRequest(baseOptions) {
                 var errorCode = String(lodash.at(res.data, errorCodePath));
                 if (successCodes.includes(errorCode)) {
                     if (cacheData) {
-                        cache.setCache(params, res.data, { cacheTime: cacheTime });
+                        cache.setCache(requestDataOrParams, res.data, { cacheTime: cacheTime });
                     }
                     return res.data;
                 }

package/dist/es/cache/index.mjs

@@ -3,14 +3,21 @@ import moment from 'moment';
 import { IndexedDBStorage } from './indexDB.mjs';
 import defaultEquals from '../defaultEquals.mjs';
 
+/** 存储类型映射表 */
 var StorageMap = {
     localStorage: localStorage,
     sessionStorage: sessionStorage,
 };
+/**
+ * 缓存类
+ * @template Param 缓存参数类型
+ * @template Data 缓存数据类型
+ */
 var Cache = /** @class */ (function () {
     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,
@@ -27,6 +34,11 @@ var Cache = /** @class */ (function () {
         }
         this._init();
     }
+    /**
+     * 初始化缓存
+     * 从存储中加载已保存的缓存数据，并进行解析和过期处理
+     * @private
+     */
     Cache.prototype._init = function () {
         return __awaiter(this, void 0, void 0, function () {
             var _a, cacheType, cacheKey, _b, _c, _d;
@@ -64,20 +76,33 @@ var Cache = /** @class */ (function () {
                 }
             });
         });
-    };
+    }; /**
+     * 过滤掉已过期的缓存项
+     * 通过比较当前时间和过期时间，移除过期的缓存项
+     * @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) {
@@ -92,10 +117,13 @@ var Cache = /** @class */ (function () {
             expireTime: moment().add(cacheTime, 'seconds').toJSON(),
         });
         this._saveToStorage();
-    };
+    }; /**
+     * 获取缓存数据
+     * @param params 查询参数
+     * @returns 如果找到有效的缓存数据则返回数据，否则返回 null
+     */
     Cache.prototype.getCache = function (params) {
         var _this = this;
-        // debugger;
         var itemIndex = this.cache.findIndex(function (item) {
             return _this.cacheOptions.cacheKeyEquals(item.params, params);
         });
@@ -110,7 +138,10 @@ var Cache = /** @class */ (function () {
             }
         }
         return null;
-    };
+    }; /**
+     * 清空所有缓存数据
+     * 清空内存中的缓存数组并同步到存储中
+     */
     Cache.prototype.clear = function () {
         this.cache = [];
         this._saveToStorage();

package/dist/es/cache/indexDB.mjs

@@ -1,11 +1,25 @@
-// IndexedDB的简易封装类
+/**
+ * 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) {
@@ -28,7 +42,14 @@ var IndexedDBStorage = /** @class */ (function () {
             };
         });
     };
-    // 获取存储对象
+    /**
+     * 获取存储对象
+     * @param mode 事务模式，默认为只读模式
+     * - readonly: 只读模式
+     * - readwrite: 读写模式
+     * @private
+     * @returns Promise<IDBObjectStore> 存储对象实例
+     */
     IndexedDBStorage.prototype._getStore = function (mode) {
         var _this = this;
         if (mode === void 0) { mode = 'readonly'; }
@@ -37,7 +58,13 @@ var IndexedDBStorage = /** @class */ (function () {
             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) {
@@ -47,7 +74,13 @@ var IndexedDBStorage = /** @class */ (function () {
             });
         });
     };
-    // 获取键对应的值
+    /**
+     * 获取键对应的值
+     * @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) {

package/dist/es/createStateStore/index.mjs

@@ -8,12 +8,33 @@ function resolveHookState(nextState, currentState) {
     }
     return nextState;
 }
+/** 判断当前环境是否为浏览器 */
 var isBrowser = typeof window !== 'undefined';
+/**
+ * 只执行一次的 useEffect hook
+ * @param effect 要执行的副作用函数
+ */
 var useEffectOnce = function (effect) {
     useEffect(effect, []);
 };
+/**
+ * 同构的 useLayoutEffect
+ * 在服务端渲染时使用 useEffect，在浏览器环境使用 useLayoutEffect
+ */
 var useIsomorphicLayoutEffect = isBrowser ? useLayoutEffect : useEffect;
+/**
+ * 创建状态存储
+ * 提供一个简单的状态管理解决方案，支持组件间状态共享
+ *
+ * @template S 状态类型
+ * @param initialState 初始状态值或初始化函数
+ * @returns 包含状态操作方法的对象
+ */
 function createStateStore(initialState) {
+    /**
+     * 状态存储对象
+     * 包含当前状态、设置状态的方法、状态更新器和监听器列表
+     */
     var store = {
         state: initialState instanceof Function ? initialState() : initialState,
         setState: function (nextState) {
@@ -24,11 +45,20 @@ function createStateStore(initialState) {
         setters: [],
         watchers: [],
     };
+    /**
+     * 使用状态的 Hook
+     * 返回当前状态和更新状态的函数
+     *
+     * @returns [当前状态, 状态更新函数]
+     */
     var use = function () {
+        // 使用 React 的 useState 创建组件本地状态
         var _a = useState(store.state), globalState = _a[0], stateSetter = _a[1];
+        // 组件卸载时清理状态更新器
         useEffectOnce(function () { return function () {
             store.setters = store.setters.filter(function (setter) { return setter !== stateSetter; });
         }; });
+        // 在组件挂载和更新时注册状态更新器
         useIsomorphicLayoutEffect(function () {
             if (!store.setters.includes(stateSetter)) {
                 store.setters.push(stateSetter);
@@ -36,8 +66,15 @@ function createStateStore(initialState) {
         });
         return [globalState, store.setState];
     };
+    /** 获取当前状态值 */
     var get = function () { return store.state; };
+    /** 设置状态的函数引用 */
     var set = store.setState;
+    /**
+     * 监听状态变化
+     * @param callback 状态变化时的回调函数
+     * @returns 取消监听的函数
+     */
     var watch = function (callback) {
         store.watchers.push(callback);
         var close = function () {

package/dist/es/defaultEquals.mjs

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

package/dist/es/request/defaultHandlers.mjs

@@ -1,9 +1,30 @@
+/**
+ * 默认业务错误码处理函数
+ * 用于处理业务错误码的默认行为
+ *
+ * @param defaultMessageShower 消息展示函数
+ * @param code 业务错误码
+ */
 function _defaultErrorCodeHandler(defaultMessageShower, code) {
     defaultMessageShower("\u8BF7\u6C42\u51FA\u9519\uFF0C\u9519\u8BEF\u7801\uFF1A".concat(code, "\uFF0C\u8BF7\u7A0D\u540E\u518D\u8BD5"));
 }
+/**
+ * 默认 HTTP 错误码处理函数
+ * 用于处理 HTTP 状态码错误的默认行为
+ *
+ * @param defaultMessageShower 消息展示函数
+ * @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"));
 }
+/**
+ * 默认其他错误处理函数
+ * 用于处理未知错误或非标准错误的默认行为
+ *
+ * @param defaultMessageShower 消息展示函数
+ * @param error 错误对象
+ */
 function _defaultOtherErrorCodeHandler(defaultMessageShower, error) {
     defaultMessageShower("\u672A\u77E5\u8BF7\u6C42\u51FA\u9519\uFF0C\u8BF7\u7A0D\u540E\u518D\u8BD5");
 }

package/dist/es/request/error.mjs

@@ -1,7 +1,20 @@
 import { __extends } from 'C:\\Users\\ruixutong\\code\\RUtils\\node_modules\\tslib\\tslib.es6.js';
 
+/**
+ * 请求错误类
+ * 用于统一处理请求过程中的各种错误
+ *
+ * @template Data 错误数据类型
+ * @extends Error
+ */
 var RequestError = /** @class */ (function (_super) {
     __extends(RequestError, _super);
+    /**
+     * 构造函数
+     * @param message 错误消息
+     * @param type 错误类型
+     * @param data 错误相关的数据
+     */
     function RequestError(message, type, data) {
         var _this = _super.call(this, message) || this;
         _this.name = 'RequestError';

package/dist/es/request/index.mjs

@@ -6,23 +6,40 @@ import defaultEquals from '../defaultEquals.mjs';
 import Cache from '../cache/index.mjs';
 import RequestError from './error.mjs';
 
+/**
+ * 创建基础请求实例
+ * @param baseOptions 基础配置选项
+ * @returns 请求创建函数
+ */
 function createBaseRequest(baseOptions) {
     var baseURL = Object(baseOptions).baseURL;
-    // 创建新的 Axios 实例
+    // 创建新的 Axios 实例并配置基础URL和跨域凭证
     var instance = axios.create({
         baseURL: baseURL,
         withCredentials: true,
     });
+    /**
+     * 创建请求函数
+     * @template Param 请求参数类型
+     * @template Data 响应数据类型，必须是对象类型
+     * @param requestOptions 请求配置
+     * @param createOptions 创建选项（覆盖基础配置）
+     * @returns 发送请求的函数
+     */
     return function createRequest(requestOptions, createOptions) {
         var _a = __assign({}, requestOptions), method = _a.method, url = _a.url;
         var _b = __assign(__assign({}, baseOptions), createOptions), baseURL = _b.baseURL, _c = _b.cacheDataKey, cacheDataKey = _c === void 0 ? "".concat(method, ":").concat(baseURL).concat(url) : _c, cacheDataInStorage = _b.cacheDataInStorage, _d = _b.cacheKeyEquals, cacheKeyEquals = _d === void 0 ? defaultEquals : _d, cacheTime = _b.cacheTime, _e = _b.indexDBName, indexDBName = _e === void 0 ? '__apiCacheDatabase__' : _e;
         var cache = new Cache(cacheDataInStorage, cacheDataKey, cacheTime, indexDBName, cacheKeyEquals);
         function request(requestParam, options) {
             var _a = __assign(__assign({}, requestOptions), requestParam), method = _a.method, url = _a.url, _b = _a.data, data = _b === void 0 ? {} : _b, _c = _a.params, params = _c === void 0 ? {} : _c;
+            var requestDataOrParams = params;
+            if (method.toLowerCase() === 'post') {
+                requestDataOrParams = data;
+            }
             var _d = __assign(__assign(__assign({}, baseOptions), createOptions), options).defaultMessageShower, defaultMessageShower = _d === void 0 ? alert : _d;
             var _e = __assign(__assign(__assign({}, baseOptions), createOptions), options), _f = _e.enableCache, enableCache = _f === void 0 ? false : _f, _g = _e.cacheData, cacheData = _g === void 0 ? false : _g, _h = _e.defaultErrorCodeHandler, defaultErrorCodeHandler = _h === void 0 ? _defaultErrorCodeHandler.bind(null, defaultMessageShower) : _h, _j = _e.defaultHttpErrorCodeHandler, defaultHttpErrorCodeHandler = _j === void 0 ? _defaultHttpErrorCodeHandler.bind(null, defaultMessageShower) : _j, _k = _e.otherErrorHandler, otherErrorHandler = _k === void 0 ? _defaultOtherErrorCodeHandler.bind(null, defaultMessageShower) : _k, _l = _e.errorCodePath, errorCodePath = _l === void 0 ? 'code' : _l, _m = _e.cacheTime, cacheTime = _m === void 0 ? 60 : _m, _o = _e.errorCodeMap, errorCodeMap = _o === void 0 ? {} : _o, _p = _e.successCodes, successCodes = _p === void 0 ? ['0', '200'] : _p, _q = _e.httpErrorCodeMap, httpErrorCodeMap = _q === void 0 ? {} : _q, _r = _e.axiosOptions, axiosOptions = _r === void 0 ? {} : _r, _s = _e.throwError, throwError = _s === void 0 ? true : _s;
             if (enableCache) {
-                var cacheItem = cache.getCache(params);
+                var cacheItem = cache.getCache(requestDataOrParams);
                 if (cacheItem) {
                     return Promise.resolve(cacheItem);
                 }
@@ -33,7 +50,7 @@ function createBaseRequest(baseOptions) {
                 var errorCode = String(at(res.data, errorCodePath));
                 if (successCodes.includes(errorCode)) {
                     if (cacheData) {
-                        cache.setCache(params, res.data, { cacheTime: cacheTime });
+                        cache.setCache(requestDataOrParams, res.data, { cacheTime: cacheTime });
                     }
                     return res.data;
                 }

package/dist/types/cache/index.d.ts

@@ -1,29 +1,133 @@
 import { IndexedDBStorage } from './indexDB.js';
 
+/**
+ * 缓存存储类型
+ * - sessionStorage: 会话存储，浏览器关闭后清除
+ * - localStorage: 本地存储，永久保存
+ * - indexedDB: IndexedDB 数据库存储
+ */
 type StorageType = 'sessionStorage' | 'localStorage' | 'indexedDB';
+/**
+ * 缓存项接口定义
+ * 定义了单个缓存项的数据结构
+ *
+ * @template Param 缓存参数类型
+ * @template Data 缓存数据类型
+ */
 interface ICache<Param, Data> {
+    /**
+     * 缓存的参数
+     * 用于标识和查找缓存项
+     */
     params: Param;
+    /**
+     * 缓存的数据
+     * 实际存储的内容
+     */
     data: Data;
+    /**
+     * 过期时间
+     * - ISO 8601 格式的字符串
+     * - 由 moment().add(cacheTime, 'seconds').toJSON() 生成
+     * - 示例：'2025-06-12T10:30:00.000Z'
+     */
     expireTime: string;
 }
+/**
+ * 缓存选项接口
+ * @template Param 缓存参数类型
+ */
 interface ICacheOptions<Param> {
+    /**
+     * 存储类型
+     * - 'sessionStorage': 会话存储，浏览器关闭后清除
+     * - 'localStorage': 本地存储，永久保存
+     * - 'indexedDB': IndexedDB 数据库存储
+     * - undefined: 仅在内存中缓存（默认值）
+     */
     storageType?: StorageType;
+    /**
+     * 缓存键名
+     * - 当使用 localStorage/sessionStorage 时必须提供
+     * - 用于在存储中标识不同的缓存数据
+     * @default undefined 不使用持久化存储
+     */
     cacheKey?: string;
+    /**
+     * 缓存时间（秒）
+     * - 超过这个时间的缓存项会被自动清除
+     * @default 60 一分钟
+     */
     cacheTime?: number;
+    /**
+     * 缓存键比较函数
+     * - 用于判断两个缓存参数是否相等
+     * - 相等则认为是同一个缓存项
+     * @param prev 前一个参数
+     * @param next 后一个参数
+     * @returns 是否相等
+     * @default defaultEquals 使用 JSON.stringify 进行比较
+     */
     cacheKeyEquals: (prev: Param, next: Param) => boolean;
+    /**
+     * IndexedDB 数据库名称
+     * - 仅在 storageType 为 'indexedDB' 时使用
+     * @default '__apiCacheDatabase__'
+     */
     indexDBName?: string;
 }
+/** 存储类型映射表 */
 declare const StorageMap: Record<StorageType | string, Storage>;
+/**
+ * 缓存类
+ * @template Param 缓存参数类型
+ * @template Data 缓存数据类型
+ */
 declare class Cache<Param, Data> {
+    /** 内存中的缓存数组 */
     cache: ICache<Param, Data>[];
+    /** 缓存选项 */
     private cacheOptions;
-    storage?: Storage | IndexedDBStorage;
+    /** 存储实例 */
+    storage?: Storage | IndexedDBStorage; /**
+     * 构造函数
+     * @param cacheType 存储类型
+     * @param cacheKey 缓存键名
+     * @param cacheTime 缓存时间（秒）
+     * @param indexDBName IndexedDB 数据库名称，默认值为 '__apiCacheDatabase__'
+     * @param cacheKeyEquals 缓存键比较函数，默认使用 defaultEquals
+     */
     constructor(cacheType?: StorageType, cacheKey?: string, cacheTime?: number, indexDBName?: string, cacheKeyEquals?: (prev: Param, next: Param) => boolean);
-    private _init;
-    private _filterExpired;
-    private _saveToStorage;
-    setCache(params: Param, data: Data, cacheOptions?: Omit<ICacheOptions<Param>, 'storageType' | 'cacheKey' | 'cacheKeyEquals'>): void;
-    getCache(params: Param): Data;
+    /**
+     * 初始化缓存
+     * 从存储中加载已保存的缓存数据，并进行解析和过期处理
+     * @private
+     */
+    private _init; /**
+     * 过滤掉已过期的缓存项
+     * 通过比较当前时间和过期时间，移除过期的缓存项
+     * @private
+     */
+    private _filterExpired; /**
+     * 将当前缓存数据保存到存储中
+     * 如果设置了缓存键名且存储实例存在，则将缓存数据序列化后保存
+     * @private
+     */
+    private _saveToStorage; /**
+     * 设置缓存数据
+     * @param params 缓存的参数
+     * @param data 要缓存的数据
+     * @param cacheOptions 可选的缓存配置，可以覆盖默认的缓存时间
+     */
+    setCache(params: Param, data: Data, cacheOptions?: Omit<ICacheOptions<Param>, 'storageType' | 'cacheKey' | 'cacheKeyEquals'>): void; /**
+     * 获取缓存数据
+     * @param params 查询参数
+     * @returns 如果找到有效的缓存数据则返回数据，否则返回 null
+     */
+    getCache(params: Param): Data; /**
+     * 清空所有缓存数据
+     * 清空内存中的缓存数组并同步到存储中
+     */
     clear(): void;
 }
 

package/dist/types/cache/indexDB.d.ts

@@ -1,11 +1,51 @@
+/**
+ * IndexedDB 存储类
+ * 提供了对 IndexedDB 数据库操作的简单封装
+ */
 declare class IndexedDBStorage {
+    /** 数据库名称 */
     private dbName;
+    /** 存储对象名称 */
     private storeName;
+    /** 数据库连接实例 */
     private db;
+    /**
+     * 构造函数
+     * @param dbName 数据库名称
+     * @param storeName 存储对象名称
+     */
     constructor(dbName: string, storeName: string);
+    /**
+     * 打开数据库连接
+     * 如果数据库不存在则创建新的数据库和存储对象
+     * @private
+     * @returns Promise<IDBDatabase> 数据库连接实例
+     */
     private _open;
+    /**
+     * 获取存储对象
+     * @param mode 事务模式，默认为只读模式
+     * - readonly: 只读模式
+     * - readwrite: 读写模式
+     * @private
+     * @returns Promise<IDBObjectStore> 存储对象实例
+     */
     private _getStore;
+    /**
+     * 设置键值对
+     * @param key 键名
+     * @param value 要存储的值
+     * @returns Promise<void> 存储操作的结果
+     * @throws 当存储操作失败时抛出错误
+     */
     setItem<T>(key: string, value: T): Promise<void>;
+    /**
+     * 获取键对应的值
+     * @param key 要获取的键名
+     * @returns Promise<T> 返回存储的值，如果不存在则返回 undefined
+     * @throws 当获取操作失败时抛出错误
+     * @template T 存储值的类型，默认为 any
+     */
     getItem<T = any>(key: string): Promise<T>;
 }
 

package/dist/types/createStateStore/index.d.ts

@@ -1,8 +1,36 @@
+/**
+ * 状态初始化设置器类型
+ * 用于延迟初始化状态的函数类型
+ */
 type IHookStateInitialSetter<S> = () => S;
+/**
+ * 状态初始化动作类型
+ * 可以是直接的状态值或初始化设置器
+ */
 type IHookStateInitAction<S> = S | IHookStateInitialSetter<S>;
+/**
+ * 状态设置器类型
+ * 可以是接收前一个状态的函数或无参数的函数
+ */
 type IHookStateSetter<S> = ((prevState: S) => S) | (() => S);
+/**
+ * 状态设置动作类型
+ * 可以是直接的状态值或状态设置器
+ */
 type IHookStateSetAction<S> = S | IHookStateSetter<S>;
+/**
+ * 可解析的状态类型
+ * 包含所有可能的状态值或状态设置函数
+ */
 type IHookStateResolvable<S> = S | IHookStateInitialSetter<S> | IHookStateSetter<S>;
+/**
+ * 创建状态存储
+ * 提供一个简单的状态管理解决方案，支持组件间状态共享
+ *
+ * @template S 状态类型
+ * @param initialState 初始状态值或初始化函数
+ * @returns 包含状态操作方法的对象
+ */
 declare function createStateStore<S>(initialState?: S): {
     use: () => [S, (state: IHookStateSetAction<S>) => void];
     get: () => S;

package/dist/types/request/error.d.ts

@@ -1,8 +1,29 @@
+/**
+ * 请求错误类型
+ * - server: 服务端业务错误
+ * - http: HTTP 网络错误
+ */
 type RequestErrorType = 'server' | 'http';
+/**
+ * 请求错误类
+ * 用于统一处理请求过程中的各种错误
+ *
+ * @template Data 错误数据类型
+ * @extends Error
+ */
 declare class RequestError<Data = any> extends Error {
+    /** 错误码 */
     code: string;
+    /** 错误类型 */
     type: RequestErrorType;
+    /** 错误相关的数据 */
     data?: Data;
+    /**
+     * 构造函数
+     * @param message 错误消息
+     * @param type 错误类型
+     * @param data 错误相关的数据
+     */
     constructor(message: string, type: RequestErrorType, data?: Data);
 }
 

package/dist/types/request/index.d.ts

@@ -1,36 +1,132 @@
 import { AxiosResponse, Method, AxiosRequestConfig } from 'axios';
 import { StorageType } from '../cache/index.js';
 
+/**
+ * 错误处理器返回类型
+ * @template D 响应数据类型
+ */
 type ErrorHandlerReturnType<D> = {
+    /** 替换响应数据 */
     replaceResData?: D;
+    /**
+     * 是否抛出错误
+     * - true: 强制抛出错误
+     * - false: 不抛出错误
+     * - 'default': 使用默认错误处理逻辑
+     */
     throwError?: boolean | 'default';
 };
+/**
+ * 请求配置选项接口
+ * @template Params 请求参数类型
+ * @template Data 响应数据类型
+ */
 interface Options<Params = any, Data = any> {
+    /** 请求基础URL，默认为空字符串 */
     baseURL?: string;
+    /**
+     * 是否抛出错误
+     * @default true
+     */
     throwError?: boolean;
+    /**
+     * 默认的消息展示函数
+     * @default window.alert
+     */
     defaultMessageShower?: (message: string) => void;
+    /**
+     * 是否启用缓存功能
+     * @default false
+     */
     enableCache?: boolean;
+    /**
+     * 缓存键比较函数
+     * @default defaultEquals 使用 JSON.stringify 进行比较
+     */
     cacheKeyEquals?: (prev: Params, next: Params) => boolean;
+    /**
+     * 是否将响应数据存入缓存
+     * @default false
+     */
     cacheData?: boolean;
-    cacheTime?: number;
+    /**
+     * 缓存时间（秒）
+     * @default 60
+     */
+    cacheTime?: number; /**
+     * 缓存数据的存储类型
+     * - localStorage: 使用浏览器本地存储，数据永久保存
+     * - sessionStorage: 使用会话存储，关闭浏览器后清除
+     * - indexedDB: 使用 IndexedDB 数据库存储
+     * - 不填则仅在内存中缓存，页面刷新后清除
+     */
     cacheDataInStorage?: StorageType;
+    /**
+     * 缓存数据的键名
+     * @default `${method}:${baseURL}${url}` 默认使用请求方法、基础URL和请求路径组合
+     */
     cacheDataKey?: string;
+    /**
+     * IndexedDB 数据库名称
+     * @default '__apiCacheDatabase__'
+     */
     indexDBName?: string;
-    errorCodePath?: string;
+    /**
+     * 错误码在响应数据中的路径
+     * @default 'code'
+     */
+    errorCodePath?: string; /**
+     * 错误码映射表
+     * 可以配置错误码对应的错误信息或处理函数
+     * @default {} 空对象，使用默认处理函数
+     */
     errorCodeMap?: Record<string, string | ((code: string, data: Data, res: AxiosResponse<Data>, requestParam: RequestOptions<Params>) => ErrorHandlerReturnType<Data> | void)>;
-    defaultErrorCodeHandler?: (code: string, data: Data, res: AxiosResponse<Data>) => ErrorHandlerReturnType<Data> | void;
+    /**
+     * 默认错误码处理函数
+     * 当错误码不在 errorCodeMap 中时调用
+     */
+    defaultErrorCodeHandler?: (code: string, data: Data, res: AxiosResponse<Data>) => ErrorHandlerReturnType<Data> | void; /**
+     * 成功状态的错误码列表
+     * @default ['0', '200']
+     */
     successCodes?: string[];
+    /**
+     * HTTP 错误码映射表
+     * 可以配置 HTTP 状态码对应的错误信息或处理函数
+     * @default {} 空对象，使用默认处理函数
+     */
     httpErrorCodeMap?: Record<string, string | ((code: number, res: AxiosResponse<Data>, requestParam: RequestOptions<Params>) => ErrorHandlerReturnType<Data> | void)>;
+    /**
+     * 默认 HTTP 错误码处理函数
+     * 当 HTTP 状态码不在 httpErrorCodeMap 中时调用
+     */
     defaultHttpErrorCodeHandler?: (code: number, error: any) => ErrorHandlerReturnType<Data> | void;
+    /**
+     * 其他错误处理函数
+     * 处理非 HTTP 错误和非业务错误码的错误
+     */
     otherErrorHandler?: (error: any) => ErrorHandlerReturnType<Data> | void;
     axiosOptions?: Omit<AxiosRequestConfig<Params>, 'method' | 'url' | 'params' | 'data'>;
 }
+/**
+ * 请求参数接口
+ * @template Param 请求参数类型
+ */
 interface RequestOptions<Param> {
+    /** HTTP 请求方法 */
     method: Method;
+    /** 请求URL */
     url: string;
+    /** POST/PUT 等请求的数据 */
     data?: Param;
+    /** URL 查询参数 */
     params?: Param;
 }
+/**
+ * 创建基础请求实例
+ * @param baseOptions 基础配置选项
+ * @returns 请求创建函数
+ */
 declare function createBaseRequest(baseOptions?: Options): <Param, Data extends Record<any, any>>(requestOptions: RequestOptions<Param>, createOptions?: Omit<Options<Param, Data>, "baseURL">) => {
     (requestParam?: Omit<RequestOptions<Param>, "url" | "method">, options?: Omit<Options<Param, Data>, "baseURL" | "cacheDataKey" | "cacheDataInStorage" | "cacheKeyEquals">): Promise<Data>;
     clearCache(): void;

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "rxtutils",
-  "version": "1.0.8",
+  "version": "1.1.0",
+  "type": "module",
   "main": "dist/cjs/index.cjs",
   "module": "dist/es/index.mjs",
   "types": "dist/types/index.d.ts",
@@ -17,7 +18,6 @@
     "@types/node": "^22.15.29",
     "rollup": "^4.41.1",
     "rollup-plugin-dts": "^6.2.1",
-    "tslib": "^2.8.1",
     "typescript": "^5.8.3",
     "vite": "^5.4.19"
   },
@@ -25,8 +25,9 @@
     "react": "^19.1.0"
   },
   "dependencies": {
+    "tslib": "^2.8.1",
     "axios": "^1.9.0",
     "lodash": "^4.17.21",
     "moment": "^2.30.1"
   }
-}
+}