rxtutils 1.1.4-beta.9 → 1.1.6

package/cjs/validator/decorators.cjs

@@ -1,238 +1,81 @@
-'use strict';
-
-var validator = require('./validator.cjs');
-
-/**
- * 验证器装饰器模块
- * 提供一系列用于数据验证的装饰器，可用于类属性的验证规则定义
- * 这些装饰器基于 BaseValidator 的 decoratorCreator 方法创建
- */
-/**
- * 必填项验证装饰器
- * 验证值是否存在且不在指定的无效值列表中
- *
- * @param noneVals 被视为无效的值数组，默认为 [undefined]
- * @returns 装饰器工厂函数，可接收自定义错误消息
- *
- * @example
- * class User extends BaseValidator {
- *   @(VRequired()('用户名不能为空'))
- *   username?: string;
- * }
- */
-function VRequired(noneVals) {
-    if (noneVals === void 0) { noneVals = [undefined]; }
-    return validator.BaseValidator.decoratorCreator(function (val) {
-        if (noneVals.includes(val)) {
-            return false;
-        }
-        return true;
-    });
-}
-/**
- * 字符串类型验证装饰器
- * 验证值是否为字符串类型
- *
- * @returns 装饰器工厂函数，可接收自定义错误消息
- *
- * @example
- * class User extends BaseValidator {
- *   @VString('用户名必须为字符串')
- *   username?: string;
- * }
- */
-var VString = validator.BaseValidator.decoratorCreator(function (val) {
-    if (typeof val !== 'string') {
-        return false;
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const validator = require("./validator.cjs");
+function VRequired(noneVals = [void 0]) {
+  return validator.BaseValidator.decoratorCreator((val) => {
+    if (noneVals.includes(val)) {
+      return false;
     }
     return true;
+  });
+}
+const VString = validator.BaseValidator.decoratorCreator((val) => {
+  if (typeof val !== "string") {
+    return false;
+  }
+  return true;
 });
-/**
- * 数字类型验证装饰器
- * 验证值是否为数字类型
- *
- * @returns 装饰器工厂函数，可接收自定义错误消息
- *
- * @example
- * class User extends BaseValidator {
- *   @VNumber('年龄必须为数字')
- *   age?: number;
- * }
- */
-var VNumber = validator.BaseValidator.decoratorCreator(function (val) {
-    if (typeof val !== 'number') {
-        return false;
-    }
-    return true;
+const VNumber = validator.BaseValidator.decoratorCreator((val) => {
+  if (typeof val !== "number") {
+    return false;
+  }
+  return true;
 });
-/**
- * 数组类型验证装饰器
- * 验证值是否为数组类型
- *
- * @returns 装饰器工厂函数，可接收自定义错误消息
- *
- * @example
- * class User extends BaseValidator {
- *   @VArray('标签必须为数组')
- *   tags?: string[];
- * }
- */
-var VArray = validator.BaseValidator.decoratorCreator(function (val) {
-    if (!Array.isArray(val)) {
-        return false;
-    }
-    return true;
+const VArray = validator.BaseValidator.decoratorCreator((val) => {
+  if (!Array.isArray(val)) {
+    return false;
+  }
+  return true;
 });
-/**
- * 布尔类型验证装饰器
- * 验证值是否为布尔类型
- *
- * @returns 装饰器工厂函数，可接收自定义错误消息
- *
- * @example
- * class User extends BaseValidator {
- *   @VBoolean('状态必须为布尔值')
- *   active?: boolean;
- * }
- */
-var VBoolean = validator.BaseValidator.decoratorCreator(function (val) {
-    if (typeof val !== 'boolean') {
-        return false;
-    }
-    return true;
+const VBoolean = validator.BaseValidator.decoratorCreator((val) => {
+  if (typeof val !== "boolean") {
+    return false;
+  }
+  return true;
 });
-/**
- * 最小值验证装饰器
- * 验证数字是否大于或等于指定的最小值
- *
- * @param min 最小值
- * @returns 装饰器工厂函数，可接收自定义错误消息
- *
- * @example
- * class User extends BaseValidator {
- *   @(VMin(18)('年龄必须大于或等于18岁'))
- *   age?: number;
- * }
- */
-var VMin = function (min) {
-    return validator.BaseValidator.decoratorCreator(function (val) {
-        if (typeof val !== 'number' || val < min) {
-            return false;
-        }
-        return true;
-    });
-};
-/**
- * 最大值验证装饰器
- * 验证数字是否小于或等于指定的最大值
- *
- * @param max 最大值
- * @returns 装饰器工厂函数，可接收自定义错误消息
- *
- * @example
- * class User extends BaseValidator {
- *   @(VMax(120)('年龄必须小于或等于120岁'))
- *   age?: number;
- * }
- */
-var VMax = function (max) {
-    return validator.BaseValidator.decoratorCreator(function (val) {
-        if (typeof val !== 'number' || val > max) {
-            return false;
-        }
-        return true;
-    });
-};
-/**
- * 最小长度验证装饰器
- * 验证字符串或数组的长度是否大于或等于指定的最小长度
- *
- * @param minLen 最小长度
- * @returns 装饰器工厂函数，可接收自定义错误消息
- *
- * @example
- * class User extends BaseValidator {
- *   @(VMinLength(6)('密码长度不能少于6位'))
- *   password?: string;
- * }
- */
-var VMinLength = function (minLen) {
-    return validator.BaseValidator.decoratorCreator(function (val) {
-        if (typeof val !== 'string' && !Array.isArray(val)) {
-            return false;
-        }
-        if (val.length < minLen) {
-            return false;
-        }
-        return true;
-    });
-};
-/**
- * 最大长度验证装饰器
- * 验证字符串或数组的长度是否小于或等于指定的最大长度
- *
- * @param maxLen 最大长度
- * @returns 装饰器工厂函数，可接收自定义错误消息
- *
- * @example
- * class User extends BaseValidator {
- *   @(VMaxLength(20)('用户名长度不能超过20位'))
- *   username?: string;
- * }
- */
-var VMaxLength = function (maxLen) {
-    return validator.BaseValidator.decoratorCreator(function (val) {
-        if (typeof val !== 'string' && !Array.isArray(val)) {
-            return false;
-        }
-        if (val.length > maxLen) {
-            return false;
-        }
-        return true;
-    });
-};
-/**
- * 邮箱格式验证装饰器
- * 验证字符串是否符合邮箱格式
- *
- * @returns 装饰器工厂函数，可接收自定义错误消息
- *
- * @example
- * class User extends BaseValidator {
- *   @VEmail('邮箱格式不正确')
- *   email?: string;
- * }
- */
-var VEmail = validator.BaseValidator.decoratorCreator(function (val) {
-    if (typeof val !== 'string') {
-        return false;
-    }
-    // 简单邮箱正则
-    var emailReg = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-    return emailReg.test(val);
+const VMin = (min) => validator.BaseValidator.decoratorCreator((val) => {
+  if (typeof val !== "number" || val < min) {
+    return false;
+  }
+  return true;
+});
+const VMax = (max) => validator.BaseValidator.decoratorCreator((val) => {
+  if (typeof val !== "number" || val > max) {
+    return false;
+  }
+  return true;
+});
+const VMinLength = (minLen) => validator.BaseValidator.decoratorCreator((val) => {
+  if (typeof val !== "string" && !Array.isArray(val)) {
+    return false;
+  }
+  if (val.length < minLen) {
+    return false;
+  }
+  return true;
+});
+const VMaxLength = (maxLen) => validator.BaseValidator.decoratorCreator((val) => {
+  if (typeof val !== "string" && !Array.isArray(val)) {
+    return false;
+  }
+  if (val.length > maxLen) {
+    return false;
+  }
+  return true;
+});
+const VEmail = validator.BaseValidator.decoratorCreator((val) => {
+  if (typeof val !== "string") {
+    return false;
+  }
+  const emailReg = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  return emailReg.test(val);
+});
+const VPattern = (pattern) => validator.BaseValidator.decoratorCreator((val) => {
+  if (typeof val !== "string") {
+    return false;
+  }
+  return pattern.test(val);
 });
-/**
- * 正则表达式验证装饰器
- * 验证字符串是否匹配指定的正则表达式模式
- *
- * @param pattern 正则表达式
- * @returns 装饰器工厂函数，可接收自定义错误消息
- *
- * @example
- * class User extends BaseValidator {
- *   @(VPattern(/^1[3-9]\d{9}$/)('手机号格式不正确'))
- *   phone?: string;
- * }
- */
-var VPattern = function (pattern) {
-    return validator.BaseValidator.decoratorCreator(function (val) {
-        if (typeof val !== 'string') {
-            return false;
-        }
-        return pattern.test(val);
-    });
-};
-
 exports.VArray = VArray;
 exports.VBoolean = VBoolean;
 exports.VEmail = VEmail;

package/cjs/validator/index.cjs

@@ -1,10 +1,7 @@
-'use strict';
-
-var validator = require('./validator.cjs');
-var decorators = require('./decorators.cjs');
-
-
-
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const validator = require("./validator.cjs");
+const decorators = require("./decorators.cjs");
 exports.BaseValidator = validator.BaseValidator;
 exports.VArray = decorators.VArray;
 exports.VBoolean = decorators.VBoolean;

package/cjs/validator/validator.cjs

@@ -1,184 +1,108 @@
-'use strict';
-
-var tslib = require('tslib');
-
-var KEY_SYMBOL = Symbol("key-description");
-/**
- * 基础验证器类
- * 提供字段验证功能，可通过装饰器为类属性添加验证规则
- */
-var BaseValidator = /** @class */ (function () {
-    /**
-     * 构造函数
-     * 初始化验证器映射存储
-     */
-    function BaseValidator() {
-        /** 用于存储验证器映射的私有符号 */
-        this.__keySymbol = KEY_SYMBOL;
-        this[this.__keySymbol] = {};
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+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] = tslib.__spreadArray(tslib.__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']));
-
+  };
+};
+let BaseValidator = _BaseValidator;
 exports.BaseValidator = BaseValidator;

package/es/_utils/defaultEquals.mjs

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