rxtutils 1.1.4-beta.9 → 1.1.6

package/es/validator/validator.mjs

@@ -1,182 +1,108 @@
-import { __spreadArray } from 'tslib';
-
-var KEY_SYMBOL = Symbol("key-description");
-/**
- * 基础验证器类
- * 提供字段验证功能，可通过装饰器为类属性添加验证规则
- */
-var BaseValidator = /** @class */ (function () {
-    /**
-     * 构造函数
-     * 初始化验证器映射存储
-     */
-    function BaseValidator() {
-        /** 用于存储验证器映射的私有符号 */
-        this.__keySymbol = KEY_SYMBOL;
-        this[this.__keySymbol] = {};
+const KEY_SYMBOL = /* @__PURE__ */ Symbol("key-description");
+const _BaseValidator = class _BaseValidator {
+  /**
+   * 构造函数
+   * 初始化验证器映射存储
+   */
+  constructor() {
+    this.__keySymbol = KEY_SYMBOL;
+    this[this.__keySymbol] = {};
+  }
+  /**
+   * 验证单个字段
+   * @param itemAll 是否验证所有规则，为true时会验证该字段的所有规则，为false时遇到第一个失败的规则就停止
+   * @param itemKey 要验证的字段名
+   * @returns 验证错误数组，如果没有错误则返回null
+   */
+  validate(itemKey, itemAll = false) {
+    const validatorMap = this[this.__keySymbol];
+    const errors = [];
+    const validators = validatorMap[itemKey];
+    if (!validators) {
+      return null;
     }
-    /**
-     * 验证单个字段
-     * @param itemAll 是否验证所有规则，为true时会验证该字段的所有规则，为false时遇到第一个失败的规则就停止
-     * @param itemKey 要验证的字段名
-     * @returns 验证错误数组，如果没有错误则返回null
-     */
-    BaseValidator.prototype.validate = function (itemKey, itemAll) {
-        if (itemAll === void 0) { itemAll = false; }
-        var validatorMap = this[this.__keySymbol];
-        var errors = [];
-        // 校验每个 key
-        var validators = validatorMap[itemKey];
-        if (!validators) {
-            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.message);
-                if (!itemAll)
-                    break;
-            }
+    for (const validator of validators) {
+      const res = validator(this[itemKey]);
+      if (!res.status) {
+        errors.push(res.message || `${itemKey} error`);
+        if (!itemAll) break;
+      }
+    }
+    if (errors.length) {
+      return errors;
+    }
+    return null;
+  }
+  /**
+   * 验证多个或所有字段
+   * @param order 验证字段的顺序，可以指定验证的字段名数组及其顺序，默认验证所有字段，按对象定义顺序
+   * @param itemAll 是否验证每个字段的所有规则，为true时会验证字段的所有规则，为false时遇到第一个失败的规则就停止，默认为 false
+   * @param everyItem 是否验证所有字段，为true时会验证所有字段，为false时遇到第一个失败的字段就停止，默认为 false
+   * @returns 验证错误数组，如果没有错误则返回null
+   */
+  validateAll(order, itemAll = false, everyItem = false) {
+    const validatorMap = this[this.__keySymbol];
+    const errors = {};
+    const keys = order || Object.keys(validatorMap);
+    for (const key of keys) {
+      const value = this[key];
+      const fns = validatorMap[key];
+      for (const fn of fns) {
+        const res = fn(value);
+        if (!res.status) {
+          const msg = res.message || `${key} error`;
+          if (Array.isArray(errors[key])) {
+            errors[key].push(msg);
+          } else {
+            errors[key] = [msg];
+          }
+          if (!itemAll) break;
         }
-        if (errors.length) {
-            return errors;
+      }
+      if (errors[key] && !everyItem) {
+        break;
+      }
+    }
+    if (Object.keys(errors).length) {
+      return errors;
+    }
+    return null;
+  }
+};
+_BaseValidator.decoratorCreator = (func) => {
+  return (message = (val, value, context) => `${String(context.name)}格式错误`) => {
+    return function(value, context) {
+      context.addInitializer(function() {
+        let validators = this[this.__keySymbol];
+        if (!validators) {
+          this[this.__keySymbol] = {};
+          validators = this[this.__keySymbol];
         }
-        return null;
-    };
-    /**
-     * 验证多个或所有字段
-     * @param order 验证字段的顺序，可以指定验证的字段名数组及其顺序
-     * @param itemAll 是否验证每个字段的所有规则，为true时会验证字段的所有规则，为false时遇到第一个失败的规则就停止
-     * @param everyItem 是否验证所有字段，为true时会验证所有字段，为false时遇到第一个失败的字段就停止
-     * @returns 验证错误数组，如果没有错误则返回null
-     */
-    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 = {};
-        // 校验每个 key
-        var keys = order || Object.keys(validatorMap);
-        for (var _i = 0, keys_1 = keys; _i < keys_1.length; _i++) {
-            var key = keys_1[_i];
-            var value = this[key];
-            var fns = validatorMap[key];
-            // 校验每个校验项目
-            for (var _a = 0, fns_1 = fns; _a < fns_1.length; _a++) {
-                var fn = fns_1[_a];
-                var res = fn(value);
-                if (!res.status) {
-                    if (Array.isArray(errors[res.name])) {
-                        errors[res.name].push(res.message);
-                    }
-                    else {
-                        errors[res.name] = [res.message];
-                    }
-                    if (!itemAll)
-                        break;
-                }
+        const name = context.name;
+        const validator = (val) => {
+          const validateStatus = func(val, value, context);
+          if (validateStatus) {
+            return { name, status: true };
+          } else {
+            let msg = "";
+            if (typeof message === "function") {
+              msg = message(val, value, context);
+            } else {
+              msg = message;
             }
-            if (!everyItem) {
-                break;
-            }
-        }
-        if (Object.keys(errors).length) {
-            return errors;
-        }
-        return null;
-    };
-    /**
-     * 装饰器创建器
-     * 用于创建属性验证装饰器的工厂函数
-     *
-     * @param func 验证函数，接收属性值并返回布尔值表示验证结果
-     * @returns 返回一个接收错误消息的函数，该函数再返回实际的装饰器
-     *
-     * @example
-     * // 创建一个验证字符串的装饰器
-     * const VString = BaseValidator.decoratorCreator(
-     *   (val) => typeof val === 'string' || val === undefined
-     * );
-     *
-     * // 创建一个验证必填项的装饰器
-     * const VRequired = BaseValidator.decoratorCreator(
-     *   (val) => val !== undefined && val !== null && val !== ''
-     * );
-     *
-     * // 在类中使用这些装饰器
-     * class User extends BaseValidator {
-     *   @VString('名称必须为字符串')
-     *   @(VRequired()('名称必须填写'))
-     *   name?: string;
-     *
-     *   // 验证使用
-     *   validateName() {
-     *     return this.validate('name');
-     *   }
-     * }
-     *
-     * const user = new User();
-     * console.log(user.validateName()); // 显示错误信息：名称必须填写
-     */
-    BaseValidator.decoratorCreator = function (func) {
-        return function (message) {
-            if (message === void 0) { message = function (val, value, context) { return "".concat(String(context.name), "\u683C\u5F0F\u9519\u8BEF"); }; }
-            return function (value, context) {
-                context.addInitializer(function () {
-                    var validators = this[this.__keySymbol];
-                    if (!validators) {
-                        this[this.__keySymbol] = {};
-                        validators = this[this.__keySymbol];
-                    }
-                    var name = context.name;
-                    var validator = function (val) {
-                        var validateStatus = func(val, value, context);
-                        if (validateStatus) {
-                            return { name: name, status: true };
-                        }
-                        else {
-                            var msg = "";
-                            if (typeof message === "function") {
-                                msg = message(val, value, context);
-                            }
-                            else {
-                                msg = message;
-                            }
-                            return { name: name, status: false, message: msg };
-                        }
-                    };
-                    if (validators[name]) {
-                        validators[name] = __spreadArray(__spreadArray([], validators[name], true), [validator], false);
-                    }
-                    else {
-                        validators[name] = [validator];
-                    }
-                });
-            };
+            return { name, status: false, message: msg };
+          }
         };
+        if (validators[name]) {
+          validators[name] = [...validators[name], validator];
+        } else {
+          validators[name] = [validator];
+        }
+      });
     };
-    return BaseValidator;
-}());
-// class User extends BaseValidator{
-//   @VString('名称必须为字符串')
-//   @(VRequired()('名称必须填写'))
-//   name?: string;
-//   @VNumber('年龄必须为数字')
-//   @(VRequired()('年龄必须填写'))
-//   age?: number;
-//   @VEmail('邮箱格式不正确')
-//   @(VRequired()('邮箱必须填写'))
-//   email?: string;
-//   @(VMinLength(6)('密码长度不能少于6位'))
-//   @(VRequired()('密码必须填写'))
-//   password?: string
-// }
-// const user = new User();
-// user.name = '张三'
-// user.email = ' asdfasdf'
-// user.password = '12345'
-// console.log(user)
-// console.log(user.validateAll(false,true,['password','age','email']));
-
-export { BaseValidator };
+  };
+};
+let BaseValidator = _BaseValidator;
+export {
+  BaseValidator
+};

package/package.json

@@ -1,37 +1,107 @@
 {
   "name": "rxtutils",
-  "version": "1.1.4-beta.9",
+  "version": "1.1.6",
   "type": "module",
   "main": "cjs/index.cjs",
   "module": "es/index.mjs",
   "types": "es/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./es/index.d.ts",
+      "import": "./es/index.mjs",
+      "require": "./cjs/index.cjs"
+    },
+    "./cache": {
+      "types": "./es/cache/index.d.ts",
+      "import": "./es/cache/index.mjs",
+      "require": "./cjs/cache/index.cjs"
+    },
+    "./hooks": {
+      "types": "./es/hooks/index.d.ts",
+      "import": "./es/hooks/index.mjs",
+      "require": "./cjs/hooks/index.cjs"
+    },
+    "./request": {
+      "types": "./es/request/index.d.ts",
+      "import": "./es/request/index.mjs",
+      "require": "./cjs/request/index.cjs"
+    },
+    "./store": {
+      "types": "./es/store/index.d.ts",
+      "import": "./es/store/index.mjs",
+      "require": "./cjs/store/index.cjs"
+    },
+    "./validator": {
+      "types": "./es/validator/index.d.ts",
+      "import": "./es/validator/index.mjs",
+      "require": "./cjs/validator/index.cjs"
+    },
+    "./downloadBlob": {
+      "types": "./es/downloadBlob.d.ts",
+      "import": "./es/downloadBlob.mjs",
+      "require": "./cjs/downloadBlob.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "sideEffects": false,
   "files": [
     "es",
     "cjs"
   ],
   "scripts": {
-    "build": "pnpm clean && rollup -c",
-    "clean": "rm -rf es cjs",
+    "dev": "vite serve playground --config playground/vite.config.ts",
+    "build": "pnpm clean && vite build",
+    "clean": "rimraf es cjs dist",
+    "format": "prettier . --write",
+    "format:check": "prettier . --check",
+    "lint": "eslint . --max-warnings=0",
+    "lint:fix": "eslint . --fix",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc -p tsconfig.test.json --noEmit",
     "publishNpm": "npm publish --registry https://registry.npmjs.org",
     "loginNpm": "npm login --registry https://registry.npmjs.org"
   },
   "devDependencies": {
-    "@rollup/plugin-typescript": "^12.1.2",
+    "@babel/plugin-proposal-class-properties": "^7.18.6",
+    "@babel/plugin-proposal-decorators": "^7.28.6",
+    "@babel/plugin-transform-class-static-block": "^7.28.6",
+    "@eslint/js": "^9.39.2",
+    "@rollup/plugin-typescript": "^12.3.0",
+    "@testing-library/react": "^16.3.2",
     "@types/lodash-es": "^4.17.12",
-    "@types/node": "^22.15.29",
-    "@types/react": "^19.1.12",
-    "rollup": "^4.41.1",
-    "rollup-plugin-dts": "^6.2.1",
-    "typescript": "^5.8.3",
-    "vite": "^5.4.19"
+    "@types/node": "^22.19.5",
+    "@types/react": "^19.2.8",
+    "@types/react-dom": "^19.2.3",
+    "@vitejs/plugin-react": "^5.1.2",
+    "babel-plugin-react-compiler": "^1.0.0",
+    "eslint": "^9.39.2",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-prettier": "^5.5.5",
+    "eslint-plugin-react-hooks": "^7.0.1",
+    "eslint-plugin-vitest": "^0.5.4",
+    "fake-indexeddb": "^6.2.2",
+    "globals": "^17.3.0",
+    "jsdom": "^28.0.0",
+    "prettier": "^3.8.1",
+    "react": "^19.2.4",
+    "react-dom": "^19.2.4",
+    "rimraf": "^6.1.2",
+    "rollup": "^4.55.1",
+    "rollup-plugin-dts": "^6.3.0",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.54.0",
+    "vite": "^7.3.1",
+    "vite-plugin-dts": "^4.5.4",
+    "vitest": "^4.0.18"
   },
   "peerDependencies": {
-    "react": "^19.1.0"
+    "react": "^19.2.3"
   },
   "dependencies": {
-    "axios": "^1.9.0",
-    "lodash-es": "^4.17.21",
-    "moment": "^2.30.1",
+    "axios": "^1.13.2",
+    "date-fns": "^4.1.0",
+    "lodash-es": "^4.17.22",
     "tslib": "^2.8.1"
   }
-}
+}

package/cjs/_utils/deepAssign.cjs

@@ -1,25 +0,0 @@
-'use strict';
-
-function deepAssign(target) {
-    var sources = [];
-    for (var _i = 1; _i < arguments.length; _i++) {
-        sources[_i - 1] = arguments[_i];
-    }
-    for (var _a = 0, sources_1 = sources; _a < sources_1.length; _a++) {
-        var source = sources_1[_a];
-        for (var key in source) {
-            var val = source[key];
-            if (val &&
-                typeof val === 'object' &&
-                !Array.isArray(val)) {
-                target[key] = deepAssign(target[key] || {}, val);
-            }
-            else {
-                target[key] = val;
-            }
-        }
-    }
-    return target;
-}
-
-exports.deepAssign = deepAssign;

package/cjs/cache/index.d.ts

@@ -1,141 +0,0 @@
-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 };

package/cjs/cache/indexDB.d.ts

@@ -1,52 +0,0 @@
-/**
- * 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>;
-}
-
-export { IndexedDBStorage };

package/cjs/hooks/index.d.ts

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

package/cjs/hooks/useCombineControlValue.d.ts

@@ -1,21 +0,0 @@
-type UseCombineControlValueOptions<V> = {
-    props: Record<string, any>;
-    valueKey?: string;
-    defaultValue?: V;
-    onChange?: (val: V) => void;
-};
-type UseCombineControlValueEasyResult<V> = {
-    value: V;
-    onChange: (nextVal: V) => void;
-};
-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'> & {
-    onChange?: (...args: Parameters<R>) => void;
-}, resolveFn: (...args: Parameters<R>) => V): UseCombineControlValueResolveResult<V, R>;
-
-export { useCombineControlValue };
-export type { UseCombineControlValueEasyResult, UseCombineControlValueOptions, UseCombineControlValueResolveResult };

package/cjs/index.d.ts

@@ -1,8 +0,0 @@
-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 { useCombineControlValue } from './hooks/useCombineControlValue.js';
-export { default as RequestError, RequestErrorType } from './request/error.js';