rxtutils 1.1.2-beta.10 → 1.1.2-beta.11

package/cjs/_utils/defaultEquals.cjs

@@ -0,0 +1,21 @@
+'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);
+}
+
+module.exports = defaultEquals;

package/cjs/cache/index.cjs

@@ -5,7 +5,7 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var tslib = require('tslib');
 var moment = require('moment');
 var indexDB = require('./indexDB.cjs');
-var defaultEquals = require('../defaultEquals.cjs');
+var defaultEquals = require('../_utils/defaultEquals.cjs');
 
 /** 存储类型映射表 */
 var StorageMap = {
@@ -18,8 +18,16 @@ var StorageMap = {
  * @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 (indexDBName === void 0) { indexDBName = "__apiCacheDatabase__"; }
         if (cacheKeyEquals === void 0) { cacheKeyEquals = defaultEquals; }
         /** 内存中的缓存数组 */
         this.cache = [];
@@ -30,10 +38,10 @@ var Cache = /** @class */ (function () {
             indexDBName: indexDBName,
             cacheKeyEquals: cacheKeyEquals,
         };
-        if (cacheType === 'indexedDB') {
-            this.storage = new indexDB.IndexedDBStorage(indexDBName, 'cacheStore');
+        if (cacheType === "indexedDB") {
+            this.storage = new indexDB.IndexedDBStorage(indexDBName, "cacheStore");
         }
-        else if (typeof cacheType === 'string') {
+        else if (typeof cacheType === "string") {
             this.storage = StorageMap[cacheType];
         }
         this._init();
@@ -55,15 +63,15 @@ var Cache = /** @class */ (function () {
                         _d = (_c = JSON).parse;
                         return [4 /*yield*/, this.storage.getItem(cacheKey)];
                     case 1:
-                        _b.cache = _d.apply(_c, [(_e.sent()) || '[]']);
+                        _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') {
+                                if (typeof cacheKey === "string") {
                                     try {
-                                        this.cache = JSON.parse(this.storage.getItem(cacheKey) || '[]');
+                                        this.cache = JSON.parse(this.storage.getItem(cacheKey) || "[]");
                                     }
                                     catch (e) {
                                         this.cache = [];
@@ -80,7 +88,8 @@ var Cache = /** @class */ (function () {
                 }
             });
         });
-    }; /**
+    };
+    /**
      * 过滤掉已过期的缓存项
      * 通过比较当前时间和过期时间，移除过期的缓存项
      * @private
@@ -90,18 +99,20 @@ var Cache = /** @class */ (function () {
             return moment(item.expireTime).isAfter(moment());
         });
         this.cache = newCache;
-    }; /**
+    };
+    /**
      * 将当前缓存数据保存到存储中
      * 如果设置了缓存键名且存储实例存在，则将缓存数据序列化后保存
      * @private
      */
     Cache.prototype._saveToStorage = function () {
         if (this.storage) {
-            if (typeof this.cacheOptions.cacheKey === 'string') {
+            if (typeof this.cacheOptions.cacheKey === "string") {
                 this.storage.setItem(this.cacheOptions.cacheKey, JSON.stringify(this.cache));
             }
         }
-    }; /**
+    };
+    /**
      * 设置缓存数据
      * @param params 缓存的参数
      * @param data 要缓存的数据
@@ -118,10 +129,11 @@ var Cache = /** @class */ (function () {
         this.cache.push({
             params: params,
             data: data,
-            expireTime: moment().add(cacheTime, 'seconds').toJSON(),
+            expireTime: moment().add(cacheTime, "seconds").toJSON(),
         });
         this._saveToStorage();
-    }; /**
+    };
+    /**
      * 获取缓存数据
      * @param params 查询参数
      * @returns 如果找到有效的缓存数据则返回数据，否则返回 null
@@ -142,7 +154,8 @@ var Cache = /** @class */ (function () {
             }
         }
         return null;
-    }; /**
+    };
+    /**
      * 清空所有缓存数据
      * 清空内存中的缓存数组并同步到存储中
      */

package/cjs/packages/cache/index.d.ts

@@ -0,0 +1,141 @@
+import { IndexedDBStorage } from '../../cache/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;
+    /**
+     * 构造函数
+     * @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
+     */
+    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;
+}
+
+export { StorageMap, Cache as default };
+export type { ICache, ICacheOptions, StorageType };

package/cjs/packages/index.d.ts

@@ -0,0 +1,7 @@
+export { default as Cache, ICache, ICacheOptions, StorageMap, StorageType } from './cache/index.js';
+export { ErrorHandlerReturnType, Options, RequestOptions, default as createBaseRequest } from './request/index.js';
+export { createStoreGetter, createStoreGetterMemo } from '../store/createGetter/index.js';
+export { IHookStateInitAction, IHookStateInitialSetter, IHookStateResolvable, IHookStateSetAction, IHookStateSetter, default as createStateStore } from '../store/createStateStore/index.js';
+export { BaseValidator } from '../validator/validator.js';
+export { VArray, VBoolean, VEmail, VMax, VMaxLength, VMin, VMinLength, VNumber, VPattern, VRequired, VString } from '../validator/decorators.js';
+export { default as RequestError, RequestErrorType } from '../request/error.js';

package/cjs/packages/request/index.d.ts

@@ -0,0 +1,140 @@
+import { AxiosResponse, Method, AxiosRequestConfig } from 'axios';
+import { StorageType } from '../cache/index.js';
+export { default as RequestError, RequestErrorType } from '../../request/error.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;
+    /**
+     * 缓存时间（秒）
+     * @default 60
+     */
+    cacheTime?: number;
+    /**
+     * 缓存数据的存储类型
+     * - localStorage: 使用浏览器本地存储，数据永久保存
+     * - sessionStorage: 使用会话存储，关闭浏览器后清除
+     * - indexedDB: 使用 IndexedDB 数据库存储
+     * - 不填则仅在内存中缓存，页面刷新后清除
+     */
+    cacheDataInStorage?: StorageType;
+    /**
+     * 缓存数据的键名
+     * @default `${method}:${baseURL}${url}` 默认使用请求方法、基础URL和请求路径组合
+     */
+    cacheDataKey?: string;
+    /**
+     * IndexedDB 数据库名称
+     * @default '__apiCacheDatabase__'
+     */
+    indexDBName?: string;
+    /**
+     * 错误码在响应数据中的路径
+     * @default 'code'
+     */
+    errorCodePath?: string;
+    /**
+     * 错误码映射表
+     * 可以配置错误码对应的错误信息或处理函数
+     * @default {} 空对象，使用默认处理函数
+     */
+    errorCodeMap?: Record<string, string | ((code: string, data: Data, res: AxiosResponse<Data>, requestParam: RequestOptions<Params>) => ErrorHandlerReturnType<Data> | void)>;
+    /**
+     * 默认错误码处理函数
+     * 当错误码不在 errorCodeMap 中时调用
+     */
+    defaultErrorCodeHandler?: (code: string, data: Data, res: AxiosResponse<Data>) => Promise<ErrorHandlerReturnType<Data> | void>;
+    /**
+     * 成功状态的错误码列表
+     * @default ['0', '200']
+     */
+    successCodes?: string[];
+    /**
+     * HTTP 错误码映射表
+     * 可以配置 HTTP 状态码对应的错误信息或处理函数
+     * @default {} 空对象，使用默认处理函数
+     */
+    httpErrorCodeMap?: Record<string, string | ((code: number, res: AxiosResponse<Data>, requestParam: RequestOptions<Params>) => Promise<ErrorHandlerReturnType<Data> | void>)>;
+    /**
+     * 默认 HTTP 错误码处理函数
+     * 当 HTTP 状态码不在 httpErrorCodeMap 中时调用
+     */
+    defaultHttpErrorCodeHandler?: (code: number, error: any) => Promise<ErrorHandlerReturnType<Data> | void>;
+    /**
+     * 其他错误处理函数
+     * 处理非 HTTP 错误和非业务错误码的错误
+     */
+    otherErrorHandler?: (error: any) => Promise<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;
+};
+
+export { createBaseRequest as default };
+export type { ErrorHandlerReturnType, Options, RequestOptions };

package/cjs/packages/store/index.d.ts

@@ -0,0 +1,2 @@
+export { GetterNameMap, ReducedData, StoreGetter, createStoreGetter, createStoreGetterMemo } from '../../store/createGetter/index.js';
+export { IHookStateInitAction, IHookStateInitialSetter, IHookStateResolvable, IHookStateSetAction, IHookStateSetter, default as createStateStore } from '../../store/createStateStore/index.js';

package/cjs/packages/validator/index.d.ts

@@ -0,0 +1,2 @@
+export { BaseValidator } from '../../validator/validator.js';
+export { VArray, VBoolean, VEmail, VMax, VMaxLength, VMin, VMinLength, VNumber, VPattern, VRequired, VString } from '../../validator/decorators.js';

package/cjs/request/index.cjs

@@ -4,7 +4,7 @@ var tslib = require('tslib');
 var axios = require('axios');
 var lodash = require('lodash');
 var defaultHandlers = require('./defaultHandlers.cjs');
-var defaultEquals = require('../defaultEquals.cjs');
+var defaultEquals = require('../_utils/defaultEquals.cjs');
 var index = require('../cache/index.cjs');
 var error = require('./error.cjs');
 

package/cjs/store/index.cjs

@@ -0,0 +1,10 @@
+'use strict';
+
+var index = require('./createGetter/index.cjs');
+var index$1 = require('./createStateStore/index.cjs');
+
+
+
+exports.createStoreGetter = index.createStoreGetter;
+exports.createStoreGetterMemo = index.createStoreGetterMemo;
+exports.createStateStore = index$1.default;

package/cjs/validator/index.cjs

@@ -0,0 +1,19 @@
+'use strict';
+
+var validator = require('./validator.cjs');
+var decorators = require('./decorators.cjs');
+
+
+
+exports.BaseValidator = validator.BaseValidator;
+exports.VArray = decorators.VArray;
+exports.VBoolean = decorators.VBoolean;
+exports.VEmail = decorators.VEmail;
+exports.VMax = decorators.VMax;
+exports.VMaxLength = decorators.VMaxLength;
+exports.VMin = decorators.VMin;
+exports.VMinLength = decorators.VMinLength;
+exports.VNumber = decorators.VNumber;
+exports.VPattern = decorators.VPattern;
+exports.VRequired = decorators.VRequired;
+exports.VString = decorators.VString;

package/es/_utils/defaultEquals.mjs

@@ -0,0 +1,19 @@
+/**
+ * 默认的相等性比较函数
+ * 通过将两个值序列化为 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);
+}
+
+export { defaultEquals as default };

package/es/cache/index.mjs

@@ -1,7 +1,7 @@
 import { __awaiter, __generator, __assign } from 'tslib';
 import moment from 'moment';
 import { IndexedDBStorage } from './indexDB.mjs';
-import defaultEquals from '../defaultEquals.mjs';
+import defaultEquals from '../_utils/defaultEquals.mjs';
 
 /** 存储类型映射表 */
 var StorageMap = {
@@ -14,8 +14,16 @@ var StorageMap = {
  * @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 (indexDBName === void 0) { indexDBName = "__apiCacheDatabase__"; }
         if (cacheKeyEquals === void 0) { cacheKeyEquals = defaultEquals; }
         /** 内存中的缓存数组 */
         this.cache = [];
@@ -26,10 +34,10 @@ var Cache = /** @class */ (function () {
             indexDBName: indexDBName,
             cacheKeyEquals: cacheKeyEquals,
         };
-        if (cacheType === 'indexedDB') {
-            this.storage = new IndexedDBStorage(indexDBName, 'cacheStore');
+        if (cacheType === "indexedDB") {
+            this.storage = new IndexedDBStorage(indexDBName, "cacheStore");
         }
-        else if (typeof cacheType === 'string') {
+        else if (typeof cacheType === "string") {
             this.storage = StorageMap[cacheType];
         }
         this._init();
@@ -51,15 +59,15 @@ var Cache = /** @class */ (function () {
                         _d = (_c = JSON).parse;
                         return [4 /*yield*/, this.storage.getItem(cacheKey)];
                     case 1:
-                        _b.cache = _d.apply(_c, [(_e.sent()) || '[]']);
+                        _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') {
+                                if (typeof cacheKey === "string") {
                                     try {
-                                        this.cache = JSON.parse(this.storage.getItem(cacheKey) || '[]');
+                                        this.cache = JSON.parse(this.storage.getItem(cacheKey) || "[]");
                                     }
                                     catch (e) {
                                         this.cache = [];
@@ -76,7 +84,8 @@ var Cache = /** @class */ (function () {
                 }
             });
         });
-    }; /**
+    };
+    /**
      * 过滤掉已过期的缓存项
      * 通过比较当前时间和过期时间，移除过期的缓存项
      * @private
@@ -86,18 +95,20 @@ var Cache = /** @class */ (function () {
             return moment(item.expireTime).isAfter(moment());
         });
         this.cache = newCache;
-    }; /**
+    };
+    /**
      * 将当前缓存数据保存到存储中
      * 如果设置了缓存键名且存储实例存在，则将缓存数据序列化后保存
      * @private
      */
     Cache.prototype._saveToStorage = function () {
         if (this.storage) {
-            if (typeof this.cacheOptions.cacheKey === 'string') {
+            if (typeof this.cacheOptions.cacheKey === "string") {
                 this.storage.setItem(this.cacheOptions.cacheKey, JSON.stringify(this.cache));
             }
         }
-    }; /**
+    };
+    /**
      * 设置缓存数据
      * @param params 缓存的参数
      * @param data 要缓存的数据
@@ -114,10 +125,11 @@ var Cache = /** @class */ (function () {
         this.cache.push({
             params: params,
             data: data,
-            expireTime: moment().add(cacheTime, 'seconds').toJSON(),
+            expireTime: moment().add(cacheTime, "seconds").toJSON(),
         });
         this._saveToStorage();
-    }; /**
+    };
+    /**
      * 获取缓存数据
      * @param params 查询参数
      * @returns 如果找到有效的缓存数据则返回数据，否则返回 null
@@ -138,7 +150,8 @@ var Cache = /** @class */ (function () {
             }
         }
         return null;
-    }; /**
+    };
+    /**
      * 清空所有缓存数据
      * 清空内存中的缓存数组并同步到存储中
      */

package/es/packages/cache/index.d.ts

@@ -0,0 +1,141 @@
+import { IndexedDBStorage } from '../../cache/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;
+    /**
+     * 构造函数
+     * @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
+     */
+    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;
+}
+
+export { StorageMap, Cache as default };
+export type { ICache, ICacheOptions, StorageType };

package/es/packages/index.d.ts

@@ -0,0 +1,7 @@
+export { default as Cache, ICache, ICacheOptions, StorageMap, StorageType } from './cache/index.js';
+export { ErrorHandlerReturnType, Options, RequestOptions, default as createBaseRequest } from './request/index.js';
+export { createStoreGetter, createStoreGetterMemo } from '../store/createGetter/index.js';
+export { IHookStateInitAction, IHookStateInitialSetter, IHookStateResolvable, IHookStateSetAction, IHookStateSetter, default as createStateStore } from '../store/createStateStore/index.js';
+export { BaseValidator } from '../validator/validator.js';
+export { VArray, VBoolean, VEmail, VMax, VMaxLength, VMin, VMinLength, VNumber, VPattern, VRequired, VString } from '../validator/decorators.js';
+export { default as RequestError, RequestErrorType } from '../request/error.js';

package/es/packages/request/index.d.ts

@@ -0,0 +1,140 @@
+import { AxiosResponse, Method, AxiosRequestConfig } from 'axios';
+import { StorageType } from '../cache/index.js';
+export { default as RequestError, RequestErrorType } from '../../request/error.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;
+    /**
+     * 缓存时间（秒）
+     * @default 60
+     */
+    cacheTime?: number;
+    /**
+     * 缓存数据的存储类型
+     * - localStorage: 使用浏览器本地存储，数据永久保存
+     * - sessionStorage: 使用会话存储，关闭浏览器后清除
+     * - indexedDB: 使用 IndexedDB 数据库存储
+     * - 不填则仅在内存中缓存，页面刷新后清除
+     */
+    cacheDataInStorage?: StorageType;
+    /**
+     * 缓存数据的键名
+     * @default `${method}:${baseURL}${url}` 默认使用请求方法、基础URL和请求路径组合
+     */
+    cacheDataKey?: string;
+    /**
+     * IndexedDB 数据库名称
+     * @default '__apiCacheDatabase__'
+     */
+    indexDBName?: string;
+    /**
+     * 错误码在响应数据中的路径
+     * @default 'code'
+     */
+    errorCodePath?: string;
+    /**
+     * 错误码映射表
+     * 可以配置错误码对应的错误信息或处理函数
+     * @default {} 空对象，使用默认处理函数
+     */
+    errorCodeMap?: Record<string, string | ((code: string, data: Data, res: AxiosResponse<Data>, requestParam: RequestOptions<Params>) => ErrorHandlerReturnType<Data> | void)>;
+    /**
+     * 默认错误码处理函数
+     * 当错误码不在 errorCodeMap 中时调用
+     */
+    defaultErrorCodeHandler?: (code: string, data: Data, res: AxiosResponse<Data>) => Promise<ErrorHandlerReturnType<Data> | void>;
+    /**
+     * 成功状态的错误码列表
+     * @default ['0', '200']
+     */
+    successCodes?: string[];
+    /**
+     * HTTP 错误码映射表
+     * 可以配置 HTTP 状态码对应的错误信息或处理函数
+     * @default {} 空对象，使用默认处理函数
+     */
+    httpErrorCodeMap?: Record<string, string | ((code: number, res: AxiosResponse<Data>, requestParam: RequestOptions<Params>) => Promise<ErrorHandlerReturnType<Data> | void>)>;
+    /**
+     * 默认 HTTP 错误码处理函数
+     * 当 HTTP 状态码不在 httpErrorCodeMap 中时调用
+     */
+    defaultHttpErrorCodeHandler?: (code: number, error: any) => Promise<ErrorHandlerReturnType<Data> | void>;
+    /**
+     * 其他错误处理函数
+     * 处理非 HTTP 错误和非业务错误码的错误
+     */
+    otherErrorHandler?: (error: any) => Promise<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;
+};
+
+export { createBaseRequest as default };
+export type { ErrorHandlerReturnType, Options, RequestOptions };

package/es/packages/store/index.d.ts

@@ -0,0 +1,2 @@
+export { GetterNameMap, ReducedData, StoreGetter, createStoreGetter, createStoreGetterMemo } from '../../store/createGetter/index.js';
+export { IHookStateInitAction, IHookStateInitialSetter, IHookStateResolvable, IHookStateSetAction, IHookStateSetter, default as createStateStore } from '../../store/createStateStore/index.js';

package/es/packages/validator/index.d.ts

@@ -0,0 +1,2 @@
+export { BaseValidator } from '../../validator/validator.js';
+export { VArray, VBoolean, VEmail, VMax, VMaxLength, VMin, VMinLength, VNumber, VPattern, VRequired, VString } from '../../validator/decorators.js';

package/es/request/index.mjs

@@ -2,7 +2,7 @@ import { __assign, __awaiter, __generator } from 'tslib';
 import axios from 'axios';
 import { at } from 'lodash';
 import { _defaultErrorCodeHandler, _defaultHttpErrorCodeHandler, _defaultOtherErrorCodeHandler } from './defaultHandlers.mjs';
-import defaultEquals from '../defaultEquals.mjs';
+import defaultEquals from '../_utils/defaultEquals.mjs';
 import Cache from '../cache/index.mjs';
 import RequestError from './error.mjs';
 

package/es/store/index.mjs

@@ -0,0 +1,2 @@
+export { createStoreGetter, createStoreGetterMemo } from './createGetter/index.mjs';
+export { default as createStateStore } from './createStateStore/index.mjs';

package/es/validator/index.mjs

@@ -0,0 +1,2 @@
+export { BaseValidator } from './validator.mjs';
+export { VArray, VBoolean, VEmail, VMax, VMaxLength, VMin, VMinLength, VNumber, VPattern, VRequired, VString } from './decorators.mjs';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rxtutils",
-  "version": "1.1.2-beta.10",
+  "version": "1.1.2-beta.11",
   "type": "module",
   "main": "cjs/index.cjs",
   "module": "es/index.mjs",