暂存, 新增esm导出

lib/fieldCheck.d.ts

@@ -1,115 +0,0 @@
-/**
- * 表单字段验证库
- * author:kindring
- * date:2023/10/08
- */
-/**
- * 规则匹配结果
- * @property code_pass 验证通过
- * @property code_notPass 验证未通过
- * @property code_notMatch 未匹配到规则
- */
-declare enum checkCode {
-    code_pass = 1,
-    code_notPass = 2,
-    code_notMatch = 3
-}
-/**
- * @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;
-    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 {verifyForm} formObject 需要检验的表单项 字段:值
-     * @param [isMustMatch] 是否强制要求匹配规则
-     * @returns errMessage 错误码或错误信息
-     */
-    verify(formObject: verifyForm, isMustMatch?: boolean): errMessage;
-}
-export default FieldCheck;
-//# sourceMappingURL=fieldCheck.d.ts.map

lib/fieldCheck.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"fieldCheck.d.ts","sourceRoot":"","sources":["../src/fieldCheck.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AAKH;;;;;GAKG;AACH,aAAK,SAAS;IACV,SAAS,IAAI;IACb,YAAY,IAAA;IACZ,aAAa,IAAA;CAChB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,cAAM,UAAU;;IAIZ,SAAS,YAAuB;IAEhC,YAAY,EAAC,MAAM,CAA0B;IAG7C,aAAa,YAA2B;gBAQ5B,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,GAAI,IAAI;IASzD;;;;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,267 +0,0 @@
-"use strict";
-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
- */
-// 在 types 中定义的 enum 在此处使用会导致异常
-/**
- * 规则匹配结果
- * @property code_pass 验证通过
- * @property code_notPass 验证未通过
- * @property code_notMatch 未匹配到规则
- */
-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 || (checkCode = {}));
-/**
- * @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 {
-    constructor(ruleItems) {
-        // 通过
-        this.code_pass = checkCode.code_pass;
-        // 未通过
-        this.code_notPass = checkCode.code_notPass;
-        // 无法匹配到验证规则
-        this.code_notMatch = 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);
-            }
-        }
-    }
-    /**
-     * 判断值是否定义
-     * @param v
-     * @returns {boolean}
-     * @private
-     */
-    _isDef(v) {
-        return v !== undefined && v !== null;
-    }
-    /**
-     * 判断是否为空
-     * @param v 要检验的值
-     */
-    _isEmpty(v) {
-        return v === undefined || v === '';
-    }
-    /**
-     * 判断是否为正则
-     * @param v 要检验的值
-     */
-    _isRegExp(v) {
-        return this._toString.call(v) === '[object 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');
-        }
-        //  检测checkFields中的每一项是否为字符串或者正则
-        for (let field of checkFields) {
-            if (typeof field !== 'string' && !this._isRegExp(field)) {
-                throw new Error('checkFields item is not string or RegExp');
-            }
-        }
-        //  检测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;
-    }
-    /**
-     * 添加一条验证规则
-     * @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;
-    }
-    /**
-     * 获取验证规则
-     * @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;
-                    }
-                }
-            }
-            return false;
-        });
-    }
-    /**
-     * 检查字段是否符合规则
-     * @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];
-            }
-        }
-        return [this.code_pass];
-    }
-    /**
-     * 检查表单是否符合规则
-     * @param {verifyForm} 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 `字段没有对应匹配项`;
-            }
-        }
-    }
-}
-_FieldCheck_ruleItems = new WeakMap();
-exports.default = FieldCheck;
-//# sourceMappingURL=fieldCheck.js.map

lib/formVerify.d.ts

@@ -1,70 +0,0 @@
-import FieldCheck from "./fieldCheck";
-/**
- * @class FormItem 表单验证类
- * @description 表单项
- * @param {formObject} formObject 表单项数据
- * @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;
-    constructor(formObject: 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;
-    onLog: (msg: string) => void;
-    /**
-     * 检查表单项是否符合要求
-     * @param {formObject} form 表单对象
-     * @param isMustMatch 是否必须全部匹配到验证规则
-     * @returns {boolean}
-     */
-    checkForm(form: formObject, isMustMatch: boolean): boolean;
-    /**
-     * 验证当前的表单是否符合要求
-     * @param [isMustMatch] 是否必须全部匹配到验证规则
-     */
-    check(isMustMatch?: boolean): boolean;
-    /**
-     * 检测特定表单项的内容是否符合规则
-     * @param field 字段名
-     * @param isMustMatch 是否必须匹配到验证规则 默认 true
-     */
-    checkItem(field: string, isMustMatch?: boolean): boolean;
-    /**
-     * 使用该表单绑定的验证器进行验证字段与值是否符合规则
-     * @param field 要验证的字段
-     * @param value 要验证的值
-     * @param isMustMatch
-     */
-    verifyKnV(field: string, value: any, isMustMatch?: boolean): errMessage;
-    /**
-     * 获取表单keyValue数据对
-     * @returns {verifyForm} key:value
-     */
-    getFormData(): verifyForm;
-}
-export default FormVerify;
-//# sourceMappingURL=formVerify.d.ts.map

lib/formVerify.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"formVerify.d.ts","sourceRoot":"","sources":["../src/formVerify.ts"],"names":[],"mappings":"AACA,OAAO,UAAU,MAAM,cAAc,CAAC;AAStC;;;;;;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;gBAElB,UAAU,EAAC,UAAU,EAAE,UAAU,CAAC,EAAC,UAAU,EAAE,MAAM,CAAC,EAAC,gBAAgB;IAiBnF,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;IA8G7C;;;OAGG;IACH,MAAM,CAAC,gBAAgB,CAAG,UAAU,EAAE,UAAU;IAazC,KAAK,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAElC;IAED;;;;;OAKG;IACI,SAAS,CAAE,IAAI,EAAE,UAAU,EAAE,WAAW,EAAE,OAAO,GAAG,OAAO;IAiJlE;;;OAGG;IACI,KAAK,CAAE,WAAW,GAAC,OAAe,GAAI,OAAO;IAIpD;;;;OAIG;IACI,SAAS,CAAE,KAAK,EAAC,MAAM,EAAE,WAAW,UAAO,GAAI,OAAO;IAkB7D;;;;;OAKG;IACI,SAAS,CAAG,KAAK,EAAC,MAAM,EAAE,KAAK,EAAC,GAAG,EAAE,WAAW,UAAO,GAAK,UAAU;IAM7E;;;OAGG;IACI,WAAW,IAAK,UAAU;CAapC;AAED,eAAe,UAAU,CAAC"}

lib/formVerify.js

@@ -1,356 +0,0 @@
-"use strict";
-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"));
-// import {formItemData, formObject, formOption, FormVerifyOption} from "./types/formVerify";
-let hasOwnProperty = Object.prototype.hasOwnProperty;
-function hasOwn(obj, key) {
-    return hasOwnProperty.call(obj, key);
-}
-/**
- * @class FormItem 表单验证类
- * @description 表单项
- * @param {formObject} formObject 表单项数据
- * @param {FieldCheck} [fieldCheck] 字段验证对象
- * @param {object} [option] 配置项
- */
-class FormVerify {
-    constructor(formObject, 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;
-        // onLog函数
-        this.onLog = (msg) => {
-            // 不进行任何操作.
-        };
-        this.fieldCheck = fieldCheck || new fieldCheck_1.default();
-        // 合并配置项
-        this.option = Object.assign(this.defaultOption, option);
-        let errMsg;
-        // 拿出其中的每一项来构建对应的表单项
-        for (let key in formObject) {
-            // this.formData[key] = object[key];
-            // 验证表单项是否符合要求,不符合要求则抛出错误
-            errMsg = FormVerify.buildFormItem(formObject, key, formObject[key], this.fieldCheck, this.option.isMustMatchRule);
-            if (errMsg) {
-                throw new Error(`表单项${key}不符合要求,err:${errMsg}`);
-            }
-        }
-        this.formData = formObject;
-    }
-    static isObject(obj) {
-        return obj !== null && typeof obj === 'object';
-    }
-    /**
-     * 检查表单项是否符合要求
-     * @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`;
-        }
-        // 是否需要从验证规则表中查找对应的验证规则
-        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.find(item => item === option.key)) {
-                    option.disabled = true;
-                }
-            }
-            if (!hasInit) {
-                return `form item ${field} init value must be in options`;
-            }
-        }
-        // 判断是否有 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`;
-        }
-        // 判断是否有 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`;
-            }
-        }
-        // 判断是否有 reCheckField 有则使用该字段的值进行规则验证
-        if (formItemData.reCheckField) {
-            checkFieldStr = formItemData.reCheckField;
-        }
-        // 判断是否有 rules 规则
-        if (isMustMatchRule) {
-            if (fieldCheck.getRuleItem(checkFieldStr)) {
-                return `form item ${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 = '';
-        }
-    }
-    /**
-     * 检查表单项是否符合要求
-     * @param {formObject} form 表单对象
-     * @param isMustMatch 是否必须全部匹配到验证规则
-     * @returns {boolean}
-     */
-    checkForm(form, isMustMatch) {
-        let r = true;
-        let n_checkPass = 0, n_checkTotal = 0;
-        let tmpOption = {};
-        let msg = '';
-        let logStr = '';
-        let logHandle = (_str) => {
-            try {
-                this.onLog(_str);
-            }
-            catch (e) {
-                console.log(_str);
-                console.error(e);
-            }
-        };
-        for (const fieldKey in form) {
-            let formItem = form[fieldKey];
-            logStr = '';
-            if (!formItem) {
-                continue;
-            }
-            let depend = form[formItem.depend || ''];
-            let checkField = fieldKey;
-            let tmpInd = -1;
-            n_checkTotal++;
-            if (formItem.notCheck) {
-                n_checkPass++;
-                logStr = `项${fieldKey} 不进行检查`;
-                formItem.state = this.formState_pass;
-                formItem.msg = '';
-                logHandle(logStr);
-                continue;
-            }
-            if (formItem.reCheckField) {
-                checkField = formItem.reCheckField;
-            }
-            // 禁用值判断 array
-            if (formItem.disables) {
-                if (formItem.disables.find(item => item === formItem.val)) {
-                    formItem.msg = '该项内容不合法';
-                    formItem.state = this.formState_notPass;
-                    r = false;
-                }
-            }
-            // 枚举值判断
-            if (formItem.options) {
-                // 有枚举字段,只判断是否在枚举中
-                // console.log(`检测枚举字段:${checkField},值:${formItem.val}`);
-                tmpOption = formItem.options.find(item => item.value == formItem.val);
-                // tmpInd = formItem.options.findIndex(item=>item.value == formItem.val);
-                if (tmpOption) {
-                    if (tmpOption.disabled) {
-                        logStr = `项${fieldKey} 检测枚举字段:${checkField},值:${formItem.val}被禁用`;
-                        formItem.msg = '该选项已经被禁用';
-                        formItem.state = this.formState_notPass;
-                        r = false;
-                    }
-                    // 检查通过
-                    formItem.state = this.formState_pass;
-                    formItem.msg = '';
-                }
-                else {
-                    logStr = `项${fieldKey} 检测枚举字段:${checkField},值:${formItem.val}不在范围内`;
-                    formItem.msg = '选项不在范围内';
-                    formItem.state = this.formState_notPass;
-                    r = false;
-                }
-                // 枚举值判断完毕,继续下一个字段
-                n_checkPass++;
-                continue;
-            }
-            // 依赖字段判断
-            if (depend) {
-                depend = depend;
-                if (depend.options) {
-                    // 依赖的对象有枚举类型,检查该枚举类型是否有有检测值
-                    let optionItem = depend.options.find(item => item.value == formItem.val);
-                    if (!optionItem) {
-                        logStr = `检测依赖字段:${depend},但是选项${formItem.val}不在范围内`;
-                        depend.msg = '选项不在范围内';
-                        formItem.msg = '该值依赖项输入异常';
-                        r = false;
-                        // continue;
-                    }
-                    optionItem = optionItem;
-                    if (optionItem.checkField) {
-                        // console.log(`采用依赖项的检测字段${optionItem.checkField}`)
-                        checkField = optionItem.checkField;
-                    }
-                }
-                else {
-                    logStr = `项${fieldKey} 依赖表单项:${depend},没有对应 options 内容`;
-                    r = false;
-                }
-                if (!r) {
-                    logStr = `项${fieldKey} 检测依赖字段:${depend},但是选项${formItem.val}不在范围内`;
-                    depend.msg = '该项依赖项输入异常';
-                    formItem.msg = '该值依赖项输入异常';
-                    formItem.state = this.formState_notPass;
-                }
-            }
-            // 使用验证规则进行
-            formItem.msg = this.fieldCheck.verify({
-                [checkField]: formItem.val,
-                isMustMatch
-            });
-            if (formItem.msg) {
-                r = false;
-                logStr = `检测字段:${checkField},值:${formItem.val}不符合规则,${formItem.msg}`;
-            }
-            if (r) {
-                n_checkPass++;
-                logStr = `检测字段:${checkField},值:${formItem.val}符合规则`;
-                formItem.state = this.formState_pass;
-                formItem.msg = '';
-            }
-            else {
-                logStr = `检测字段:${checkField},值:${formItem.val}不符合规则,${formItem.msg}`;
-                formItem.state = this.formState_notPass;
-            }
-        }
-        if (logStr)
-            logHandle(logStr);
-        msg = `检查表单项通过率:${n_checkPass}/${n_checkTotal}`;
-        console.log(msg);
-        return r;
-    }
-    /**
-     * 验证当前的表单是否符合要求
-     * @param [isMustMatch] 是否必须全部匹配到验证规则
-     */
-    check(isMustMatch = false) {
-        return this.checkForm(this.formData, isMustMatch);
-    }
-    /**
-     * 检测特定表单项的内容是否符合规则
-     * @param field 字段名
-     * @param isMustMatch 是否必须匹配到验证规则 默认 true
-     */
-    checkItem(field, isMustMatch = true) {
-        var _a, _b;
-        // 获取表单项
-        let formItem;
-        let depend;
-        let formObject = {};
-        formItem = (_a = this === null || this === void 0 ? void 0 : this.formData) === null || _a === void 0 ? void 0 : _a[field];
-        if (!formItem) {
-            return false;
-        }
-        formObject[field] = formItem;
-        // 判断是否有depend字段
-        if (formItem.depend) {
-            formObject[formItem.depend] = (_b = this.formData) === null || _b === void 0 ? void 0 : _b[formItem.depend];
-        }
-        // 检查表单项是否符合要求
-        return this.checkForm(formObject, isMustMatch);
-    }
-    /**
-     * 使用该表单绑定的验证器进行验证字段与值是否符合规则
-     * @param field 要验证的字段
-     * @param value 要验证的值
-     * @param isMustMatch
-     */
-    verifyKnV(field, value, isMustMatch = true) {
-        return this.fieldCheck.verify({
-            [field]: value,
-        }, isMustMatch);
-    }
-    /**
-     * 获取表单keyValue数据对
-     * @returns {verifyForm} key:value
-     */
-    getFormData() {
-        let formData = {};
-        for (const key in this.formData) {
-            if (hasOwn(this.formData, key)) {
-                const formItem = this.formData[key];
-                formData[key] = formItem.val;
-            }
-        }
-        return formData;
-    }
-}
-exports.default = FormVerify;
-//# sourceMappingURL=formVerify.js.map

lib/index.d.ts

@@ -1,10 +0,0 @@
-/**
- * @module kind-form-verify
- */
-export { default as FormVerify } from "./formVerify";
-export { default as FieldCheck } from "./fieldCheck";
-/**
- * @example
- * import {FormItem,FieldCheck} from "kind-form-verify"
- */
-//# sourceMappingURL=index.d.ts.map

lib/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,EAAC,OAAO,IAAI,UAAU,EAAC,MAAM,cAAc,CAAC;AAGnD,OAAO,EAAC,OAAO,IAAI,UAAU,EAAC,MAAM,cAAc,CAAC;AAOnD;;;GAGG"}

lib/index.js

@@ -1,26 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FieldCheck = exports.FormVerify = void 0;
-/**
- * @module kind-form-verify
- */
-// import "./types";
-// 导入 types
-var formVerify_1 = require("./formVerify");
-Object.defineProperty(exports, "FormVerify", { enumerable: true, get: function () { return __importDefault(formVerify_1).default; } });
-var fieldCheck_1 = require("./fieldCheck");
-Object.defineProperty(exports, "FieldCheck", { enumerable: true, get: function () { return __importDefault(fieldCheck_1).default; } });
-// 导出模块
-// export default {
-//     FormVerify,
-//     FieldCheck,
-// };
-// 示例
-/**
- * @example
- * import {FormItem,FieldCheck} from "kind-form-verify"
- */
-//# sourceMappingURL=index.js.map

lib/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;AAAA;;GAEG;AACH,oBAAoB;AACpB,WAAW;AACX,2CAAmD;AAA3C,yHAAA,OAAO,OAAc;AAG7B,2CAAmD;AAA3C,yHAAA,OAAO,OAAc;AAC7B,OAAO;AACP,mBAAmB;AACnB,kBAAkB;AAClB,kBAAkB;AAClB,KAAK;AACL,KAAK;AACL;;;GAGG"}

lib/tools/tool.d.ts

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

lib/tools/tool.d.ts.map

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

lib/tools/tool.js

@@ -1,2 +0,0 @@
-"use strict";
-//# sourceMappingURL=tool.js.map

lib/tools/tool.js.map

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

package.json

@@ -2,8 +2,10 @@
   "name": "kind-form-verify",
   "version": "1.0.4",
   "description": "表单规则验证工具库",
-  "main": "lib/index.js",
+  "main": "lib/cjs/index.js",
+  "module": "lib/esm/index.js",
   "types": "lib/index.d.ts",
+  "type": "module",
   "author": "kindring",
   "keywords": [
     "verify",
@@ -15,7 +17,7 @@
     "patch": "npm run build && npm version patch",
     "compile": "npx babel -d lib/ src/",
     "clean": "rimraf -rf lib/",
-    "build": "npm run clean && tsc",
+    "build": "npm run clean && tsc -p tsconfig.json && tsc -p tsconfig.esm.json",
     "prepublishOnly": "npm run compile"
   },
   "license": "MIT",

test/ep1.mjs

@@ -0,0 +1,171 @@
+/**
+ * 测试 表单验证器
+ */
+
+import {FieldCheck, FormVerify} from "../lib/esm/index.js"
+import {paramsRules} from "./rule.js"
+
+let fieldCheck  = new FieldCheck(paramsRules);
+
+let t_form = {
+    pType: {
+        val: 'all',
+        oldVal: 'all',
+        init: 'all',
+        msg: '',
+        state: 0,
+        options: [
+            {text: '全部', key: 'all', value: 'all'},
+            {text: '新闻', key: 'news', value: 'news'},
+            {text: '解决方案', key: 'solution', value: 'solution'},
+        ]
+    },
+    type: {
+        val: '',
+        init: '',
+        msg: '',
+        state: 0,
+        options: [
+                {
+                    "text": "全部",
+                    "key": "all",
+                    "value": "all",
+                    "disabled": true
+                },
+                {
+                    "type_id": 1,
+                    "type_logo": null,
+                    "type_name": "解决方案",
+                    "parent_type": 1,
+                    "type_name_en": "Plan and case",
+                    "type_sort": 1,
+                    "date_time": "1482569003",
+                    "type_key": "sol",
+                    "seo_key": null,
+                    "text": "解决方案",
+                    "key": "sol",
+                    "typeKey": "sol",
+                    "href": "/sol",
+                    "value": "sol"
+                },
+                {
+                    "type_id": 3,
+                    "type_logo": null,
+                    "type_name": "公司动态",
+                    "parent_type": 2,
+                    "type_name_en": "Company Dynamic",
+                    "type_sort": 0,
+                    "date_time": "1482307803",
+                    "type_key": "com",
+                    "seo_key": null,
+                    "text": "公司动态",
+                    "key": "com",
+                    "typeKey": "com",
+                    "href": "/com",
+                    "value": "com"
+                },
+                {
+                    "type_id": 4,
+                    "type_logo": null,
+                    "type_name": "行业资讯",
+                    "parent_type": 2,
+                    "type_name_en": "Industry information",
+                    "type_sort": 0,
+                    "date_time": "1482307826",
+                    "type_key": "in",
+                    "seo_key": null,
+                    "text": "行业资讯",
+                    "key": "in",
+                    "typeKey": "in",
+                    "href": "/in",
+                    "value": "in"
+                },
+                {
+                    "type_id": 2,
+                    "type_logo": null,
+                    "type_name": "应用案例",
+                    "parent_type": 1,
+                    "type_name_en": "输电线路在线监测",
+                    "type_sort": 0,
+                    "date_time": "1482307826",
+                    "type_key": "acs",
+                    "seo_key": null,
+                    "text": "应用案例",
+                    "key": "acs",
+                    "typeKey": "acs",
+                    "href": "/acs",
+                    "value": "acs"
+                },
+                {
+                    "type_id": 12,
+                    "type_logo": null,
+                    "type_name": "产品的应用",
+                    "parent_type": 2,
+                    "type_name_en": "产品的应用",
+                    "type_sort": 0,
+                    "date_time": "1638180062",
+                    "type_key": "pa",
+                    "seo_key": null,
+                    "text": "产品的应用",
+                    "key": "pa",
+                    "typeKey": "pa",
+                    "href": "/pa",
+                    "value": "pa"
+                },
+                {
+                    "type_id": 14,
+                    "type_logo": null,
+                    "type_name": "电力案例",
+                    "parent_type": 1,
+                    "type_name_en": "电力案例",
+                    "type_sort": 0,
+                    "date_time": "1663818099",
+                    "type_key": "epower",
+                    "seo_key": null,
+                    "text": "电力案例",
+                    "key": "epower",
+                    "typeKey": "epower",
+                    "href": "/epower",
+                    "value": "epower"
+                }
+        ],
+        disables: ['all'],
+    },
+    title: {
+        val: '',
+        init: '',
+        msg: '',
+        state: 0
+    },
+    author: {
+        val: '',
+        init: '',
+        msg: '',
+        state: 0
+    },
+    source: {
+        val: '',
+        init: '',
+        msg: '',
+        state: 0
+    },
+    cover: {
+        val: '',
+        init: '',
+        msg: '',
+        reCheckField: 'fileData',
+        state: 0
+    },
+    remark: {
+        val: '',
+        init: '',
+        msg: '',
+        state: 0
+    },
+}
+let formVerify = new FormVerify(t_form, fieldCheck);
+
+t_form.remark.val = '123';
+
+let t_b_1 = formVerify.checkItem('remark');
+console.log(`[${t_b_1?'pass':'failed'}] ${t_form.remark.msg}`);

test/rule.js

@@ -0,0 +1,192 @@
+function isNumber(v){
+    return v instanceof Number
+}
+function toString(v){
+    // 情况1 非对象,直接调用内部值
+    if(isNumber(v)) {
+        return v + ''
+    }
+    return v + '';
+}
+
+let requiredRuleItem = {require: true,message:'该项为必填项'}
+let phoneRule = [{
+    type: 'string',
+    length: 11,
+    message: '手机号长度必须是11字符'
+},{
+    regex: /^1(3\d|4[5-9]|5[0-35-9]|6[2567]|7[0-8]|8\d|9[0-35-9])\d{8}$/,
+    message: '手机号格式不正确'
+}]
+let passwordRule= [{
+    type: 'string',
+    minLength: 6,
+    maxLength: 18,
+    message: '密码长度为6-18'
+}]
+let imeiRule = [{
+    type: 'string',
+    length: 15,
+    message: 'IMEI号长度应该为15位'
+}]
+const ownerRule= [
+    requiredRuleItem,
+    {
+        type: 'string',
+        minLength: 1,
+        maxLength: 16,
+        message: '用户名owner类型或者长度不一致'
+    },
+]
+const captchaRule = [{
+    type: 'string',
+    length: 4,
+    message: '验证码长度为4'
+}]
+const nameRule = [
+    {
+        type: 'string',
+        min: 1,
+        max: 25,
+        message: '名称长度不符合'
+    }
+]
+
+const hrefRule = [
+    {
+        type: 'string',
+        min: 1,
+        max: 500,
+        message: '链接长度不符合'
+    },
+    {
+        type: 'string',
+        // 是否符合url地址,支持域名与ip/^http(s)?:\/\/([\w-]+\.)+[\w-]+(\/[\w- .\/?%&=]*)?$/
+        regex: /(https?|ftp|file|http):\/\/[-A-Za-z0-9+&@#/%?=~_|!:,.;]+[-A-Za-z0-9+&@#/%=~_|]/,
+        message: '链接格式不正确'
+    },
+];
+
+
+const requireIdRule = [
+    requiredRuleItem,
+]
+
+let checkCode = function (val) {
+    let p = /^[1-9]\d{5}(18|19|20)\d{2}((0[1-9])|(1[0-2]))(([0-2][1-9])|10|20|30|31)\d{3}[0-9Xx]$/;
+    let factor = [ 7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2 ];
+    let parity = [ 1, 0, 'X', 9, 8, 7, 6, 5, 4, 3, 2 ];
+    let code = val.substring(17);
+    if(p.test(val)) {
+        let sum = 0;
+        for(let i=0;i<17;i++) {
+            sum += val[i]*factor[i];
+        }
+        console.log(typeof parity[sum % 11])
+        console.log(typeof code.toUpperCase())
+        if(toString(parity[sum % 11]) === code.toUpperCase()) {
+            return true;
+        }
+    }
+    return false;
+}
+
+
+let checkDate = function (val) {
+    var pattern = /^(18|19|20)\d{2}((0[1-9])|(1[0-2]))(([0-2][1-9])|10|20|30|31)$/;
+    if(pattern.test(val)) {
+        var year = val.substring(0, 4);
+        var month = val.substring(4, 6);
+        var date = val.substring(6, 8);
+        var date2 = new Date(year+"-"+month+"-"+date);
+        if(date2 && date2.getMonth() === (parseInt(month) - 1)) {
+            return true;
+        }
+    }
+    return false;
+}
+let checkProv = function (val) {
+    let pattern = /^[1-9][0-9]/;
+    let provs = {11:"北京",12:"天津",13:"河北",14:"山西",15:"内蒙古",21:"辽宁",22:"吉林",23:"黑龙江 ",31:"上海",32:"江苏",33:"浙江",34:"安徽",35:"福建",36:"江西",37:"山东",41:"河南",42:"湖北 ",43:"湖南",44:"广东",45:"广西",46:"海南",50:"重庆",51:"四川",52:"贵州",53:"云南",54:"西藏 ",61:"陕西",62:"甘肃",63:"青海",64:"宁夏",65:"新疆",71:"台湾",81:"香港",82:"澳门"};
+    if(pattern.test(val)) {
+        if(provs[val]) {
+            return true;
+        }
+    }
+    return false;
+}
+
+const checkID = function (val) {
+    if(checkCode(val)) {
+        console.log('code')
+        let date = val.substring(6,14);
+        if(checkDate(date)) {
+            if(checkProv(val.substring(0,2))) {
+                console.log('匹配成功')
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
+
+const cardRule = [
+    requiredRuleItem,
+    function(val){
+        return checkID(val)?'':'身份证验证失败';
+    }]
+
+export const paramsRules = [
+    {
+        name: "用户名验证规则",
+        checkFields: ['name','workerName','buildingName','entranceName'],
+        rules: nameRule,
+    },
+    {
+        name: "设备imei号验证",
+        checkFields: ['imei','IMEI','Imei'],
+        rules: imeiRule,
+    },
+    {
+        name: "类型等必填项验证规则",
+        checkFields: ['workerType','type','cameraType','buildingAbout','entranceId'],
+        rules: [requiredRuleItem],
+    },
+    {
+        name: "手机号验证",
+        checkFields: ['phone','workerPhone','companyPhone'],
+        rules: phoneRule,
+    },
+    {
+        name: "验证码验证",
+        checkFields:['captcha','captchaImg'],
+        rules:captchaRule
+    },
+    {
+        name: "账户",
+        checkFields:['owner','account'],
+        rules:ownerRule
+    },
+    {
+        checkFields:['passwd', 'password'],
+        rules:passwordRule
+    },
+    {
+        checkFields: ['card', 'workerCard'],
+        rules: cardRule,
+    },
+    {
+        checkFields: ['href', 'url'],
+        rules: hrefRule,
+    },
+    {
+        checkFields: [/id/gi,'fileData', 'remark'],
+        rules: requireIdRule
+    }
+]
+
+
+export default {
+    paramsRules
+}

tsconfig.esm.json

@@ -0,0 +1,11 @@
+{
+  "extends": "./tsconfig.json",
+
+  "compilerOptions": {
+    "target": "es2016",
+    "module": "es2015",
+    "outDir": "./lib/esm",
+    "moduleResolution": "node",
+
+  }
+}

tsconfig.json

@@ -1,4 +1,5 @@
 {
+  /* cjs */
   "compilerOptions": {
     /* Visit https://aka.ms/tsconfig to read more about this file */
 
@@ -54,7 +55,7 @@
      "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. */
+     "outDir": "./lib/cjs",                                   /* 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. */