ph-utils 0.2.23 → 0.3.1

package/lib/validator.js

@@ -1,215 +1,212 @@
-"use strict";
-/* eslint-disable @typescript-eslint/ban-ts-comment */
-/**
- * 数据验证器
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-// 默认的错误提示信息
-const defaultMsgs = {
-    mobile: '请输入正确的手机号',
-    same: '两次输入不一致',
-    required: '%s为必填字段',
-};
-const defaultMsg = '请输入正确的数据';
-// 一些常用的验证正则
-const ruleRegexs = {
-    /** 验证跟其余数据相等的正则，一般用于验证再次输入密码 */
-    same: /^same:(.+)$/i,
-    /** 验证手机号的正则表达式 */
-    mobile: /^1[34578]\d{9}$/,
-    /** 非空验证的正则表达式 */
-    required: /^\S{1}.*/,
-};
-// 规则比对函数
-const ruleFns = {
-    /** 验证相等 */
-    same(val1, val2) {
-        return val2 === val1;
-    },
-    /** 正则匹配 */
-    pattern(regex, val) {
-        if (val == null) {
-            return false;
-        }
-        return regex.test(String(val));
-    },
-};
-class ValidateError extends Error {
-    name;
-    key;
-    constructor(key, msg) {
-        super(msg);
-        this.name = 'ValidateError';
-        this.key = key;
-    }
-}
-/**
- * 数据验证器，除了进行数据验证外，还可以同时进行数据转化
- */
-class Validator {
-    rules;
-    /**
-     * 构造数据验证转换器
-     * @param schemas 配置验证转换规则
-     */
-    constructor(schemas) {
-        let parsedRules = {};
-        for (let schema of schemas) {
-            // 解析规则
-            let rules = [];
-            let rule = schema.rules;
-            if (typeof rule === 'string') {
-                rules = rules.concat(this._parseStringRule(rule, schema.message));
-            }
-            else if (rule instanceof Array) {
-                for (let ruleItem of rule) {
-                    if (typeof ruleItem === 'string') {
-                        rules.push(...this._parseStringRule(ruleItem, schema.message));
-                    }
-                    else if (ruleItem instanceof RegExp ||
-                        typeof ruleItem === 'function') {
-                        rules.push({
-                            rule: ruleItem,
-                            message: schema.message || defaultMsg,
-                        });
-                    }
-                    else {
-                        if (typeof ruleItem.rule === 'string') {
-                            rules.push(...this._parseStringRule(ruleItem.rule, ruleItem.message));
-                        }
-                        else {
-                            rules.push({
-                                rule: ruleItem.rule,
-                                message: ruleItem.message || defaultMsg,
-                            });
-                        }
-                    }
-                }
-            }
-            else {
-                rules.push({ rule, message: defaultMsg });
-            }
-            if (schema.required === true &&
-                rules.findIndex((r) => r.rule === 'required') === -1) {
-                rules.push(this._parseStringRule('required'));
-            }
-            parsedRules[schema.key] = rules;
-        }
-        this.rules = parsedRules;
-    }
-    /**
-     * 进行数据验证
-     * @param data 待验证的数据
-     * @returns
-     */
-    validate(data) {
-        return new Promise((resolve, reject) => {
-            let errMsg = '';
-            let errKey = '';
-            for (let key in this.rules) {
-                // eslint-disable-next-line no-prototype-builtins
-                if (this.rules.hasOwnProperty(key)) {
-                    errMsg = this._validateRule(this.rules[key], data[key], data);
-                    if (errMsg !== '') {
-                        errKey = key;
-                        errMsg = errMsg.replace('%s', key);
-                        break;
-                    }
-                }
-            }
-            if (errMsg === '') {
-                resolve(true);
-            }
-            else {
-                reject(new ValidateError(errKey, errMsg));
-            }
-        });
-    }
-    /**
-     * 只验证指定 key 的数据格式
-     * @param key   指定待验证的 key
-     * @param value 待验证的数据
-     */
-    validateKey(key, value, data) {
-        return new Promise((resolve, reject) => {
-            let keyRules = this.rules[key];
-            let errMsg = this._validateRule(keyRules, value, data);
-            if (errMsg !== '') {
-                errMsg = errMsg.replace('%s', key);
-                reject(new ValidateError(key, errMsg));
-            }
-            else {
-                resolve(true);
-            }
-        });
-    }
-    _validateRule(rules, value, data) {
-        let errMsg = '';
-        for (let rule of rules) {
-            // 如果数据为空，则判断是否是必填
-            if (rule.rule === 'required') {
-                if (value == null || !ruleFns.pattern(ruleRegexs.required, value)) {
-                    errMsg = rule.message;
-                }
-            }
-            if (typeof rule.rule === 'function') {
-                if (!rule.rule(value)) {
-                    errMsg = rule.message;
-                }
-            }
-            else if (rule.sameKey != null) {
-                if (data != null) {
-                    if (!ruleFns.same(value, data[rule.sameKey])) {
-                        errMsg = rule.message;
-                    }
-                }
-            }
-            else if (rule.rule === 'required') {
-                if (!ruleFns.pattern(ruleRegexs.required, String(value))) {
-                    errMsg = rule.message;
-                }
-            }
-            else {
-                if (!ruleFns.pattern(rule.rule, String(value))) {
-                    errMsg = rule.message;
-                }
-            }
-            if (errMsg !== '') {
-                break;
-            }
-        }
-        return errMsg;
-    }
-    _parseStringRule(rule, ruleErrMsg) {
-        let rules = [];
-        let trule = rule.split('|');
-        for (let r of trule) {
-            let message = ruleErrMsg;
-            let rrule = null;
-            let sameKey;
-            if (ruleRegexs.same.test(r)) {
-                let m = r.match(ruleRegexs.same);
-                if (m != null) {
-                    rrule = ruleRegexs.same;
-                    let m = r.match(ruleRegexs.same);
-                    if (m != null) {
-                        sameKey = m[1];
-                    }
-                    message = message || defaultMsgs['same'];
-                }
-            }
-            else if (rule === 'required') {
-                rrule = 'required';
-                message = message || ruleErrMsg || defaultMsgs.required;
-                // eslint-disable-next-line no-prototype-builtins
-            }
-            else if (ruleRegexs.hasOwnProperty(r)) {
-                rrule = ruleRegexs[r];
-                message = message || defaultMsgs[r];
-            }
-            rules.push({ rule: rrule, message: message, sameKey });
-        }
-        return rules;
-    }
-}
-exports.default = Validator;
+/**
+ * 数据验证器
+ */
+// 默认的错误提示信息
+const defaultMsgs = {
+    mobile: '请输入正确的手机号',
+    same: '两次输入不一致',
+    required: '%s为必填字段',
+};
+const defaultMsg = '请输入正确的数据';
+// 一些常用的验证正则
+const ruleRegexs = {
+    /** 验证跟其余数据相等的正则，一般用于验证再次输入密码 */
+    same: /^same:(.+)$/i,
+    /** 验证手机号的正则表达式 */
+    mobile: /^1[34578]\d{9}$/,
+    /** 非空验证的正则表达式 */
+    required: /^\S{1}.*/,
+};
+// 规则比对函数
+const ruleFns = {
+    /** 验证相等 */
+    same(val1, val2) {
+        return val2 === val1;
+    },
+    /** 正则匹配 */
+    pattern(regex, val) {
+        if (val == null) {
+            return false;
+        }
+        return regex.test(String(val));
+    },
+};
+class ValidateError extends Error {
+    name;
+    key;
+    constructor(key, msg) {
+        super(msg);
+        this.name = 'ValidateError';
+        this.key = key;
+    }
+}
+/**
+ * 数据验证器，除了进行数据验证外，还可以同时进行数据转化
+ */
+class Validator {
+    rules;
+    /**
+     * 构造数据验证转换器
+     * @param schemas 配置验证转换规则
+     */
+    constructor(schemas) {
+        let parsedRules = {};
+        for (let schema of schemas) {
+            // 解析规则
+            let rules = [];
+            let rule = schema.rules;
+            if (rule != null) {
+                if (typeof rule === 'string') {
+                    rules = rules.concat(this._parseStringRule(rule, schema.message));
+                }
+                else if (rule instanceof Array) {
+                    for (let ruleItem of rule) {
+                        if (typeof ruleItem === 'string') {
+                            rules.push(...this._parseStringRule(ruleItem, schema.message));
+                        }
+                        else if (ruleItem instanceof RegExp || typeof ruleItem === 'function') {
+                            rules.push({
+                                rule: ruleItem,
+                                message: schema.message || defaultMsg,
+                            });
+                        }
+                        else {
+                            if (typeof ruleItem.rule === 'string') {
+                                rules.push(...this._parseStringRule(ruleItem.rule, ruleItem.message));
+                            }
+                            else {
+                                rules.push({
+                                    rule: ruleItem.rule,
+                                    message: ruleItem.message || defaultMsg,
+                                });
+                            }
+                        }
+                    }
+                }
+                else {
+                    rules.push({ rule, message: defaultMsg });
+                }
+            }
+            if (schema.required === true && (rules == null || rules.findIndex((r) => r.rule === 'required') === -1)) {
+                rules.push(...this._parseStringRule('required', schema.message));
+            }
+            parsedRules[schema.key] = rules;
+        }
+        this.rules = parsedRules;
+    }
+    /**
+     * 进行数据验证
+     * @param data 待验证的数据
+     * @returns
+     */
+    validate(data) {
+        return new Promise((resolve, reject) => {
+            let errMsg = '';
+            let errKey = '';
+            for (let key in this.rules) {
+                // eslint-disable-next-line no-prototype-builtins
+                if (this.rules.hasOwnProperty(key)) {
+                    errMsg = this._validateRule(this.rules[key], data[key], data);
+                    if (errMsg !== '') {
+                        errKey = key;
+                        errMsg = errMsg.replace('%s', key);
+                        break;
+                    }
+                }
+            }
+            if (errMsg === '') {
+                resolve(true);
+            }
+            else {
+                reject(new ValidateError(errKey, errMsg));
+            }
+        });
+    }
+    /**
+     * 只验证指定 key 的数据格式
+     * @param key   指定待验证的 key
+     * @param value 待验证的数据
+     */
+    validateKey(key, value, data) {
+        return new Promise((resolve, reject) => {
+            let keyRules = this.rules[key];
+            let errMsg = this._validateRule(keyRules, value, data);
+            if (errMsg !== '') {
+                errMsg = errMsg.replace('%s', key);
+                reject(new ValidateError(key, errMsg));
+            }
+            else {
+                resolve(true);
+            }
+        });
+    }
+    _validateRule(rules, value, data) {
+        let errMsg = '';
+        for (let rule of rules) {
+            // 如果数据为空，则判断是否是必填
+            if (rule.rule === 'required') {
+                if (value == null || !ruleFns.pattern(ruleRegexs.required, value)) {
+                    errMsg = rule.message;
+                }
+            }
+            if (typeof rule.rule === 'function') {
+                if (!rule.rule(value)) {
+                    errMsg = rule.message;
+                }
+            }
+            else if (rule.sameKey != null) {
+                if (data != null) {
+                    if (!ruleFns.same(value, data[rule.sameKey])) {
+                        errMsg = rule.message;
+                    }
+                }
+            }
+            else if (rule.rule === 'required') {
+                if (!ruleFns.pattern(ruleRegexs.required, String(value))) {
+                    errMsg = rule.message;
+                }
+            }
+            else {
+                if (!ruleFns.pattern(rule.rule, String(value))) {
+                    errMsg = rule.message;
+                }
+            }
+            if (errMsg !== '') {
+                break;
+            }
+        }
+        return errMsg;
+    }
+    _parseStringRule(rule, ruleErrMsg) {
+        let rules = [];
+        let trule = rule.split('|');
+        for (let r of trule) {
+            let message = ruleErrMsg;
+            let rrule = null;
+            let sameKey;
+            if (ruleRegexs.same.test(r)) {
+                let m = r.match(ruleRegexs.same);
+                if (m != null) {
+                    rrule = ruleRegexs.same;
+                    let m = r.match(ruleRegexs.same);
+                    if (m != null) {
+                        sameKey = m[1];
+                    }
+                    message = message || defaultMsgs['same'];
+                }
+            }
+            else if (rule === 'required') {
+                rrule = 'required';
+                message = message || ruleErrMsg || defaultMsgs.required;
+                // eslint-disable-next-line no-prototype-builtins
+            }
+            else if (ruleRegexs.hasOwnProperty(r)) {
+                rrule = ruleRegexs[r];
+                message = message || defaultMsgs[r];
+            }
+            rules.push({ rule: rrule, message: message, sameKey });
+        }
+        return rules;
+    }
+}
+export default Validator;

package/lib/web.d.ts

@@ -1,55 +1,13 @@
-/**
- * 解析 Form 表单中的 input 元素的数据为 JSON 格式，key: input-name；value: input-value
- * @param form {object} Form 节点对象
- */
-export declare const formJson: <T>(form: HTMLFormElement) => T;
-/**
- * 获取 url query 参数 (get 请求的参数)
- * @param search 如果是 React 应用就需要传递 useLocation().search
- * @returns
- */
-export declare function query(search?: string): {
-    [index: string]: string;
-};
-interface RandomOpts {
-    /** 生成的随机数是整形还是小数形 */
-    isInt?: boolean;
-    /** 生成的随机数是否包含末尾数字 end, 仅在有 end 参数并且 isInt = true 时有效; true 表示包含 */
-    hasEnd?: boolean;
-}
-/**
- * 生成指定长度的随机数
- * @param len 生成的随机数长度
- * @param firstZero 生成的随机数第一位是否可以包含 0，默认为 true
- */
-export declare function random(len: number, firstZero?: boolean): string;
-/**
- * 生成介于 min 和 max 之间的随机数
- * @param min   最小值
- * @param max   最大值
- * @param opts  配置项
- * @property opts.isInt 生成的随机数是整形还是小数形
- * @property opts.hasEnd 生成的随机数是否包含末尾数字 max, 仅在有 max 参数并且 isInt = true 时有效; true 表示包含
- */
-export declare function random(min: number, max: number, opts?: RandomOpts): number;
-/**
- * 将金额数字格式化为金额格式显示并且会保留两位小数[去除多余的位数，不是四舍五入，而是直接舍去]  1234523432.23 => 123,123,123.23
- * @param {number} number 待转换的金额数字
- * @return string
- */
-export declare function formatMoney(number: number): string;
-/**
- * 函数节流 - 每隔单位时间，只执行一次
- * @param cb    待节流的函数
- * @param wait  间隔时间
- * @returns
- */
-export declare function throttle<R extends any[], T>(fn: (...args: R) => T, wait?: number): (...args: R) => void;
-/**
- * 函数防抖 - 当重复触发某一个行为（事件时），只执行最后一次触发
- * @param fn        防抖函数
- * @param interval  间隔时间段
- * @returns
- */
-export declare function debounce<R extends any[], T>(fn: (...args: R) => T, interval?: number): (...args: R) => void;
-export {};
+/**
+ * 解析 Form 表单中的 input 元素的数据为 JSON 格式，key: input-name；value: input-value
+ * @param form {object} Form 节点对象
+ */
+export declare const formJson: <T>(form: HTMLFormElement) => T;
+/**
+ * 获取 url query 参数 (get 请求的参数)
+ * @param search 如果是 React 应用就需要传递 useLocation().search
+ * @returns
+ */
+export declare function query(search?: string): {
+    [index: string]: string;
+};