使用ts 重构内容,编译内容

lib/fieldCheck.d.ts

@@ -0,0 +1,109 @@
+/**
+ * 表单字段验证库
+ * author:kindring
+ * date:2023/10/08
+ */
+import { checkFields, checkCode, checkRule, ruleItem, validatorFunction, errMessage, verifyForm } from "./types";
+/**
+ * @class FieldCheck
+ * @description 表单字段验证类
+ * @property {Array<ruleItem>} ruleItems 验证规则
+ * @property {function} addRuleItem 添加一条验证规则
+ * @property {function} verify 检查表单是否符合规则
+ * @example
+ * let fieldCheck = new FieldCheck();
+ * fieldCheck.addRuleItem('rule1',['name'],[
+ *    {
+ *    type: 'string',
+ *    minLength: 2,
+ *    maxLength: 10,
+ *    message: '姓名必须为2-10个字符'
+ *    }
+ *    ]);
+ *    fieldCheck.addRuleItem('rule2',['age'],[
+ *    {
+ *    type: 'number',
+ *    min: 18,
+ *    max: 100,
+ *    message: '年龄必须为18-100岁'
+ *    }]);
+ *    let errMsg = fieldCheck.verify({
+ *    name: 'kindring',
+ *    age: 18});
+ *    console.log(errMsg);
+ *    // null
+ *    let errMsg = fieldCheck.verify({
+ *    name: 'kindring',
+ *    age: 17});
+ *    console.log(errMsg);
+ *    // 年龄必须为18-100岁
+ */
+declare class FieldCheck {
+    #private;
+    code_pass: checkCode;
+    code_notPass: number;
+    code_notMatch: checkCode;
+    /**
+     *
+     * @param {Array< ruleItem >} [ruleItems] 验证规则数组
+     */
+    constructor(ruleItems?: Array<ruleItem>);
+    /**
+     * 判断值是否定义
+     * @param v
+     * @returns {boolean}
+     * @private
+     */
+    _isDef(v: any): boolean;
+    _toString: () => string;
+    /**
+     * 判断是否为空
+     * @param v 要检验的值
+     */
+    _isEmpty(v: any): boolean;
+    /**
+     * 判断是否为正则
+     * @param v 要检验的值
+     */
+    _isRegExp(v: any): boolean;
+    /**
+     * 构建验证规则
+     * @param {Array<string | RegExp>} checkFields 需要验证的字段
+     * @param {Array<validatorFunction | checkRule>} ruleArr 验证规则
+     * @returns {ruleItem} 验证规则对象
+     */
+    buildRuleItem(name: string, checkFields: checkFields, ruleArr: Array<validatorFunction | checkRule>): ruleItem;
+    /**
+     * 添加一条验证规则
+     * @param ruleName 验证规则名,用于区分
+     * @param checkFields 用于匹配字段的字符或者正则数组
+     * @param ruleArr 验证规则
+     * @returns  返回当前对象
+     */
+    addRuleItem(ruleName: string, checkFields: checkFields, ruleArr: Array<validatorFunction | checkRule>): this;
+    /**
+     * 获取验证规则
+     * @param field 字段名
+     * @returns 验证规则
+     */
+    getRuleItem(field: string): ruleItem | undefined;
+    /**
+     * 检查字段是否符合规则
+     * @param field 字段名
+     * @param value 字段值
+     * @returns {Array<checkCode | ?errMessage>} 错误码或错误信息
+     */
+    checkField(field: string, value: any): [
+        checkCode,
+        errMessage
+    ] | [checkCode];
+    /**
+     * 检查表单是否符合规则
+     * @param formObject 需要检验的表单项 字段:值
+     * @param [isMustMatch] 是否强制要求匹配规则
+     * @returns errMessage 错误码或错误信息
+     */
+    verify(formObject: verifyForm, isMustMatch?: boolean): errMessage;
+}
+export default FieldCheck;
+//# sourceMappingURL=fieldCheck.d.ts.map

lib/fieldCheck.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fieldCheck.d.ts","sourceRoot":"","sources":["../src/fieldCheck.ts"],"names":[],"mappings":"AACA;;;;GAIG;AAOH,OAAO,EACH,WAAW,EACX,SAAS,EACT,SAAS,EACT,QAAQ,EACR,iBAAiB,EACjB,UAAU,EAEV,UAAU,EACb,MAAM,SAAS,CAAC;AAIjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,cAAM,UAAU;;IAGZ,SAAS,YAAuB;IAEhC,YAAY,EAAC,MAAM,CAA0B;IAG7C,aAAa,YAA2B;IAOxC;;;OAGG;gBACS,SAAS,CAAC,EAAC,KAAK,CAAE,QAAQ,CAAE;IAUxC;;;;;OAKG;IACH,MAAM,CAAE,CAAC,EAAC,GAAG;IAGb,SAAS,eAA6B;IACtC;;;OAGG;IACH,QAAQ,CAAC,CAAC,EAAC,GAAG;IAId;;;OAGG;IACH,SAAS,CAAE,CAAC,EAAC,GAAG;IAKhB;;;;;OAKG;IACH,aAAa,CAAC,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,WAAW,EACxB,OAAO,EAAC,KAAK,CAAC,iBAAiB,GAAG,SAAS,CAAC,GAAK,QAAQ;IA4BvE;;;;;;OAMG;IACH,WAAW,CACP,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,WAAW,EACxB,OAAO,EAAE,KAAK,CAAC,iBAAiB,GAAG,SAAS,CAAC;IASjD;;;;OAIG;IACH,WAAW,CAAC,KAAK,EAAC,MAAM,GAAE,QAAQ,GAAG,SAAS;IA0B9C;;;;;OAKG;IACH,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,GAChC;QAAE,SAAS;QAAE,UAAU;KAAE,GAAG,CAAE,SAAS,CAAE;IAoE7C;;;;;OAKG;IACH,MAAM,CAAC,UAAU,EAAE,UAAU,EAAE,WAAW,GAAC,OAAe;CAW7D;AAED,eAAe,UAAU,CAAC"}

lib/fieldCheck.js

@@ -1,222 +1,258 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports["default"] = void 0;
-function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
-function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
-function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
-function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
-function _classPrivateFieldInitSpec(obj, privateMap, value) { _checkPrivateRedeclaration(obj, privateMap); privateMap.set(obj, value); }
-function _checkPrivateRedeclaration(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }
-function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); }
-function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; }
-function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; }
-function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); }
-function _classApplyDescriptorSet(receiver, descriptor, value) { if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } }
-var _code_pass = new WeakMap();
-var _code_notPass = new WeakMap();
-var _code_notMatch = new WeakMap();
-var _ruleItems = new WeakMap();
-var FieldCheck = function () {
-  function FieldCheck(ruleItems) {
-    _classCallCheck(this, FieldCheck);
-    _classPrivateFieldInitSpec(this, _code_pass, {
-      writable: true,
-      value: 1
-    });
-    _classPrivateFieldInitSpec(this, _code_notPass, {
-      writable: true,
-      value: 2
-    });
-    _classPrivateFieldInitSpec(this, _code_notMatch, {
-      writable: true,
-      value: 3
-    });
-    _classPrivateFieldInitSpec(this, _ruleItems, {
-      writable: true,
-      value: []
-    });
-    _defineProperty(this, "_toString", Object.prototype.toString);
-    _classPrivateFieldSet(this, _ruleItems, []);
-    if (ruleItems && Array.isArray(ruleItems)) {
-      var _iterator = _createForOfIteratorHelper(ruleItems),
-        _step;
-      try {
-        for (_iterator.s(); !(_step = _iterator.n()).done;) {
-          var ruleItem = _step.value;
-          this.addRuleItem(ruleItem.name || "", ruleItem.checkFields, ruleItem.rules);
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _FieldCheck_ruleItems;
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * 表单字段验证库
+ * author:kindring
+ * date:2023/10/08
+ */
+const types_1 = require("./types");
+/**
+ * @class FieldCheck
+ * @description 表单字段验证类
+ * @property {Array<ruleItem>} ruleItems 验证规则
+ * @property {function} addRuleItem 添加一条验证规则
+ * @property {function} verify 检查表单是否符合规则
+ * @example
+ * let fieldCheck = new FieldCheck();
+ * fieldCheck.addRuleItem('rule1',['name'],[
+ *    {
+ *    type: 'string',
+ *    minLength: 2,
+ *    maxLength: 10,
+ *    message: '姓名必须为2-10个字符'
+ *    }
+ *    ]);
+ *    fieldCheck.addRuleItem('rule2',['age'],[
+ *    {
+ *    type: 'number',
+ *    min: 18,
+ *    max: 100,
+ *    message: '年龄必须为18-100岁'
+ *    }]);
+ *    let errMsg = fieldCheck.verify({
+ *    name: 'kindring',
+ *    age: 18});
+ *    console.log(errMsg);
+ *    // null
+ *    let errMsg = fieldCheck.verify({
+ *    name: 'kindring',
+ *    age: 17});
+ *    console.log(errMsg);
+ *    // 年龄必须为18-100岁
+ */
+class FieldCheck {
+    /**
+     *
+     * @param {Array< ruleItem >} [ruleItems] 验证规则数组
+     */
+    constructor(ruleItems) {
+        // 通过
+        this.code_pass = types_1.checkCode.code_pass;
+        // 未通过
+        this.code_notPass = types_1.checkCode.code_notPass;
+        // 无法匹配到验证规则
+        this.code_notMatch = types_1.checkCode.code_notMatch;
+        /**
+         * @type {Array< ruleItem >}
+         */
+        _FieldCheck_ruleItems.set(this, []);
+        this._toString = Object.prototype.toString;
+        __classPrivateFieldSet(this, _FieldCheck_ruleItems, [], "f");
+        if (ruleItems && Array.isArray(ruleItems)) {
+            // 使用 addRuleItem 添加规则
+            for (const ruleItem of ruleItems) {
+                this.addRuleItem(ruleItem.name || "", ruleItem.checkFields, ruleItem.rules);
+            }
         }
-      } catch (err) {
-        _iterator.e(err);
-      } finally {
-        _iterator.f();
-      }
     }
-  }
-  _createClass(FieldCheck, [{
-    key: "_isDef",
-    value: function _isDef(v) {
-      return v !== undefined && v !== null;
+    /**
+     * 判断值是否定义
+     * @param v
+     * @returns {boolean}
+     * @private
+     */
+    _isDef(v) {
+        return v !== undefined && v !== null;
     }
-  }, {
-    key: "_isEmpty",
-    value: function _isEmpty(v) {
-      return v === undefined || v === '';
+    /**
+     * 判断是否为空
+     * @param v 要检验的值
+     */
+    _isEmpty(v) {
+        return v === undefined || v === '';
     }
-  }, {
-    key: "_isRegExp",
-    value: function _isRegExp(v) {
-      return this._toString.call(v) === '[object RegExp]';
+    /**
+     * 判断是否为正则
+     * @param v 要检验的值
+     */
+    _isRegExp(v) {
+        return this._toString.call(v) === '[object RegExp]';
     }
-  }, {
-    key: "buildRuleItem",
-    value: function buildRuleItem(checkFields, ruleArr) {
-      if (!Array.isArray(checkFields) || !Array.isArray(ruleArr)) {
-        throw new Error('checkFields or ruleArr is not Array');
-      }
-      var _iterator2 = _createForOfIteratorHelper(checkFields),
-        _step2;
-      try {
-        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-          var field = _step2.value;
-          if (typeof field !== 'string' && !this._isRegExp(field)) {
-            throw new Error('checkFields item is not string or RegExp');
-          }
+    /**
+     * 构建验证规则
+     * @param {Array<string | RegExp>} checkFields 需要验证的字段
+     * @param {Array<validatorFunction | checkRule>} ruleArr 验证规则
+     * @returns {ruleItem} 验证规则对象
+     */
+    buildRuleItem(name, checkFields, ruleArr) {
+        //  检测checkFields是否为数组
+        //  检测ruleArr是否为数组
+        if (!Array.isArray(checkFields) || !Array.isArray(ruleArr)) {
+            throw new Error('checkFields or ruleArr is not Array');
         }
-      } catch (err) {
-        _iterator2.e(err);
-      } finally {
-        _iterator2.f();
-      }
-      var _iterator3 = _createForOfIteratorHelper(ruleArr),
-        _step3;
-      try {
-        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
-          var rule = _step3.value;
-          if (typeof rule !== 'function' && _typeof(rule) !== 'object') {
-            throw new Error('ruleArr item is not function or object');
-          }
+        //  检测checkFields中的每一项是否为字符串或者正则
+        for (let field of checkFields) {
+            if (typeof field !== 'string' && !this._isRegExp(field)) {
+                throw new Error('checkFields item is not string or RegExp');
+            }
         }
-      } catch (err) {
-        _iterator3.e(err);
-      } finally {
-        _iterator3.f();
-      }
-      var ruleItem = {
-        checkFields: checkFields,
-        rules: ruleArr
-      };
-      return ruleItem;
+        //  检测ruleArr中的每一项是否为函数或者对象
+        for (let rule of ruleArr) {
+            if (typeof rule !== 'function' && typeof rule !== 'object') {
+                throw new Error('ruleArr item is not function or object');
+            }
+        }
+        let ruleItem = {
+            name: name || "",
+            checkFields: checkFields,
+            rules: ruleArr
+        };
+        // this.ruleItems = this.ruleItems.push(ruleItem);
+        return ruleItem;
     }
-  }, {
-    key: "addRuleItem",
-    value: function addRuleItem(ruleName, checkFields, ruleArr) {
-      var ruleItem = this.buildRuleItem(checkFields, ruleArr);
-      _classPrivateFieldGet(this, _ruleItems).push(ruleItem);
-      return this;
+    /**
+     * 添加一条验证规则
+     * @param ruleName 验证规则名,用于区分
+     * @param checkFields 用于匹配字段的字符或者正则数组
+     * @param ruleArr 验证规则
+     * @returns  返回当前对象
+     */
+    addRuleItem(ruleName, checkFields, ruleArr) {
+        let ruleItem = this.buildRuleItem(ruleName, checkFields, ruleArr);
+        __classPrivateFieldGet(this, _FieldCheck_ruleItems, "f").push(ruleItem);
+        return this;
     }
-  }, {
-    key: "getRuleItem",
-    value: function getRuleItem(field) {
-      var _this = this;
-      return _classPrivateFieldGet(this, _ruleItems).find(function (item) {
-        var _iterator4 = _createForOfIteratorHelper(item.checkFields),
-          _step4;
-        try {
-          for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
-            var _matchKey = _step4.value;
-            if (_this._isRegExp(_matchKey)) {
-              if (_matchKey.test(field)) {
-                return true;
-              }
-            } else {
-              if (_matchKey === field) {
-                return true;
-              }
+    /**
+     * 获取验证规则
+     * @param field 字段名
+     * @returns 验证规则
+     */
+    getRuleItem(field) {
+        return __classPrivateFieldGet(this, _FieldCheck_ruleItems, "f").find(item => {
+            // 判断是否为正则
+            for (const _matchKey of item.checkFields) {
+                // 判断是否为正则
+                if (this._isRegExp(_matchKey)) {
+                    // 确定为正则
+                    let reg = _matchKey;
+                    // console.log(`使用正则进行匹配,${_matchKey.test(key)}`);
+                    if (reg.test(field)) {
+                        // console.log(`通过正则匹配规则成功,${_matchKey.test(key)}`);
+                        return true;
+                    }
+                }
+                else {
+                    // console.log(`比较是否全等,${_matchKey} === ${key} ?${_matchKey === key}`);
+                    if (_matchKey === field) {
+                        // console.log(`通过字符${_matchKey}匹配成功`);
+                        return true;
+                    }
+                }
             }
-          }
-        } catch (err) {
-          _iterator4.e(err);
-        } finally {
-          _iterator4.f();
-        }
-        return false;
-      });
+            return false;
+        });
     }
-  }, {
-    key: "checkField",
-    value: function checkField(field, value) {
-      var ruleItem = this.getRuleItem(field);
-      if (!ruleItem || !ruleItem.rules) {
-        return [_classPrivateFieldGet(this, _code_notMatch)];
-      }
-      if (value === undefined) {
-        return [_classPrivateFieldGet(this, _code_notPass), '字段值为undefined'];
-      }
-      var _iterator5 = _createForOfIteratorHelper(ruleItem.rules),
-        _step5;
-      try {
-        for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
-          var _rule = _step5.value;
-          if (typeof _rule === 'function') {
-            var _msg = _rule(value);
-            if (_msg) {
-              return [_classPrivateFieldGet(this, _code_notPass), _msg];
+    /**
+     * 检查字段是否符合规则
+     * @param field 字段名
+     * @param value 字段值
+     * @returns {Array<checkCode | ?errMessage>} 错误码或错误信息
+     */
+    checkField(field, value) {
+        let ruleItem = this.getRuleItem(field);
+        if (!ruleItem || !ruleItem.rules) {
+            return [this.code_notMatch];
+        }
+        // 判断值是否为undefined
+        if (value === undefined) {
+            return [this.code_notPass, '字段值为undefined'];
+        }
+        // 开始匹配规则
+        for (let _rule of ruleItem.rules) {
+            // 判断是否有自定义验证函数
+            if (typeof _rule === 'function') {
+                let _msg = _rule(value);
+                // console.log(_msg)
+                if (_msg) {
+                    return [this.code_notPass, _msg];
+                }
+            }
+            let rule = _rule;
+            // 判断类型
+            if (rule.type && typeof value !== rule.type) {
+                return [this.code_notPass, rule.message];
+            }
+            // 判断是否为必填项
+            if (rule.require && this._isEmpty(value)) {
+                return [this.code_notPass, rule.message];
+            }
+            // 判断最小值
+            if (rule.min && value < rule.min) {
+                return [this.code_notPass, rule.message];
+            }
+            // 判断最大值
+            if (rule.max && value > rule.max) {
+                return [this.code_notPass, rule.message];
+            }
+            // 判断值是否达到指定长度
+            if (rule.length && value.length && value.length !== rule.length) {
+                return [this.code_notPass, rule.message];
+            }
+            // 判断最小长度
+            if (rule.minLength && value.length && value.length < rule.minLength) {
+                return [this.code_notPass, rule.message];
+            }
+            // 判断最大长度
+            if (rule.maxLength && value.length && value.length > rule.maxLength) {
+                return [this.code_notPass, rule.message];
+            }
+            // 判断是否符合正则
+            if (rule.regex && !rule.regex.test(value)) {
+                return [this.code_notPass, rule.message];
             }
-          }
-          if (_rule.type && _typeof(value) !== _rule.type) {
-            return [_classPrivateFieldGet(this, _code_notPass), _rule.message];
-          }
-          if (_rule.require && this._isEmpty(value)) {
-            return [_classPrivateFieldGet(this, _code_notPass), _rule.message];
-          }
-          if (_rule.min && value < _rule.min) {
-            return [_classPrivateFieldGet(this, _code_notPass), _rule.message];
-          }
-          if (_rule.max && value > _rule.max) {
-            return [_classPrivateFieldGet(this, _code_notPass), _rule.message];
-          }
-          if (_rule.length && value.length && value.length !== _rule.length) {
-            return [_classPrivateFieldGet(this, _code_notPass), _rule.message];
-          }
-          if (_rule.minLength && value.length && value.length < _rule.minLength) {
-            return [_classPrivateFieldGet(this, _code_notPass), _rule.message];
-          }
-          if (_rule.maxLength && value.length && value.length > _rule.maxLength) {
-            return [_classPrivateFieldGet(this, _code_notPass), _rule.message];
-          }
-          if (_rule.regex && !_rule.regex.test(value)) {
-            return [_classPrivateFieldGet(this, _code_notPass), _rule.message];
-          }
         }
-      } catch (err) {
-        _iterator5.e(err);
-      } finally {
-        _iterator5.f();
-      }
-      return [_classPrivateFieldGet(this, _code_pass)];
+        return [this.code_pass];
     }
-  }, {
-    key: "verify",
-    value: function verify(formObject, isMustMatch) {
-      for (var _oKey in formObject) {
-        var value = formObject[_oKey];
-        var r = this.checkField(_oKey, value);
-        if (r[0] === _classPrivateFieldGet(this, _code_notPass)) {
-          return r[1];
-        } else if (isMustMatch && r[0] === _classPrivateFieldGet(this, _code_notMatch)) {
-          return "\u5B57\u6BB5\u6CA1\u6709\u5BF9\u5E94\u5339\u914D\u9879";
+    /**
+     * 检查表单是否符合规则
+     * @param formObject 需要检验的表单项 字段:值
+     * @param [isMustMatch] 是否强制要求匹配规则
+     * @returns errMessage 错误码或错误信息
+     */
+    verify(formObject, isMustMatch = false) {
+        for (const _oKey in formObject) {
+            let value = formObject[_oKey];
+            let r = this.checkField(_oKey, value);
+            if (r[0] === this.code_notPass) {
+                return r[1];
+            }
+            else if (isMustMatch && r[0] === this.code_notMatch) {
+                return `字段没有对应匹配项`;
+            }
         }
-      }
     }
-  }]);
-  return FieldCheck;
-}();
-var _default = exports["default"] = FieldCheck;
+}
+_FieldCheck_ruleItems = new WeakMap();
+exports.default = FieldCheck;

lib/formData.d.ts

@@ -0,0 +1,53 @@
+import FieldCheck from "./fieldCheck";
+import { formItemData, formObject, FormVerifyOption } from "./types";
+/**
+ * @class FormItem 表单验证类
+ * @description 表单项
+ * @param {object} object 表单项数据
+ * @param {FieldCheck} [fieldCheck] 字段验证对象
+ * @param {object} [option] 配置项
+ */
+declare class FormVerify {
+    formData: formObject | null;
+    fieldCheck: FieldCheck;
+    defaultOption: FormVerifyOption;
+    option: FormVerifyOption;
+    static formState_default: number;
+    static formState_pass: number;
+    static formState_notPass: number;
+    formState_default: number;
+    formState_pass: number;
+    formState_notPass: number;
+    /**
+     *
+     * @param object
+     * @param {FieldCheck} [fieldCheck] 字段验证对象
+     * @param {object} [option] 配置项
+     */
+    constructor(object: formObject, fieldCheck?: FieldCheck, option?: FormVerifyOption);
+    static isObject(obj: any): boolean;
+    /**
+     * 检查表单项是否符合要求
+     * @param  object 表单项数据
+     * @param  field 字段名
+     * @param  formItemData 表单项数据
+     * @param  fieldCheck 字段验证对象
+     * @param  isMustMatchRule 表单字段是否必须匹配到验证规则
+     * @returns  errMsg 错误信息
+     */
+    static buildFormItem(object: formObject, field: string, formItemData: formItemData, fieldCheck: FieldCheck, isMustMatchRule: boolean): string;
+    /**
+     * 初始化表单项数据
+     * @param { formObject } formObject 表单对象
+     */
+    static initFormItemData(formObject: formObject): void;
+    /**
+     * 检查表单项是否符合要求
+     * @param form 表单对象
+     * @param isMustMatch 是否必须全部匹配到验证规则
+     * @returns {boolean}
+     */
+    checkForm(form: formObject, isMustMatch: boolean): boolean;
+}
+export default FormVerify;
+//# sourceMappingURL=formData.d.ts.map

lib/formData.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formData.d.ts","sourceRoot":"","sources":["../src/formData.ts"],"names":[],"mappings":"AACA,OAAO,UAAU,MAAM,cAAc,CAAC;AACtC,OAAO,EAAC,YAAY,EAAE,UAAU,EAAc,gBAAgB,EAAC,MAAM,SAAS,CAAC;AAO/E;;;;;;GAMG;AACH,cAAM,UAAU;IACZ,QAAQ,EAAC,UAAU,GAAG,IAAI,CAAQ;IAElC,UAAU,EAAC,UAAU,CAAC;IAGtB,aAAa,EAAE,gBAAgB,CAE9B;IACD,MAAM,EAAE,gBAAgB,CAEtB;IAEF,OAAc,iBAAiB,EAAE,MAAM,CAAC;IACxC,OAAc,cAAc,EAAE,MAAM,CAAC;IACrC,OAAc,iBAAiB,EAAE,MAAM,CAAC;IAExC,iBAAiB,EAAE,MAAM,CAAK;IAC9B,cAAc,EAAE,MAAM,CAAK;IAC3B,iBAAiB,EAAE,MAAM,CAAK;IAC9B;;;;;OAKG;gBACS,MAAM,EAAC,UAAU,EAAE,UAAU,CAAC,EAAC,UAAU,EAAE,MAAM,CAAC,EAAC,gBAAgB;IAiB/E,MAAM,CAAC,QAAQ,CAAE,GAAG,EAAC,GAAG;IAIxB;;;;;;;;OAQG;IACH,MAAM,CAAC,aAAa,CAAC,MAAM,EAAE,UAAU,EAClB,KAAK,EAAE,MAAM,EACb,YAAY,EAAE,YAAY,EAC1B,UAAU,EAAE,UAAU,EACtB,eAAe,EAAE,OAAO;IA4G7C;;;OAGG;IACH,MAAM,CAAC,gBAAgB,CAAG,UAAU,EAAE,UAAU;IAYhD;;;;;OAKG;IACH,SAAS,CAAE,IAAI,EAAE,UAAU,EAAE,WAAW,EAAE,OAAO;CAkGpD;AAED,eAAe,UAAU,CAAC"}

lib/formData.js

@@ -1,209 +1,263 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports["default"] = void 0;
-var _fieldCheck = _interopRequireDefault(require("./fieldCheck"));
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
-function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
-function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
-function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
-var hasOwnProperty = Object.prototype.hasOwnProperty;
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fieldCheck_1 = __importDefault(require("./fieldCheck"));
+let hasOwnProperty = Object.prototype.hasOwnProperty;
 function hasOwn(obj, key) {
-  return hasOwnProperty.call(obj, key);
+    return hasOwnProperty.call(obj, key);
 }
-var FormItem = function () {
-  function FormItem(object, fieldCheck, option) {
-    _classCallCheck(this, FormItem);
-    _defineProperty(this, "formData", null);
-    _defineProperty(this, "fieldCheck", null);
-    _defineProperty(this, "formState_default", 0);
-    _defineProperty(this, "formState_pass", 1);
-    _defineProperty(this, "formState_notPass", 2);
-    _defineProperty(this, "defaultOption", {
-      isMustMatchRule: false
-    });
-    _defineProperty(this, "option", {});
-    this.fieldCheck = fieldCheck || new _fieldCheck["default"]();
-    this.option = Object.assign(this.defaultOption, option);
-    var errMsg;
-    for (var key in object) {
-      this[key] = object[key];
-      errMsg = FormItem.buildFormItem(object, key, object[key], this.fieldCheck, this.option.isMustMatchRule);
-      if (errMsg) {
-        throw new Error("\u8868\u5355\u9879".concat(key, "\u4E0D\u7B26\u5408\u8981\u6C42,err:").concat(errMsg));
-      }
-    }
-    this.formData = object;
-  }
-  _createClass(FormItem, [{
-    key: "checkForm",
-    value: function checkForm(form, isMustMatch) {
-      var _this = this;
-      var r = true;
-      var n_checkPass = 0,
-        n_checkTotal = 0;
-      var msg = '';
-      var _loop = function _loop() {
-        var formItem = form[fieldKey];
-        var depend = form[formItem.depend];
-        var checkField = fieldKey;
-        var tmpInd = -1;
-        n_checkTotal++;
-        if (formItem.reCheckField) {
-          checkField = formItem.reCheckField;
-        }
-        if (formItem.disables) {
-          if (formItem.disables.indexOf(formItem.val) !== -1) {
-            formItem.msg = '该项内容不合法';
-            r = false;
-          }
-        }
-        if (formItem.options) {
-          tmpInd = formItem.options.findIndex(function (item) {
-            return item.value == formItem.val;
-          });
-          if (tmpInd === -1) {
-            console.log("\u68C0\u6D4B\u679A\u4E3E\u5B57\u6BB5:".concat(checkField, ",\u503C:").concat(formItem.val, "\u4E0D\u5728\u8303\u56F4\u5185"));
-            formItem.msg = '选项不在范围内';
-            formItem.state = 1;
-            r = false;
-          } else {
-            if (formItem.options[tmpInd].disabled) {
-              formItem.msg = '该选项已经被禁用';
-              r = false;
-            }
-          }
-          n_checkPass++;
-          return 1;
-        }
-        if (depend) {
-          if (depend.options) {
-            var optionItem = depend.options.find(function (item) {
-              return item.value == depend.val;
-            });
-            if (!optionItem) {
-              depend.msg = '选项不在范围内';
-              formItem.msg = '该值依赖项输入异常';
-              r = false;
-            }
-            if (optionItem.checkField) {
-              checkField = optionItem.checkField;
-            }
-          } else {
-            r = false;
-          }
-          if (!r) {
-            depend.msg = '该项依赖项输入异常';
-            formItem.msg = '该值依赖项输入异常';
-          }
-        }
-        formItem.msg = _this.fieldCheck.verify(_defineProperty({}, checkField, formItem.val));
-        if (formItem.msg) r = false;
-        if (r) {
-          n_checkPass++;
-          formItem.state = _this.formState_pass;
-        } else {
-          formItem.state = _this.formState_notPass;
+/**
+ * @class FormItem 表单验证类
+ * @description 表单项
+ * @param {object} object 表单项数据
+ * @param {FieldCheck} [fieldCheck] 字段验证对象
+ * @param {object} [option] 配置项
+ */
+class FormVerify {
+    /**
+     *
+     * @param object
+     * @param {FieldCheck} [fieldCheck] 字段验证对象
+     * @param {object} [option] 配置项
+     */
+    constructor(object, fieldCheck, option) {
+        this.formData = null;
+        this.defaultOption = {
+            isMustMatchRule: false,
+        };
+        this.option = {
+            isMustMatchRule: false,
+        };
+        this.formState_default = 0;
+        this.formState_pass = 1;
+        this.formState_notPass = 2;
+        this.fieldCheck = fieldCheck || new fieldCheck_1.default();
+        // 合并配置项
+        this.option = Object.assign(this.defaultOption, option);
+        let errMsg;
+        // 拿出其中的每一项来构建对应的表单项
+        for (let key in object) {
+            // this.formData[key] = object[key];
+            // 验证表单项是否符合要求,不符合要求则抛出错误
+            errMsg = FormVerify.buildFormItem(object, key, object[key], this.fieldCheck, this.option.isMustMatchRule);
+            if (errMsg) {
+                throw new Error(`表单项${key}不符合要求,err:${errMsg}`);
+            }
         }
-      };
-      for (var fieldKey in form) {
-        if (_loop()) continue;
-      }
-      msg = "\u68C0\u67E5\u8868\u5355\u9879\u901A\u8FC7\u7387:".concat(n_checkPass, "/").concat(n_checkTotal);
-      console.log(msg);
-      return r;
+        this.formData = object;
     }
-  }], [{
-    key: "isObject",
-    value: function isObject(obj) {
-      return obj !== null && _typeof(obj) === 'object';
+    static isObject(obj) {
+        return obj !== null && typeof obj === 'object';
     }
-  }, {
-    key: "buildFormItem",
-    value: function buildFormItem(object, field, formItemData, fieldCheck, isMustMatchRule) {
-      if (!FormItem.isObject(formItemData)) {
-        return "form item ".concat(field, " must be object");
-      }
-      var isNeedMatchRule = true;
-      var checkFieldStr = field;
-      var disables = formItemData.disables;
-      formItemData.val = formItemData.val || formItemData.init || '';
-      formItemData.msg = formItemData.msg || '';
-      formItemData.state = formItemData.state || FormData.formState_default;
-      formItemData.label = formItemData.label || '';
-      if (formItemData.options) {
-        if (!formItemData.options.length || !formItemData.options[0]) {
-          return "form item ".concat(field, " options must be array and has item");
-        }
-        if (!formItemData.init) {
-          formItemData.init = formItemData.options[0].key;
+    /**
+     * 检查表单项是否符合要求
+     * @param  object 表单项数据
+     * @param  field 字段名
+     * @param  formItemData 表单项数据
+     * @param  fieldCheck 字段验证对象
+     * @param  isMustMatchRule 表单字段是否必须匹配到验证规则
+     * @returns  errMsg 错误信息
+     */
+    static buildFormItem(object, field, formItemData, fieldCheck, isMustMatchRule) {
+        if (!FormVerify.isObject(formItemData)) {
+            return `form item ${field} must be object`;
         }
-        var hasInit = false;
-        for (var i = 0; i < formItemData.options.length; i++) {
-          var option = formItemData.options[i];
-          if (option.key === formItemData.init) {
-            hasInit = true;
-          }
-          if (disables && disables.indexOf(option.key) !== -1) {
-            option.disabled = true;
-          }
-        }
-        if (!hasInit) {
-          return "form item ".concat(field, " init value must be in options");
+        // 是否需要从验证规则表中查找对应的验证规则
+        let isNeedMatchRule = true;
+        // 用于匹配的字段
+        let checkFieldStr = field;
+        let disables = formItemData.disables;
+        // 设置默认值
+        formItemData.val = formItemData.val || formItemData.init || '';
+        // 设置默认提示词
+        formItemData.msg = formItemData.msg || '';
+        // 设置默认状态
+        formItemData.state = formItemData.state || FormVerify.formState_default;
+        // 设置默认显示文本
+        formItemData.label = formItemData.label || '';
+        // 判断是否有 options 选项有则判断是否有 init 选项,没有则设置第一个为 init
+        if (formItemData.options) {
+            if (!formItemData.options.length || !formItemData.options[0]) {
+                return `form item ${field} options must be array and has item`;
+            }
+            if (!formItemData.init) {
+                formItemData.init = formItemData.options[0].key;
+            }
+            // 判断 val 与 init 是否存在于 options 中
+            let hasInit = false;
+            for (let i = 0; i < formItemData.options.length; i++) {
+                let option = formItemData.options[i];
+                if (option.key === formItemData.init) {
+                    hasInit = true;
+                }
+                // 判断该options是否为禁用项
+                if (disables && disables.indexOf(option.key) !== -1) {
+                    option.disabled = true;
+                }
+            }
+            if (!hasInit) {
+                return `form item ${field} init value must be in options`;
+            }
         }
-      }
-      if (formItemData.depend && formItemData.reCheckField) {
-        return "form item ".concat(field, " has depend and reCheckField, but depend and reCheckField can not exist at the same time");
-      }
-      if (formItemData.depend) {
-        if (!object[formItemData.depend]) {
-          return "form item ".concat(field, " depend field ").concat(formItemData.depend, " but the field not exist");
+        // 判断是否有 depend 依赖字段 有依赖字段则依据依赖字段中的 option 中的 checkField 字段进行判断
+        if (formItemData.depend && formItemData.reCheckField) {
+            return `form item ${field} has depend and reCheckField, but depend and reCheckField can not exist at the same time`;
         }
-        if (!object[formItemData.depend].options) {
-          return "form item ".concat(field, " depend field ").concat(formItemData.depend, " has no options");
+        // 判断是否有 depend 依赖字段 有依赖字段则依据依赖字段中的 option 中的 checkField 字段进行判断
+        if (formItemData.depend) {
+            let hasCheckField = false;
+            let dependStr = formItemData.depend;
+            let dependOptions = [];
+            // 判断object 是否为 formObject 并且不为undefined
+            if (!object) {
+                return `form item ${field} depend field ${dependStr} but the field not exist`;
+            }
+            // 设置 object 不为undefined
+            object = object;
+            // 判断依赖字段是否存在
+            if (!object[dependStr]) {
+                return `form item ${field} depend field ${dependStr} but the field not exist`;
+            }
+            // 判断依赖字段的 option 是否存在
+            if (!object[dependStr].options) {
+                return `form item ${field} depend field ${dependStr} has no options`;
+            }
+            // 判断依赖字段的 options 中是否有 checkField 字段
+            dependOptions = object[dependStr].options;
+            for (let i = 0; i < dependOptions.length; i++) {
+                let option = object ? dependOptions[i] : null;
+                if (option === null || option === void 0 ? void 0 : option.checkField) {
+                    hasCheckField = true;
+                    checkFieldStr = option.checkField;
+                    break;
+                }
+            }
+            if (!hasCheckField) {
+                return `form item ${field} depend field ${dependStr} has no checkField`;
+            }
         }
-        var hasCheckField = false;
-        for (var _i = 0; _i < object[formItemData.depend].options.length; _i++) {
-          var _option = object[formItemData.depend].options[_i];
-          if (_option.checkField) {
-            hasCheckField = true;
-            checkFieldStr = _option.checkField;
-            break;
-          }
+        // 判断是否有 reCheckField 有则使用该字段的值进行规则验证
+        if (formItemData.reCheckField) {
+            checkFieldStr = formItemData.reCheckField;
         }
-        if (!hasCheckField) {
-          return "form item ".concat(field, " depend field ").concat(formItemData.depend, " has no checkField");
+        // 判断是否有 rules 规则
+        if (isMustMatchRule) {
+            if (fieldCheck.getRuleItem(checkFieldStr)) {
+                return `form item ${field} has no rules`;
+            }
         }
-      }
-      if (formItemData.reCheckField) {
-        checkFieldStr = formItemData.reCheckField;
-      }
-      if (isMustMatchRule) {
-        if (fieldCheck.getRuleItem(checkFieldStr)) {
-          return "form item ".concat(field, " has no rules");
+        return '';
+    }
+    /**
+     * 初始化表单项数据
+     * @param { formObject } formObject 表单对象
+     */
+    static initFormItemData(formObject) {
+        let keys = Object.keys(formObject);
+        for (let i = 0; i < keys.length; i++) {
+            let key = keys[i];
+            formObject[key].val = formObject[key].init;
+            formObject[key].msg = '';
+            formObject[key].state = FormVerify.formState_default;
+            formObject[key].showText = '';
         }
-      }
-      return '';
     }
-  }, {
-    key: "initFormItemData",
-    value: function initFormItemData(formObject) {
-      var keys = Object.keys(formObject);
-      for (var i = 0; i < keys.length; i++) {
-        var key = keys[i];
-        formObject[key].val = formObject[key].init;
-        formObject[key].msg = '';
-        formObject[key].state = FormData.formState_default;
-        formObject[key].showText = '';
-      }
+    /**
+     * 检查表单项是否符合要求
+     * @param form 表单对象
+     * @param isMustMatch 是否必须全部匹配到验证规则
+     * @returns {boolean}
+     */
+    checkForm(form, isMustMatch) {
+        let r = true;
+        let n_checkPass = 0, n_checkTotal = 0;
+        let msg = '';
+        for (const fieldKey in form) {
+            let formItem = form[fieldKey];
+            if (!formItem) {
+                continue;
+            }
+            let depend = form[formItem.depend || ''];
+            let checkField = fieldKey;
+            let tmpInd = -1;
+            n_checkTotal++;
+            if (formItem.reCheckField) {
+                checkField = formItem.reCheckField;
+            }
+            // 禁用值判断 array
+            if (formItem.disables) {
+                if (formItem.disables.indexOf(formItem.val || '') !== -1) {
+                    formItem.msg = '该项内容不合法';
+                    r = false;
+                }
+            }
+            // 枚举值判断
+            if (formItem.options) {
+                // 有枚举字段,只判断是否在枚举中
+                // console.log(`检测枚举字段:${checkField},值:${formItem.val}`);
+                tmpInd = formItem.options.findIndex(item => item.value == formItem.val);
+                if (tmpInd === -1) {
+                    console.log(`检测枚举字段:${checkField},值:${formItem.val}不在范围内`);
+                    formItem.msg = '选项不在范围内';
+                    formItem.state = 1;
+                    r = false;
+                }
+                else {
+                    // 判断值是否为禁用项
+                    if (formItem.options[tmpInd].disabled) {
+                        formItem.msg = '该选项已经被禁用';
+                        r = false;
+                    }
+                }
+                // 枚举值判断完毕,继续下一个字段
+                n_checkPass++;
+                continue;
+            }
+            // 依赖字段判断
+            if (depend) {
+                depend = depend;
+                if (depend.options) {
+                    // 依赖的对象有枚举类型,检查该枚举类型是否有有检测值
+                    let optionItem = depend.options.find(item => item.value == formItem.val);
+                    if (!optionItem) {
+                        depend.msg = '选项不在范围内';
+                        formItem.msg = '该值依赖项输入异常';
+                        r = false;
+                        // continue;
+                    }
+                    optionItem = optionItem;
+                    if (optionItem.checkField) {
+                        // console.log(`采用依赖项的检测字段${optionItem.checkField}`)
+                        checkField = optionItem.checkField;
+                    }
+                }
+                else {
+                    r = false;
+                }
+                if (!r) {
+                    depend.msg = '该项依赖项输入异常';
+                    formItem.msg = '该值依赖项输入异常';
+                }
+            }
+            // 使用验证规则进行
+            formItem.msg = this.fieldCheck.verify({
+                [checkField]: formItem.val,
+            });
+            if (formItem.msg)
+                r = false;
+            if (r) {
+                n_checkPass++;
+                formItem.state = this.formState_pass;
+            }
+            else {
+                formItem.state = this.formState_notPass;
+            }
+        }
+        msg = `检查表单项通过率:${n_checkPass}/${n_checkTotal}`;
+        console.log(msg);
+        return r;
     }
-  }]);
-  return FormItem;
-}();
-var _default = exports["default"] = FormItem;
+}
+exports.default = FormVerify;

lib/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @module kind-form-verify
+ */
+import Form from "./formData";
+import F from "./fieldCheck";
+export declare const FormItem: typeof Form;
+export declare const FieldCheck: typeof F;
+/**
+ * @example
+ * import {FormItem,FieldCheck} from "kind-form-verify"
+ */
+//# sourceMappingURL=index.d.ts.map

lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,IAAI,MAAM,YAAY,CAAC;AAG9B,OAAO,CAAC,MAAM,cAAc,CAAC;AAC7B,eAAO,MAAM,QAAQ,aAAO,CAAC;AAC7B,eAAO,MAAM,UAAU,UAAI,CAAC;AAE5B;;;GAGG"}

lib/index.js

@@ -1,11 +1,18 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.FormItem = exports.FieldCheck = void 0;
-var _formData = _interopRequireDefault(require("./formData"));
-var _fieldCheck = _interopRequireDefault(require("./fieldCheck"));
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
-var FormItem = exports.FormItem = _formData["default"];
-var FieldCheck = exports.FieldCheck = _fieldCheck["default"];
+/**
+ * @module kind-form-verify
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FieldCheck = exports.FormItem = void 0;
+const formData_1 = __importDefault(require("./formData"));
+const fieldCheck_1 = __importDefault(require("./fieldCheck"));
+exports.FormItem = formData_1.default;
+exports.FieldCheck = fieldCheck_1.default;
+// 示例
+/**
+ * @example
+ * import {FormItem,FieldCheck} from "kind-form-verify"
+ */

lib/tools/tool.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=tool.d.ts.map

lib/tools/tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/tools/tool.ts"],"names":[],"mappings":""}

lib/tools/tool.js

@@ -0,0 +1 @@
+"use strict";

lib/types.d.ts

@@ -0,0 +1,64 @@
+export type errMessage = string | undefined;
+export type checkFields = Array<string | RegExp>;
+export interface checkRule {
+    type?: string;
+    min?: number;
+    max?: number;
+    length?: number;
+    regex?: RegExp;
+    message?: errMessage;
+    require?: boolean;
+    minLength?: number;
+    maxLength?: number;
+    validator?: validatorFunction;
+}
+export interface ruleItem {
+    name: string;
+    checkFields: checkFields;
+    rules: Array<validatorFunction | checkRule>;
+}
+export interface validatorFunction {
+    (value: any): string | null;
+}
+export declare enum checkCode {
+    code_pass = 1,
+    code_notPass = 2,
+    code_notMatch = 3
+}
+export interface formOption {
+    key: string;
+    value: string;
+    disabled?: boolean;
+    checkField?: string;
+}
+export interface FormVerifyOption {
+    isMustMatchRule: boolean;
+}
+export interface formItemData {
+    val?: string;
+    msg?: string;
+    state?: number;
+    showText?: string;
+    label?: string;
+    init?: string;
+    options?: formOption[];
+    depend?: string;
+    reCheckField?: string;
+    disables?: string[];
+    [key: string]: any;
+}
+/**
+ * 表单数据对象
+ * object 表单数据对象
+ */
+export interface formObject {
+    [key: string]: formItemData;
+}
+export interface formOption {
+    isMustMatchRule?: boolean;
+    [key: string]: any;
+}
+export interface verifyForm {
+    [key: string]: any;
+}
+//# sourceMappingURL=types.d.ts.map

lib/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,UAAU,GAAG,MAAM,GAAG,SAAS,CAAC;AAG5C,MAAM,MAAM,WAAW,GAAG,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,CAAC;AACjD,MAAM,WAAW,SAAS;IACtB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,UAAU,CAAC;IACrB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,iBAAiB,CAAC;CACjC;AAID,MAAM,WAAW,QAAQ;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,WAAW,CAAC;IACzB,KAAK,EAAE,KAAK,CAAC,iBAAiB,GAAG,SAAS,CAAC,CAAC;CAC/C;AAED,MAAM,WAAW,iBAAiB;IAC9B,CAAC,KAAK,EAAE,GAAG,GAAG,MAAM,GAAG,IAAI,CAAA;CAC9B;AAKD,oBAAY,SAAS;IACjB,SAAS,IAAI;IACb,YAAY,IAAI;IAChB,aAAa,IAAI;CACpB;AAED,MAAM,WAAW,UAAU;IACvB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,gBAAgB;IAC7B,eAAe,EAAE,OAAO,CAAC;CAC5B;AAED,MAAM,WAAW,YAAY;IACzB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,UAAU,EAAE,CAAC;IACvB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IAEpB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACtB;AAED;;;GAGG;AACH,MAAM,WAAW,UAAU;IACvB,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY,CAAC;CAC/B;AAED,MAAM,WAAW,UAAU;IACvB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACtB;AAGD,MAAM,WAAW,UAAU;IACvB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACtB"}

lib/types.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkCode = void 0;
+// type checkCode = number;
+var checkCode;
+(function (checkCode) {
+    checkCode[checkCode["code_pass"] = 1] = "code_pass";
+    checkCode[checkCode["code_notPass"] = 2] = "code_notPass";
+    checkCode[checkCode["code_notMatch"] = 3] = "code_notMatch";
+})(checkCode || (exports.checkCode = checkCode = {}));

package-lock.json

@@ -11,7 +11,8 @@
       "devDependencies": {
         "@babel/cli": "^7.23.0",
         "@babel/core": "^7.23.2",
-        "@babel/preset-env": "^7.23.2"
+        "@babel/preset-env": "^7.23.2",
+        "typescript": "^5.2.2"
       }
     },
     "node_modules/@ampproject/remapping": {
@@ -2639,6 +2640,19 @@
         "node": ">=8.0"
       }
     },
+    "node_modules/typescript": {
+      "version": "5.2.2",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.2.2.tgz",
+      "integrity": "sha512-mI4WrpHsbCIcwT9cF4FZvr80QUeKvsUsUvKDoR+X/7XHQH98xYD8YHZg7ANtz2GtZt/CBq2QJ0thkGJMHfqc1w==",
+      "dev": true,
+      "bin": {
+        "tsc": "bin/tsc",
+        "tsserver": "bin/tsserver"
+      },
+      "engines": {
+        "node": ">=14.17"
+      }
+    },
     "node_modules/unicode-canonical-property-names-ecmascript": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/unicode-canonical-property-names-ecmascript/-/unicode-canonical-property-names-ecmascript-2.0.0.tgz",
@@ -4591,6 +4605,12 @@
         "is-number": "^7.0.0"
       }
     },
+    "typescript": {
+      "version": "5.2.2",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.2.2.tgz",
+      "integrity": "sha512-mI4WrpHsbCIcwT9cF4FZvr80QUeKvsUsUvKDoR+X/7XHQH98xYD8YHZg7ANtz2GtZt/CBq2QJ0thkGJMHfqc1w==",
+      "dev": true
+    },
     "unicode-canonical-property-names-ecmascript": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/unicode-canonical-property-names-ecmascript/-/unicode-canonical-property-names-ecmascript-2.0.0.tgz",

package.json

@@ -10,14 +10,16 @@
   ],
   "scripts": {
     "docs": "jsdoc2md src/*.js > api.md",
-    "patch": "npm version patch",
+    "patch": "npm run build && npm version patch",
     "compile": "npx babel -d lib/ src/",
+    "build": "tsc --build --clean && tsc",
     "prepublishOnly": "npm run compile"
   },
   "license": "MIT",
   "devDependencies": {
     "@babel/cli": "^7.23.0",
     "@babel/core": "^7.23.2",
-    "@babel/preset-env": "^7.23.2"
+    "@babel/preset-env": "^7.23.2",
+    "typescript": "^5.2.2"
   }
 }

src/fieldCheck.js → src/fieldCheck.ts

@@ -5,46 +5,22 @@
  * date:2023/10/08
  */
 
-/**
- * @typedef {string} errMessage 错误信息
- */
 
 
-/**
- * @typedef { Array<string | RegExp> } checkFields 验证字段匹配项
- */
-/**
- * @typedef {Object} checkRule 规则对象
- * @property {string} [type] 类型
- * @property {number} [min] 最小值
- * @property {number} [max] 最大值
- * @property {number} [length] 长度
- * @property {RegExp} [regex] 正则表达式
- * @property {errMessage} [message] 错误信息
- * @property {boolean} [require] 是否必须
- * @property {number} [minLength] 最小长度
- * @property {number} [maxLength] 最大长度
- * @property {validatorFunction} [validator] 自定义验证函数
- */
 
-/**
- * @typedef {function} validatorFunction 自定义验证函数
- * @param {any} value 需要验证的值
- * @returns {string} 返回错误信息或者 null
- */
 
-/**
- * @typedef {Object} ruleItem 验证规则对象
- * @property {Array<string>} checkFields 需要验证的字段
- * @property {Array<validatorFunction | checkRule>} rules 验证规则
- */
 
-/**
- * @typedef {number} checkCode 验证码
- * @property {1} code_pass 验证通过
- * @property {2} code_notPass 验证不通过
- * @property {3} code_notMatch 未匹配到验证规则
- */
+import {
+    checkFields,
+    checkCode,
+    checkRule,
+    ruleItem,
+    validatorFunction,
+    errMessage,
+    formObject,
+    verifyForm
+} from "./types";
+
 
 
 /**
@@ -82,24 +58,25 @@
  *    // 年龄必须为18-100岁
  */
 class FieldCheck{
+
     // 通过
-    #code_pass = 1;
+    code_pass = checkCode.code_pass;
     // 未通过
-    #code_notPass = 2;
+    code_notPass:number = checkCode.code_notPass;
 
     // 无法匹配到验证规则
-    #code_notMatch = 3;
+    code_notMatch = checkCode.code_notMatch;
 
     /**
      * @type {Array< ruleItem >}
      */
-    #ruleItems = [];
+    #ruleItems: ruleItem[] = [];
 
     /**
      *
      * @param {Array< ruleItem >} [ruleItems] 验证规则数组
      */
-    constructor(ruleItems) {
+    constructor(ruleItems?:Array< ruleItem >) {
         this.#ruleItems = [];
         if(ruleItems && Array.isArray(ruleItems)){
             // 使用 addRuleItem 添加规则
@@ -115,19 +92,23 @@ class FieldCheck{
      * @returns {boolean}
      * @private
      */
-    _isDef (v) {
+    _isDef (v:any) {
         return v !== undefined && v !== null
     }
     _toString = Object.prototype.toString;
     /**
      * 判断是否为空
-     * @param v
-     * @returns {boolean}
+     * @param v 要检验的值
      */
-    _isEmpty(v){
+    _isEmpty(v:any){
         return v === undefined || v === '';
     }
-    _isRegExp (v) {
+
+    /**
+     * 判断是否为正则
+     * @param v 要检验的值
+     */
+    _isRegExp (v:any) {
         return this._toString.call(v) === '[object RegExp]'
     }
 
@@ -138,7 +119,10 @@ class FieldCheck{
      * @param {Array<validatorFunction | checkRule>} ruleArr 验证规则
      * @returns {ruleItem} 验证规则对象
      */
-    buildRuleItem( checkFields , ruleArr) {
+    buildRuleItem(name: string,
+                  checkFields: checkFields ,
+                  ruleArr:Array<validatorFunction | checkRule> ) : ruleItem
+    {
         //  检测checkFields是否为数组
         //  检测ruleArr是否为数组
         if(!Array.isArray(checkFields) || !Array.isArray(ruleArr)){
@@ -156,10 +140,8 @@ class FieldCheck{
                 throw new Error('ruleArr item is not function or object');
             }
         }
-        /**
-         * @type {ruleItem}
-         */
-        let ruleItem = {
+        let ruleItem:ruleItem = {
+            name: name || "",
             checkFields: checkFields,
             rules: ruleArr
         }
@@ -169,13 +151,17 @@ class FieldCheck{
 
     /**
      * 添加一条验证规则
-     * @param { string } ruleName 验证规则名,用于区分
-     * @param { Array<string | RegExp> } checkFields 用于匹配字段的字符或者正则数组
-     * @param { Array<validatorFunction | checkRule> } ruleArr 验证规则
-     * @returns { FieldCheck } 返回当前对象
+     * @param ruleName 验证规则名,用于区分
+     * @param checkFields 用于匹配字段的字符或者正则数组
+     * @param ruleArr 验证规则
+     * @returns  返回当前对象
      */
-    addRuleItem( ruleName, checkFields , ruleArr) {
-        let ruleItem = this.buildRuleItem(checkFields,ruleArr);
+    addRuleItem(
+        ruleName: string,
+        checkFields: checkFields,
+        ruleArr: Array<validatorFunction | checkRule>)
+    {
+        let ruleItem = this.buildRuleItem(ruleName, checkFields, ruleArr);
         this.#ruleItems.push(ruleItem);
         return this;
     }
@@ -184,17 +170,19 @@ class FieldCheck{
 
     /**
      * 获取验证规则
-     * @param { string } field 字段名
-     * @returns { ruleItem } 验证规则
+     * @param field 字段名
+     * @returns 验证规则
      */
-    getRuleItem(field){
+    getRuleItem(field:string):ruleItem | undefined{
         return this.#ruleItems.find(item => {
             // 判断是否为正则
             for (const _matchKey of item.checkFields) {
                 // 判断是否为正则
                 if (this._isRegExp(_matchKey)) {
+                    // 确定为正则
+                    let reg :RegExp = _matchKey as RegExp;
                     // console.log(`使用正则进行匹配,${_matchKey.test(key)}`);
-                    if (_matchKey.test(field)) {
+                    if (reg.test(field)) {
                         // console.log(`通过正则匹配规则成功,${_matchKey.test(key)}`);
                         return true;
                     }
@@ -215,16 +203,19 @@ class FieldCheck{
      * 检查字段是否符合规则
      * @param field 字段名
      * @param value 字段值
-     * @returns {Array<checkCode | errMessage>} 错误码或错误信息
+     * @returns {Array<checkCode | ?errMessage>} 错误码或错误信息
      */
-    checkField(field, value){
+    checkField(field: string, value: any):
+        [ checkCode, errMessage ] | [ checkCode ]
+    {
         let ruleItem = this.getRuleItem(field);
         if(!ruleItem || !ruleItem.rules){
-            return [this.#code_notMatch];
+            return [this.code_notMatch];
         }
+
         // 判断值是否为undefined
         if(value === undefined){
-            return [this.#code_notPass, '字段值为undefined'];
+            return [this.code_notPass, '字段值为undefined'];
         }
         // 开始匹配规则
         for(let _rule of ruleItem.rules ){
@@ -233,69 +224,69 @@ class FieldCheck{
                 let  _msg = _rule(value);
                 // console.log(_msg)
                 if(_msg){
-                    return [this.#code_notPass,_msg]
+                    return [this.code_notPass,_msg]
                 }
             }
-
+            let rule = _rule as checkRule;
             // 判断类型
-            if(_rule.type && typeof value !== _rule.type){
-                return [this.#code_notPass, _rule.message]
+            if(rule.type && typeof value !== rule.type){
+                return [this.code_notPass, rule.message]
             }
 
             // 判断是否为必填项
-            if(_rule.require && this._isEmpty(value)){
-                return [this.#code_notPass, _rule.message]
+            if(rule.require && this._isEmpty(value)){
+                return [this.code_notPass, rule.message]
             }
 
             // 判断最小值
-            if(_rule.min && value < _rule.min){
-                return [this.#code_notPass, _rule.message]
+            if(rule.min && value < rule.min){
+                return [this.code_notPass, rule.message]
             }
 
             // 判断最大值
-            if(_rule.max && value > _rule.max){
-                return [this.#code_notPass, _rule.message]
+            if(rule.max && value > rule.max){
+                return [this.code_notPass, rule.message]
             }
 
             // 判断值是否达到指定长度
-            if(_rule.length && value.length && value.length !== _rule.length){
-                return [this.#code_notPass, _rule.message]
+            if(rule.length && value.length && value.length !== rule.length){
+                return [this.code_notPass, rule.message]
             }
 
             // 判断最小长度
-            if(_rule.minLength && value.length && value.length < _rule.minLength){
-                return [this.#code_notPass, _rule.message]
+            if(rule.minLength && value.length && value.length < rule.minLength){
+                return [this.code_notPass, rule.message]
             }
 
             // 判断最大长度
-            if(_rule.maxLength && value.length && value.length > _rule.maxLength){
-                return [this.#code_notPass, _rule.message]
+            if(rule.maxLength && value.length && value.length > rule.maxLength){
+                return [this.code_notPass, rule.message]
             }
 
             // 判断是否符合正则
-            if(_rule.regex && !_rule.regex.test(value)){
-                return [this.#code_notPass, _rule.message]
+            if(rule.regex && !rule.regex.test(value)){
+                return [this.code_notPass, rule.message]
             }
 
         }
 
-        return [this.#code_pass]
+        return [this.code_pass]
 
     }
 
     /**
      * 检查表单是否符合规则
-     * @param { Object } formObject 需要检验的表单项 字段:值
+     * @param formObject 需要检验的表单项 字段:值
      * @param [isMustMatch] 是否强制要求匹配规则
-     * @returns { errMessage } 错误码或错误信息
+     * @returns errMessage 错误码或错误信息
      */
-    verify(formObject, isMustMatch){
+    verify(formObject: verifyForm, isMustMatch:boolean = false){
         for (const _oKey in formObject) {
             let value = formObject[_oKey];
             let r = this.checkField(_oKey,value);
-            if(r[0] === this.#code_notPass){
+            if(r[0] === this.code_notPass){
                 return r[1]
-            }else if(isMustMatch && r[0] === this.#code_notMatch){
+            }else if(isMustMatch && r[0] === this.code_notMatch){
                 return `字段没有对应匹配项`
             }
         }

src/formData.js → src/formData.ts

@@ -1,25 +1,11 @@
 "use strict";
 import FieldCheck from "./fieldCheck";
-
+import {formItemData, formObject, formOption, FormVerifyOption} from "./types";
 let hasOwnProperty = Object.prototype.hasOwnProperty;
-function hasOwn (obj, key) {
+function hasOwn (obj:object, key:string) {
     return hasOwnProperty.call(obj, key)
 }
 
-/**
- * @typedef {object} formItemData 表单项数据
- * @property {string} [val] 表单项值
- * @property {string} [msg] 表单项错误信息
- * @property {number} [state] 表单项状态 0 通过 1 通过 2 不通过
- * @property {string} [showText] 表单项显示文本,用于在某些
- * @property {string} [label] 表单项显示文本
- * @property {string} [init] 表单项初始值
- * @property {Array} [options] 表单项枚举值
- * @property {string} [depend] 依赖字段, 该项存在将使用依赖字段的option中的checkField字段进行匹配验证规则
- * @property {string} [reCheckField] 该表单项用于匹配规则的字段
- * @property {Array} [disables] 禁用项
- */
-
 
 /**
  * @class FormItem 表单验证类
@@ -28,58 +14,68 @@ function hasOwn (obj, key) {
  * @param {FieldCheck} [fieldCheck] 字段验证对象
  * @param {object} [option] 配置项
  */
-class FormItem {
-    formData = null;
-    /**
-     * @type {FieldCheck} 字段验证对象
-     */
-    fieldCheck = null;
-    // 表单状态 默认 0 通过 1 不通过 2
-    formState_default = 0;
-    formState_pass = 1;
-    formState_notPass = 2;
+class FormVerify {
+    formData:formObject | null = null;
+
+    fieldCheck:FieldCheck;
 
-    defaultOption = {
-        isMustMatchRule: false,// 表单字段是否必须匹配到验证规则
+
+    defaultOption: FormVerifyOption = {
+        isMustMatchRule: false,
     }
-    option = {};
+    option: FormVerifyOption = {
+        isMustMatchRule: false,
+    };
+    // 表单状态 默认 0 通过 1 不通过 2
+    public static formState_default: number;
+    public static formState_pass: number;
+    public static formState_notPass: number;
+
+    formState_default: number = 0;
+    formState_pass: number = 1;
+    formState_notPass: number = 2;
     /**
      *
      * @param object
      * @param {FieldCheck} [fieldCheck] 字段验证对象
      * @param {object} [option] 配置项
      */
-    constructor(object, fieldCheck, option) {
+    constructor(object:formObject, fieldCheck?:FieldCheck, option?:FormVerifyOption) {
         this.fieldCheck = fieldCheck || new FieldCheck();
         // 合并配置项
         this.option = Object.assign(this.defaultOption, option);
+
         let errMsg;
         // 拿出其中的每一项来构建对应的表单项
         for (let key in object) {
-            this[key] = object[key];
+            // this.formData[key] = object[key];
             // 验证表单项是否符合要求,不符合要求则抛出错误
-            errMsg = FormItem.buildFormItem(object, key, object[key], this.fieldCheck, this.option.isMustMatchRule);
+            errMsg = FormVerify.buildFormItem(object, key, object[key], this.fieldCheck, this.option.isMustMatchRule);
             if (errMsg) {
                 throw new Error(`表单项${key}不符合要求,err:${errMsg}`);
             }
         }
         this.formData = object;
     }
-    static isObject (obj) {
+    static isObject (obj:any) {
         return obj !== null && typeof obj === 'object'
     }
 
     /**
      * 检查表单项是否符合要求
-     * @param { object } object 表单项数据
-     * @param { string } field 字段名
-     * @param { formItemData } formItemData 表单项数据
-     * @param { FieldCheck } fieldCheck 字段验证对象
-     * @param { boolean } isMustMatchRule 表单字段是否必须匹配到验证规则
-     * @returns { string } errMsg 错误信息
+     * @param  object 表单项数据
+     * @param  field 字段名
+     * @param  formItemData 表单项数据
+     * @param  fieldCheck 字段验证对象
+     * @param  isMustMatchRule 表单字段是否必须匹配到验证规则
+     * @returns  errMsg 错误信息
      */
-    static buildFormItem(object, field, formItemData, fieldCheck, isMustMatchRule) {
-        if ( !FormItem.isObject(formItemData) ){
+    static buildFormItem(object: formObject,
+                         field: string,
+                         formItemData: formItemData,
+                         fieldCheck: FieldCheck,
+                         isMustMatchRule: boolean) {
+        if ( !FormVerify.isObject(formItemData) ){
             return `form item ${field} must be object`;
         }
         // 是否需要从验证规则表中查找对应的验证规则
@@ -95,7 +91,7 @@ class FormItem {
         // 设置默认提示词
         formItemData.msg = formItemData.msg || '';
         // 设置默认状态
-        formItemData.state = formItemData.state || FormData.formState_default;
+        formItemData.state = formItemData.state || FormVerify.formState_default;
         // 设置默认显示文本
         formItemData.label = formItemData.label || '';
 
@@ -134,26 +130,37 @@ class FormItem {
 
         // 判断是否有 depend 依赖字段 有依赖字段则依据依赖字段中的 option 中的 checkField 字段进行判断
         if ( formItemData.depend ){
+            let hasCheckField = false;
+            let dependStr: string = formItemData.depend;
+            let dependOptions:formOption[] = [];
+            // 判断object 是否为 formObject 并且不为undefined
+            if ( !object){
+                return `form item ${field} depend field ${dependStr} but the field not exist`;
+            }
+            // 设置 object 不为undefined
+            object = object as formObject;
+
             // 判断依赖字段是否存在
-            if ( !object[formItemData.depend] ){
-                return `form item ${field} depend field ${formItemData.depend} but the field not exist`;
+            if ( !object[dependStr] ){
+                return `form item ${field} depend field ${dependStr} but the field not exist`;
             }
             // 判断依赖字段的 option 是否存在
-            if ( !object[formItemData.depend].options ){
-                return `form item ${field} depend field ${formItemData.depend} has no options`;
+            if ( !object[dependStr].options ){
+                return `form item ${field} depend field ${dependStr} has no options`;
             }
             // 判断依赖字段的 options 中是否有 checkField 字段
-            let hasCheckField = false;
-            for (let i = 0; i < object[formItemData.depend].options.length; i++) {
-                let option = object[formItemData.depend].options[i];
-                if ( option.checkField ){
+            dependOptions = object[dependStr].options as formOption[];
+
+            for (let i = 0; i < dependOptions.length; i++) {
+                let option = object?dependOptions[i]:null;
+                if ( option?.checkField ){
                     hasCheckField = true;
                     checkFieldStr = option.checkField;
                     break;
                 }
             }
             if ( !hasCheckField ){
-                return `form item ${field} depend field ${formItemData.depend} has no checkField`;
+                return `form item ${field} depend field ${dependStr} has no checkField`;
             }
 
         }
@@ -179,13 +186,13 @@ class FormItem {
      * 初始化表单项数据
      * @param { formObject } formObject 表单对象
      */
-    static initFormItemData ( formObject ) {
+    static initFormItemData ( formObject: formObject ) {
         let keys = Object.keys(formObject);
         for(let i = 0; i < keys.length; i++){
             let key = keys[i];
             formObject[key].val = formObject[key].init;
             formObject[key].msg = '';
-            formObject[key].state = FormData.formState_default;
+            formObject[key].state = FormVerify.formState_default;
             formObject[key].showText = '';
         }
     }
@@ -193,18 +200,21 @@ class FormItem {
 
     /**
      * 检查表单项是否符合要求
-     * @param {object} form 表单对象
+     * @param form 表单对象
      * @param isMustMatch 是否必须全部匹配到验证规则
      * @returns {boolean}
      */
-    checkForm (form, isMustMatch) {
+    checkForm (form: formObject, isMustMatch: boolean) {
         let r = true;
         let n_checkPass = 0,
             n_checkTotal = 0;
         let msg = '';
         for (const fieldKey in form) {
             let formItem = form[fieldKey];
-            let depend = form[formItem.depend];
+            if(!formItem){
+                continue;
+            }
+            let depend: formItemData | undefined = form[formItem.depend || ''];
             let checkField = fieldKey;
             let tmpInd = -1;
 
@@ -216,7 +226,7 @@ class FormItem {
 
             // 禁用值判断 array
             if(formItem.disables){
-                if(formItem.disables.indexOf(formItem.val) !== -1){
+                if(formItem.disables.indexOf(formItem.val || '') !== -1){
                     formItem.msg = '该项内容不合法';
                     r = false;
                 }
@@ -246,15 +256,17 @@ class FormItem {
 
             // 依赖字段判断
             if(depend){
+                depend = depend as formItemData;
                 if(depend.options){
                     // 依赖的对象有枚举类型,检查该枚举类型是否有有检测值
-                    let optionItem = depend.options.find(item=>item.value == depend.val);
+                    let optionItem = depend.options.find(item=>item.value == formItem.val);
                     if(!optionItem){
                         depend.msg = '选项不在范围内';
                         formItem.msg = '该值依赖项输入异常';
                         r = false;
                         // continue;
                     }
+                    optionItem = optionItem as formOption;
                     if(optionItem.checkField){
                         // console.log(`采用依赖项的检测字段${optionItem.checkField}`)
                         checkField = optionItem.checkField;
@@ -292,4 +304,4 @@ class FormItem {
 
 }
 
-export default FormItem;
+export default FormVerify;

src/types.ts

@@ -0,0 +1,81 @@
+export type errMessage = string | undefined;
+
+
+export type checkFields = Array<string | RegExp>;
+export interface checkRule {
+    type?: string;
+    min?: number;
+    max?: number;
+    length?: number;
+    regex?: RegExp;
+    message?: errMessage;
+    require?: boolean;
+    minLength?: number;
+    maxLength?: number;
+    validator?: validatorFunction;
+}
+
+
+
+export interface ruleItem {
+    name: string,
+    checkFields: checkFields;
+    rules: Array<validatorFunction | checkRule>;
+}
+
+export interface validatorFunction {
+    (value: any): string | null
+}
+
+
+// type checkCode = number;
+
+export enum checkCode {
+    code_pass = 1,
+    code_notPass = 2,
+    code_notMatch = 3
+}
+
+export interface formOption {
+    key: string;
+    value: string;
+    disabled?: boolean;
+    checkField?: string;
+}
+
+export interface FormVerifyOption{
+    isMustMatchRule: boolean;
+}
+
+export interface formItemData {
+    val?: string;
+    msg?: string;
+    state?: number;
+    showText?: string;
+    label?: string;
+    init?: string;
+    options?: formOption[];
+    depend?: string;
+    reCheckField?: string;
+    disables?: string[];
+    // 允许有其他字段
+    [key: string]: any;
+}
+
+/**
+ * 表单数据对象
+ * object 表单数据对象
+ */
+export interface formObject {
+    [key: string]: formItemData;
+}
+
+export interface formOption {
+    isMustMatchRule?: boolean;
+    [key: string]: any;
+}
+
+
+export interface verifyForm{
+    [key: string]: any;
+}

tsconfig.json

@@ -0,0 +1,108 @@
+{
+  "compilerOptions": {
+    /* Visit https://aka.ms/tsconfig to read more about this file */
+
+    /* Projects */
+    // "incremental": true,                              /* Save .tsbuildinfo files to allow for incremental compilation of projects. */
+    // "composite": true,                                /* Enable constraints that allow a TypeScript project to be used with project references. */
+    // "tsBuildInfoFile": "./.tsbuildinfo",              /* Specify the path to .tsbuildinfo incremental compilation file. */
+    // "disableSourceOfProjectReferenceRedirect": true,  /* Disable preferring source files instead of declaration files when referencing composite projects. */
+    // "disableSolutionSearching": true,                 /* Opt a project out of multi-project reference checking when editing. */
+    // "disableReferencedProjectLoad": true,             /* Reduce the number of projects loaded automatically by TypeScript. */
+    /* Language and Environment */
+    "target": "es2015",                                  /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
+    // "lib": [],                                        /* Specify a set of bundled library declaration files that describe the target runtime environment. */
+    // "jsx": "preserve",                                /* Specify what JSX code is generated. */
+    // "experimentalDecorators": true,                   /* Enable experimental support for legacy experimental decorators. */
+    // "emitDecoratorMetadata": true,                    /* Emit design-type metadata for decorated declarations in source files. */
+    // "jsxFactory": "",                                 /* Specify the JSX factory function used when targeting React JSX emit, e.g. 'React.createElement' or 'h'. */
+    // "jsxFragmentFactory": "",                         /* Specify the JSX Fragment reference used for fragments when targeting React JSX emit e.g. 'React.Fragment' or 'Fragment'. */
+    // "jsxImportSource": "",                            /* Specify module specifier used to import the JSX factory functions when using 'jsx: react-jsx*'. */
+    // "reactNamespace": "",                             /* Specify the object invoked for 'createElement'. This only applies when targeting 'react' JSX emit. */
+    // "noLib": true,                                    /* Disable including any library files, including the default lib.d.ts. */
+    // "useDefineForClassFields": true,                  /* Emit ECMAScript-standard-compliant class fields. */
+    // "moduleDetection": "auto",                        /* Control what method is used to detect module-format JS files. */
+
+    /* Modules */
+    "module": "commonjs",                                /* Specify what module code is generated. */
+     "rootDir": "./src",                                  /* Specify the root folder within your source files. */
+    // "moduleResolution": "node10",                     /* Specify how TypeScript looks up a file from a given module specifier. */
+    // "baseUrl": "./",                                  /* Specify the base directory to resolve non-relative module names. */
+    // "paths": {},                                      /* Specify a set of entries that re-map imports to additional lookup locations. */
+    // "rootDirs": [],                                   /* Allow multiple folders to be treated as one when resolving modules. */
+    // "typeRoots": [],                                  /* Specify multiple folders that act like './node_modules/@types'. */
+    // "types": [],                                      /* Specify type package names to be included without being referenced in a source file. */
+    // "allowUmdGlobalAccess": true,                     /* Allow accessing UMD globals from modules. */
+    // "moduleSuffixes": [],                             /* List of file name suffixes to search when resolving a module. */
+    // "allowImportingTsExtensions": true,               /* Allow imports to include TypeScript file extensions. Requires '--moduleResolution bundler' and either '--noEmit' or '--emitDeclarationOnly' to be set. */
+    // "resolvePackageJsonExports": true,                /* Use the package.json 'exports' field when resolving package imports. */
+    // "resolvePackageJsonImports": true,                /* Use the package.json 'imports' field when resolving imports. */
+    // "customConditions": [],                           /* Conditions to set in addition to the resolver-specific defaults when resolving imports. */
+    // "resolveJsonModule": true,                        /* Enable importing .json files. */
+    // "allowArbitraryExtensions": true,                 /* Enable importing files with any extension, provided a declaration file is present. */
+    // "noResolve": true,                                /* Disallow 'import's, 'require's or '<reference>'s from expanding the number of files TypeScript should add to a project. */
+
+    /* JavaScript Support */
+    // "allowJs": true,                                  /* Allow JavaScript files to be a part of your program. Use the 'checkJS' option to get errors from these files. */
+    // "checkJs": true,                                  /* Enable error reporting in type-checked JavaScript files. */
+    // "maxNodeModuleJsDepth": 1,                        /* Specify the maximum folder depth used for checking JavaScript files from 'node_modules'. Only applicable with 'allowJs'. */
+
+    /* Emit */
+     "declaration": true,                              /* Generate .d.ts files from TypeScript and JavaScript files in your project. */
+     "declarationMap": true,                           /* Create sourcemaps for d.ts files. */
+    // "emitDeclarationOnly": true,                      /* Only output d.ts files and not JavaScript files. */
+    // "sourceMap": true,                                /* Create source map files for emitted JavaScript files. */
+    // "inlineSourceMap": true,                          /* Include sourcemap files inside the emitted JavaScript. */
+    // "outFile": "./",                                  /* Specify a file that bundles all outputs into one JavaScript file. If 'declaration' is true, also designates a file that bundles all .d.ts output. */
+     "outDir": "./lib",                                   /* Specify an output folder for all emitted files. */
+    // "removeComments": true,                           /* Disable emitting comments. */
+    // "noEmit": true,                                   /* Disable emitting files from a compilation. */
+    // "importHelpers": true,                            /* Allow importing helper functions from tslib once per project, instead of including them per-file. */
+    // "importsNotUsedAsValues": "remove",               /* Specify emit/checking behavior for imports that are only used for types. */
+    // "downlevelIteration": true,                       /* Emit more compliant, but verbose and less performant JavaScript for iteration. */
+    // "sourceRoot": "",                                 /* Specify the root path for debuggers to find the reference source code. */
+    // "mapRoot": "",                                    /* Specify the location where debugger should locate map files instead of generated locations. */
+    // "inlineSources": true,                            /* Include source code in the sourcemaps inside the emitted JavaScript. */
+    // "emitBOM": true,                                  /* Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files. */
+    // "newLine": "crlf",                                /* Set the newline character for emitting files. */
+    // "stripInternal": true,                            /* Disable emitting declarations that have '@internal' in their JSDoc comments. */
+    // "noEmitHelpers": true,                            /* Disable generating custom helper functions like '__extends' in compiled output. */
+    // "noEmitOnError": true,                            /* Disable emitting files if any type checking errors are reported. */
+    // "preserveConstEnums": true,                       /* Disable erasing 'const enum' declarations in generated code. */
+    // "declarationDir": "./",                           /* Specify the output directory for generated declaration files. */
+    // "preserveValueImports": true,                     /* Preserve unused imported values in the JavaScript output that would otherwise be removed. */
+
+    /* Interop Constraints */
+    // "isolatedModules": true,                          /* Ensure that each file can be safely transpiled without relying on other imports. */
+    // "verbatimModuleSyntax": true,                     /* Do not transform or elide any imports or exports not marked as type-only, ensuring they are written in the output file's format based on the 'module' setting. */
+    // "allowSyntheticDefaultImports": true,             /* Allow 'import x from y' when a module doesn't have a default export. */
+    "esModuleInterop": true,                             /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */
+    // "preserveSymlinks": true,                         /* Disable resolving symlinks to their realpath. This correlates to the same flag in node. */
+    "forceConsistentCasingInFileNames": true,            /* Ensure that casing is correct in imports. */
+
+    /* Type Checking */
+    "strict": true,                                      /* Enable all strict type-checking options. */
+    // "noImplicitAny": true,                            /* Enable error reporting for expressions and declarations with an implied 'any' type. */
+    // "strictNullChecks": true,                         /* When type checking, take into account 'null' and 'undefined'. */
+    // "strictFunctionTypes": true,                      /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */
+    // "strictBindCallApply": true,                      /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */
+    // "strictPropertyInitialization": true,             /* Check for class properties that are declared but not set in the constructor. */
+    // "noImplicitThis": true,                           /* Enable error reporting when 'this' is given the type 'any'. */
+    // "useUnknownInCatchVariables": true,               /* Default catch clause variables as 'unknown' instead of 'any'. */
+    // "alwaysStrict": true,                             /* Ensure 'use strict' is always emitted. */
+    // "noUnusedLocals": true,                           /* Enable error reporting when local variables aren't read. */
+    // "noUnusedParameters": true,                       /* Raise an error when a function parameter isn't read. */
+    // "exactOptionalPropertyTypes": true,               /* Interpret optional property types as written, rather than adding 'undefined'. */
+    // "noImplicitReturns": true,                        /* Enable error reporting for codepaths that do not explicitly return in a function. */
+    // "noFallthroughCasesInSwitch": true,               /* Enable error reporting for fallthrough cases in switch statements. */
+    // "noUncheckedIndexedAccess": true,                 /* Add 'undefined' to a type when accessed using an index. */
+    // "noImplicitOverride": true,                       /* Ensure overriding members in derived classes are marked with an override modifier. */
+    // "noPropertyAccessFromIndexSignature": true,       /* Enforces using indexed accessors for keys declared using an indexed type. */
+    // "allowUnusedLabels": true,                        /* Disable error reporting for unused labels. */
+    // "allowUnreachableCode": true,                     /* Disable error reporting for unreachable code. */
+
+    /* Completeness */
+    // "skipDefaultLibCheck": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */
+    "skipLibCheck": true                                 /* Skip type checking all .d.ts files. */
+  }
+}