rxtutils 1.1.2-beta.9 → 1.1.4-beta.1

package/README.md

@@ -294,10 +294,10 @@ BaseValidator 类提供了两个主要的验证方法：
 
 ```typescript
 // 验证单个字段
-validate(itemKey: string, itemAll: boolean = false): { status: boolean; message?: string }[] | null;
+validate(itemKey: string, itemAll: boolean = false): string[] | null;
 
 // 验证多个或所有字段
-validateAll(itemAll: boolean = false, everyItem: boolean = false, order?: string[]): { status: boolean; message?: string }[] | null;
+validateAll(itemAll: boolean = false, everyItem: boolean = false, order?: string[]): string[] | null;
 ```
 
 参数说明：

package/{dist/cjs → 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/{dist/types → cjs}/cache/index.d.ts

@@ -6,7 +6,7 @@ import { IndexedDBStorage } from './indexDB.js';
  * - localStorage: 本地存储，永久保存
  * - indexedDB: IndexedDB 数据库存储
  */
-type StorageType = 'sessionStorage' | 'localStorage' | 'indexedDB';
+type StorageType = "sessionStorage" | "localStorage" | "indexedDB";
 /**
  * 缓存项接口定义
  * 定义了单个缓存项的数据结构
@@ -89,7 +89,8 @@ declare class Cache<Param, Data> {
     /** 缓存选项 */
     private cacheOptions;
     /** 存储实例 */
-    storage?: Storage | IndexedDBStorage; /**
+    storage?: Storage | IndexedDBStorage;
+    /**
      * 构造函数
      * @param cacheType 存储类型
      * @param cacheKey 缓存键名
@@ -103,28 +104,33 @@ declare class Cache<Param, Data> {
      * 从存储中加载已保存的缓存数据，并进行解析和过期处理
      * @private
      */
-    private _init; /**
+    private _init;
+    /**
      * 过滤掉已过期的缓存项
      * 通过比较当前时间和过期时间，移除过期的缓存项
      * @private
      */
-    private _filterExpired; /**
+    private _filterExpired;
+    /**
      * 将当前缓存数据保存到存储中
      * 如果设置了缓存键名且存储实例存在，则将缓存数据序列化后保存
      * @private
      */
-    private _saveToStorage; /**
+    private _saveToStorage;
+    /**
      * 设置缓存数据
      * @param params 缓存的参数
      * @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;
+    /**
      * 清空所有缓存数据
      * 清空内存中的缓存数组并同步到存储中
      */

package/cjs/hooks/index.cjs

@@ -0,0 +1,7 @@
+'use strict';
+
+var useCombineControlValue = require('./useCombineControlValue.cjs');
+
+
+
+exports.useCombineControlValue = useCombineControlValue.useCombineControlValue;

package/cjs/hooks/index.d.ts

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

package/cjs/hooks/useCombineControlValue.cjs

@@ -0,0 +1,32 @@
+'use strict';
+
+var react = require('react');
+
+/**
+ * @param param props 组件属性
+ * @param param valueKey 组件值的key，默认value, undefined 被认为是有值，只有当 key 不存在时，转换为非受控模式
+ * @param param defaultValue 默认值
+ * @param param onChange 值改变时的回调
+ * @returns value: 组件应该采用的值，onChange：值改变时的回调，处理非受控值与向父组件传递值的逻辑
+ */
+var useCombineControlValue = function (_a) {
+    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 = props.hasOwnProperty(valueKey);
+    var _e = react.useState(value !== null && value !== void 0 ? value : defaultValue), internalValue = _e[0], setInternalValue = _e[1];
+    var handleChange = react.useCallback(function (nextVal) {
+        setInternalValue(nextVal);
+        onChange === null || onChange === void 0 ? void 0 : onChange(nextVal);
+    }, [onChange]);
+    var finalValue = react.useMemo(function () {
+        if (hasValue)
+            return value;
+        return internalValue;
+    }, [hasValue, internalValue, value]);
+    return {
+        value: finalValue,
+        onChange: handleChange
+    };
+};
+
+exports.useCombineControlValue = useCombineControlValue;

package/cjs/hooks/useCombineControlValue.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @param param props 组件属性
+ * @param param valueKey 组件值的key，默认value, undefined 被认为是有值，只有当 key 不存在时，转换为非受控模式
+ * @param param defaultValue 默认值
+ * @param param onChange 值改变时的回调
+ * @returns value: 组件应该采用的值，onChange：值改变时的回调，处理非受控值与向父组件传递值的逻辑
+ */
+declare const useCombineControlValue: <V>({ props, valueKey, defaultValue, onChange }: {
+    props: Record<string, any>;
+    valueKey?: string;
+    defaultValue?: V;
+    onChange?: (val: V) => void;
+}) => {
+    value: any;
+    onChange: (nextVal: V) => void;
+};
+
+export { useCombineControlValue };

package/{dist/cjs → cjs}/request/index.cjs

@@ -2,9 +2,9 @@
 
 var tslib = require('tslib');
 var axios = require('axios');
-var lodash = require('lodash');
+var at = require('lodash-es/at');
 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');
 
@@ -54,7 +54,7 @@ function createBaseRequest(baseOptions) {
                 return tslib.__generator(this, function (_h) {
                     switch (_h.label) {
                         case 0:
-                            errorCode = String(lodash.at(res.data, errorCodePath));
+                            errorCode = String(at(res.data, errorCodePath));
                             if (successCodes.includes(errorCode)) {
                                 if (cacheData) {
                                     cache.setCache(requestDataOrParams, res.data, { cacheTime: cacheTime });

package/{dist/types → cjs}/request/index.d.ts

@@ -1,5 +1,6 @@
 import { AxiosResponse, Method, AxiosRequestConfig } from 'axios';
 import { StorageType } from '../cache/index.js';
+export { default as RequestError, RequestErrorType } from './error.js';
 
 /**
  * 错误处理器返回类型

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/store/index.d.ts

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

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/cjs/validator/index.d.ts

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

package/{dist/cjs → cjs}/validator/validator.cjs

@@ -13,14 +13,14 @@ var BaseValidator = /** @class */ (function () {
      */
     function BaseValidator() {
         /** 用于存储验证器映射的私有符号 */
-        this.__keySymbol = Symbol('key-description');
-        this.__keySymbol = Symbol('key-description');
+        this.__keySymbol = Symbol("key-description");
+        this.__keySymbol = Symbol("key-description");
         this[this.__keySymbol] = {};
     }
     /**
      * 验证单个字段
-     * @param itemKey 要验证的字段名
      * @param itemAll 是否验证所有规则，为true时会验证该字段的所有规则，为false时遇到第一个失败的规则就停止
+     * @param itemKey 要验证的字段名
      * @returns 验证错误数组，如果没有错误则返回null
      */
     BaseValidator.prototype.validate = function (itemKey, itemAll) {
@@ -30,13 +30,13 @@ var BaseValidator = /** @class */ (function () {
         // 校验每个 key
         var validators = validatorMap[itemKey];
         if (!validators) {
-            return errors;
+            return null;
         }
         for (var _i = 0, validators_1 = validators; _i < validators_1.length; _i++) {
             var validator = validators_1[_i];
             var res = validator(this[itemKey]);
             if (!res.status) {
-                errors.push(res);
+                errors.push(res.message);
                 if (!itemAll)
                     break;
             }
@@ -48,16 +48,16 @@ var BaseValidator = /** @class */ (function () {
     };
     /**
      * 验证多个或所有字段
+     * @param order 验证字段的顺序，可以指定验证的字段名数组及其顺序
      * @param itemAll 是否验证每个字段的所有规则，为true时会验证字段的所有规则，为false时遇到第一个失败的规则就停止
      * @param everyItem 是否验证所有字段，为true时会验证所有字段，为false时遇到第一个失败的字段就停止
-     * @param order 验证字段的顺序，可以指定验证的字段名数组及其顺序
      * @returns 验证错误数组，如果没有错误则返回null
      */
-    BaseValidator.prototype.validateAll = function (itemAll, everyItem, order) {
+    BaseValidator.prototype.validateAll = function (order, itemAll, everyItem) {
         if (itemAll === void 0) { itemAll = false; }
         if (everyItem === void 0) { everyItem = false; }
         var validatorMap = this[this.__keySymbol];
-        var errors = [];
+        var errors = {};
         // 校验每个 key
         var keys = order || Object.keys(validatorMap);
         for (var _i = 0, keys_1 = keys; _i < keys_1.length; _i++) {
@@ -69,7 +69,12 @@ var BaseValidator = /** @class */ (function () {
                 var fn = fns_1[_a];
                 var res = fn(value);
                 if (!res.status) {
-                    errors.push(res);
+                    if (Array.isArray(errors[res.name])) {
+                        errors[res.name].push(res.message);
+                    }
+                    else {
+                        errors[res.name] = [res.message];
+                    }
                     if (!itemAll)
                         break;
                 }
@@ -78,7 +83,7 @@ var BaseValidator = /** @class */ (function () {
                 break;
             }
         }
-        if (errors.length) {
+        if (Object.keys(errors).length) {
             return errors;
         }
         return null;
@@ -130,17 +135,17 @@ var BaseValidator = /** @class */ (function () {
                     var validator = function (val) {
                         var validateStatus = func(val, value, context);
                         if (validateStatus) {
-                            return { status: true };
+                            return { name: name, status: true };
                         }
                         else {
-                            var msg = '';
-                            if (typeof message === 'function') {
+                            var msg = "";
+                            if (typeof message === "function") {
                                 msg = message(val, value, context);
                             }
                             else {
                                 msg = message;
                             }
-                            return { status: false, message: msg };
+                            return { name: name, status: false, message: msg };
                         }
                     };
                     if (validators[name]) {

package/{dist/types → cjs}/validator/validator.d.ts

@@ -4,6 +4,7 @@
  * @returns 包含验证状态和可选错误消息的对象
  */
 type Validator = (val: any) => {
+    name: string;
     status: boolean;
     message?: string;
 };
@@ -31,25 +32,19 @@ declare class BaseValidator {
     constructor();
     /**
      * 验证单个字段
-     * @param itemKey 要验证的字段名
      * @param itemAll 是否验证所有规则，为true时会验证该字段的所有规则，为false时遇到第一个失败的规则就停止
+     * @param itemKey 要验证的字段名
      * @returns 验证错误数组，如果没有错误则返回null
      */
-    validate(itemKey: string, itemAll?: boolean): {
-        status: boolean;
-        message?: string;
-    }[];
+    validate(itemKey: string, itemAll?: boolean): string[] | null;
     /**
      * 验证多个或所有字段
+     * @param order 验证字段的顺序，可以指定验证的字段名数组及其顺序
      * @param itemAll 是否验证每个字段的所有规则，为true时会验证字段的所有规则，为false时遇到第一个失败的规则就停止
      * @param everyItem 是否验证所有字段，为true时会验证所有字段，为false时遇到第一个失败的字段就停止
-     * @param order 验证字段的顺序，可以指定验证的字段名数组及其顺序
      * @returns 验证错误数组，如果没有错误则返回null
      */
-    validateAll(itemAll?: boolean, everyItem?: boolean, order?: string[]): {
-        status: boolean;
-        message?: string;
-    }[];
+    validateAll(order?: string[], itemAll?: boolean, everyItem?: boolean): Record<string, string[]> | null;
     /**
      * 装饰器创建器
      * 用于创建属性验证装饰器的工厂函数

package/es/cache/index.d.ts

@@ -0,0 +1,141 @@
+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;
+    /**
+     * 构造函数
+     * @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 };