ph-utils 0.1.5 → 0.2.1

package/README.md

@@ -4,8 +4,8 @@
 
 ### 后端(node server)
 
-包含了一些 node 后端开发(web server) 时常用的工具类，包括 `index` 基础工具类(这个类里面的函数同样也适用于前端)、`date` 跟日期相关的工具类、`file` 文件操作相关工具类、`server` 一些只适用于后端的工具(使用了后端的 API 列表)
+包含了一些 node 后端开发(web server) 时常用的工具类，包括 `index` 基础工具类(这个类里面的函数同样也适用于前端)、`date` 跟日期相关的工具类、`file` 文件操作相关工具类、`server` 一些只适用于后端的工具(使用了后端的 API 列表)、`validator` 数据验证
 
 ### 前端(web)
 
-包含了一些前端网站开发时常用的工具类，包括 `index` 基础工具类(这个类里面的函数同样也适用于前端)、`date` 跟日期相关的工具类、`dom` 浏览器节点操作相关、`web` 一些只适用于前端相关的工具 s
+包含了一些前端网站开发时常用的工具类，包括 `index` 基础工具类(这个类里面的函数同样也适用于前端)、`date` 跟日期相关的工具类、`dom` 浏览器节点操作相关、`web` 一些只适用于前端相关的工具、`validator` 数据验证

package/lib/dom.d.ts

@@ -2,7 +2,7 @@
  * 根据选择器获取节点
  * @param {string} selector 选择器
  */
-export declare function elem(selector: string, dom?: HTMLElement): NodeListOf<HTMLElement>;
+export declare function elem(selector: string | HTMLElement, dom?: HTMLElement): NodeListOf<HTMLElement> | HTMLElement[];
 /**
  * 为节点添加 class
  * @param {HTMLElement} elem 待添加 class 的节点
@@ -37,6 +37,7 @@ export declare function transform(element: HTMLElement, value: string): void;
 export declare function on(element: HTMLElement, listener: string, fn: (e: Event, target?: HTMLElement, flag?: string) => void, once?: boolean | {
     once?: boolean;
     eventFlag?: string;
+    eventStop?: boolean;
 }): void;
 /**
  * 设置或获取节点的 innerHTML 属性

package/lib/dom.js

@@ -9,7 +9,12 @@ const vendorPrefix = ['', '-webkit', '-moz-'];
  * @param {string} selector 选择器
  */
 export function elem(selector, dom) {
-    return (dom || document).querySelectorAll(selector);
+    if (typeof selector === 'string') {
+        return (dom || document).querySelectorAll(selector);
+    }
+    else {
+        return [selector];
+    }
 }
 /**
  * 为节点添加 class
@@ -57,14 +62,14 @@ export function transform(element, value) {
  * @param {boolean}     onceOrConfig  是否是只运行一次的处理函数或者配置，其中 eventFlag 为 string，如果配置该项，则表明为委托事件
  */
 export function on(element, listener, fn, once = false) {
-    let eventExtra = {};
+    let eventExtra = { eventStop: false };
     if (typeof once === 'boolean') {
-        eventExtra.once = true;
+        eventExtra.once = once;
     }
     else {
         eventExtra = once;
     }
-    if (eventExtra.eventFlag !== null) {
+    if (eventExtra.eventFlag != null) {
         element.setAttribute(eventExtra.eventFlag, '__stop__');
         element.addEventListener(listener, (e) => {
             let target = e.target;
@@ -75,7 +80,7 @@ export function on(element, listener, fn, once = false) {
                     target = target.parentNode;
                 }
             } while (flag === '');
-            if (flag !== '__stop__') {
+            if (flag !== '__stop__' || eventExtra.eventStop) {
                 fn(e, target, flag);
             }
         }, eventExtra);

package/lib/validator.d.ts

@@ -0,0 +1,44 @@
+interface RuleItem {
+    rule: RegExp | ((v: any) => boolean);
+    message: string;
+    sameKey?: string;
+}
+/**
+ * 数据验证器，除了进行数据验证外，还可以同时进行数据转化
+ */
+declare class Validator {
+    rules: {
+        [index: string]: RuleItem[];
+    };
+    types: {
+        [index: string]: string | ((v: any) => void);
+    };
+    /**
+     * 构造数据验证转换器
+     * @param schemas 配置验证转换规则
+     */
+    constructor(schemas: {
+        key: string;
+        type?: string | ((v: any) => void);
+        rules: string | RegExp | ((v: any) => boolean) | (RegExp | string | ((v: any) => boolean) | {
+            rule: string | RegExp | ((v: any) => boolean);
+            message?: string;
+        })[];
+    }[]);
+    /**
+     * 进行数据验证，同时根据 type 进行数据类型转换
+     * @param data 待验证的数据
+     * @returns
+     */
+    validate<T>(data: any): Promise<unknown>;
+    /**
+     * 只验证指定 key 的数据格式
+     * @param key   指定待验证的 key
+     * @param value 待验证的数据
+     */
+    validateKey(key: string, value: any): Promise<unknown>;
+    private _conversionType;
+    private _validateRule;
+    private _parseStringRule;
+}
+export = Validator;

package/lib/validator.js

@@ -0,0 +1,219 @@
+"use strict";
+/**
+ * 数据验证器
+ */
+// 默认的错误提示信息
+const defaultMsgs = {
+    mobile: '请输入正确的手机号',
+    same: '两次输入不一致',
+    required: '%s为必填字段',
+};
+const defaultMsg = '请输入正确的数据';
+// 允许的内置 type
+const validTypes = new Set(['string', 'boolean', 'number', 'float', 'int']);
+// 一些常用的验证正则
+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));
+    },
+};
+const typeFns = {
+    string(v) {
+        return String(v);
+    },
+    boolean(v) {
+        return Boolean(v);
+    },
+    number(v) {
+        return Number(v);
+    },
+    int(v) {
+        return parseInt(v, 10);
+    },
+    floag(v) {
+        return parseFloat(v);
+    },
+};
+class ValidateError extends Error {
+    name;
+    constructor(msg) {
+        super(msg);
+        this.name = 'ValidateError';
+    }
+}
+/**
+ * 数据验证器，除了进行数据验证外，还可以同时进行数据转化
+ */
+class Validator {
+    rules;
+    types;
+    /**
+     * 构造数据验证转换器
+     * @param schemas 配置验证转换规则
+     */
+    constructor(schemas) {
+        let parsedRules = {};
+        let types = {};
+        for (let schema of schemas) {
+            // 解析 types 用于进行数据类型转换
+            if (typeof schema.type === 'function') {
+                types[schema.key] = schema.type;
+            }
+            else {
+                types[schema.key] = validTypes.has(schema.type || '') ? schema.type : 'string';
+            }
+            // 解析规则
+            let rules = [];
+            let rule = schema.rules;
+            if (typeof rule === 'string') {
+                rules = rules.concat(this._parseStringRule(rule));
+            }
+            else if (rule instanceof Array) {
+                for (let ruleItem of rule) {
+                    if (typeof ruleItem === 'string') {
+                        rules = rules.concat(this._parseStringRule(ruleItem));
+                    }
+                    else if (ruleItem instanceof RegExp || typeof ruleItem === 'function') {
+                        rules.push({ rule: ruleItem, message: defaultMsg });
+                    }
+                    else {
+                        if (typeof ruleItem.rule === 'string') {
+                            rules = rules.concat(this._parseStringRule(ruleItem.rule));
+                        }
+                        else {
+                            rules.push({ rule: ruleItem.rule, message: ruleItem.message || defaultMsg });
+                        }
+                    }
+                }
+            }
+            else {
+                rules.push({ rule, message: defaultMsg });
+            }
+            parsedRules[schema.key] = rules;
+        }
+        this.types = types;
+        this.rules = parsedRules;
+    }
+    /**
+     * 进行数据验证，同时根据 type 进行数据类型转换
+     * @param data 待验证的数据
+     * @returns
+     */
+    validate(data) {
+        return new Promise((resolve, reject) => {
+            let errMsg = '';
+            let resData = {};
+            for (let key in this.rules) {
+                if ({}.hasOwnProperty.call(this.rules, key)) {
+                    errMsg = this._validateRule(this.rules[key], data[key], data);
+                    if (errMsg === '') {
+                        resData[key] = this._conversionType(this.types[key], data[key]);
+                    }
+                    else {
+                        errMsg = errMsg.replace('%s', key);
+                        break;
+                    }
+                }
+            }
+            if (errMsg === '') {
+                resolve(resData);
+            }
+            else {
+                reject(new ValidateError(errMsg));
+            }
+        });
+    }
+    /**
+     * 只验证指定 key 的数据格式
+     * @param key   指定待验证的 key
+     * @param value 待验证的数据
+     */
+    validateKey(key, value) {
+        return new Promise((resolve, reject) => {
+            let keyRules = this.rules[key];
+            let errMsg = this._validateRule(keyRules, value, null);
+            if (errMsg === '') {
+                resolve(this._conversionType(this.types[key], value));
+            }
+            else {
+                errMsg = errMsg.replace('%s', key);
+                reject(new ValidateError(errMsg));
+            }
+        });
+    }
+    _conversionType(type, v) {
+        if (typeof type === 'function') {
+            return type(v);
+        }
+        else {
+            return typeFns[type](v);
+        }
+    }
+    _validateRule(rules, value, data) {
+        let errMsg = '';
+        for (let rule of rules) {
+            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 (!ruleFns.pattern(rule.rule, value)) {
+                    errMsg = rule.message;
+                }
+            }
+            if (errMsg !== '') {
+                break;
+            }
+        }
+        return errMsg;
+    }
+    _parseStringRule(rule) {
+        let rules = [];
+        let trule = rule.split('|');
+        for (let r of trule) {
+            let message = defaultMsg;
+            let rrule;
+            let sameKey;
+            if (ruleRegexs.same.test(r)) {
+                let m = r.match(ruleRegexs.same);
+                if (m != null) {
+                    rrule = ruleRegexs.same;
+                    sameKey = r.match(ruleRegexs.same)[1];
+                    message = defaultMsgs['same'];
+                }
+            }
+            else if (ruleRegexs.hasOwnProperty(r)) {
+                rrule = ruleRegexs[r];
+                message = defaultMsgs[r] || defaultMsg;
+            }
+            rules.push({ rule: rrule, message: message, sameKey });
+        }
+        return rules;
+    }
+}
+module.exports = Validator;

package/lib/validator_m.d.ts

@@ -0,0 +1,44 @@
+interface RuleItem {
+    rule: RegExp | ((v: any) => boolean);
+    message: string;
+    sameKey?: string;
+}
+/**
+ * 数据验证器，除了进行数据验证外，还可以同时进行数据转化
+ */
+declare class Validator {
+    rules: {
+        [index: string]: RuleItem[];
+    };
+    types: {
+        [index: string]: string | ((v: any) => void);
+    };
+    /**
+     * 构造数据验证转换器
+     * @param schemas 配置验证转换规则
+     */
+    constructor(schemas: {
+        key: string;
+        type?: string | ((v: any) => void);
+        rules: string | RegExp | ((v: any) => boolean) | (RegExp | string | ((v: any) => boolean) | {
+            rule: string | RegExp | ((v: any) => boolean);
+            message?: string;
+        })[];
+    }[]);
+    /**
+     * 进行数据验证，同时根据 type 进行数据类型转换
+     * @param data 待验证的数据
+     * @returns
+     */
+    validate<T>(data: any): Promise<unknown>;
+    /**
+     * 只验证指定 key 的数据格式
+     * @param key   指定待验证的 key
+     * @param value 待验证的数据
+     */
+    validateKey(key: string, value: any): Promise<unknown>;
+    private _conversionType;
+    private _validateRule;
+    private _parseStringRule;
+}
+export default Validator;

package/lib/validator_m.js

@@ -0,0 +1,215 @@
+/**
+ * 数据验证器
+ */
+// 默认的错误提示信息
+const defaultMsgs = {
+    mobile: '请输入正确的手机号',
+    same: '两次输入不一致',
+    required: '%s为必填字段',
+};
+const defaultMsg = '请输入正确的数据';
+// 允许的内置 type
+const validTypes = new Set(['string', 'boolean', 'number', 'float', 'int']);
+// 一些常用的验证正则
+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));
+    },
+};
+const typeFns = {
+    string(v) {
+        return String(v);
+    },
+    boolean(v) {
+        return Boolean(v);
+    },
+    number(v) {
+        return Number(v);
+    },
+    int(v) {
+        return parseInt(v, 10);
+    },
+    floag(v) {
+        return parseFloat(v);
+    },
+};
+class ValidateError extends Error {
+    constructor(msg) {
+        super(msg);
+        this.name = 'ValidateError';
+    }
+}
+/**
+ * 数据验证器，除了进行数据验证外，还可以同时进行数据转化
+ */
+class Validator {
+    /**
+     * 构造数据验证转换器
+     * @param schemas 配置验证转换规则
+     */
+    constructor(schemas) {
+        let parsedRules = {};
+        let types = {};
+        for (let schema of schemas) {
+            // 解析 types 用于进行数据类型转换
+            if (typeof schema.type === 'function') {
+                types[schema.key] = schema.type;
+            }
+            else {
+                types[schema.key] = validTypes.has(schema.type || '') ? schema.type : 'string';
+            }
+            // 解析规则
+            let rules = [];
+            let rule = schema.rules;
+            if (typeof rule === 'string') {
+                rules = rules.concat(this._parseStringRule(rule));
+            }
+            else if (rule instanceof Array) {
+                for (let ruleItem of rule) {
+                    if (typeof ruleItem === 'string') {
+                        rules = rules.concat(this._parseStringRule(ruleItem));
+                    }
+                    else if (ruleItem instanceof RegExp || typeof ruleItem === 'function') {
+                        rules.push({ rule: ruleItem, message: defaultMsg });
+                    }
+                    else {
+                        if (typeof ruleItem.rule === 'string') {
+                            rules = rules.concat(this._parseStringRule(ruleItem.rule));
+                        }
+                        else {
+                            rules.push({ rule: ruleItem.rule, message: ruleItem.message || defaultMsg });
+                        }
+                    }
+                }
+            }
+            else {
+                rules.push({ rule, message: defaultMsg });
+            }
+            parsedRules[schema.key] = rules;
+        }
+        this.types = types;
+        this.rules = parsedRules;
+    }
+    /**
+     * 进行数据验证，同时根据 type 进行数据类型转换
+     * @param data 待验证的数据
+     * @returns
+     */
+    validate(data) {
+        return new Promise((resolve, reject) => {
+            let errMsg = '';
+            let resData = {};
+            for (let key in this.rules) {
+                if ({}.hasOwnProperty.call(this.rules, key)) {
+                    errMsg = this._validateRule(this.rules[key], data[key], data);
+                    if (errMsg === '') {
+                        resData[key] = this._conversionType(this.types[key], data[key]);
+                    }
+                    else {
+                        errMsg = errMsg.replace('%s', key);
+                        break;
+                    }
+                }
+            }
+            if (errMsg === '') {
+                resolve(resData);
+            }
+            else {
+                reject(new ValidateError(errMsg));
+            }
+        });
+    }
+    /**
+     * 只验证指定 key 的数据格式
+     * @param key   指定待验证的 key
+     * @param value 待验证的数据
+     */
+    validateKey(key, value) {
+        return new Promise((resolve, reject) => {
+            let keyRules = this.rules[key];
+            let errMsg = this._validateRule(keyRules, value, null);
+            if (errMsg === '') {
+                resolve(this._conversionType(this.types[key], value));
+            }
+            else {
+                errMsg = errMsg.replace('%s', key);
+                reject(new ValidateError(errMsg));
+            }
+        });
+    }
+    _conversionType(type, v) {
+        if (typeof type === 'function') {
+            return type(v);
+        }
+        else {
+            return typeFns[type](v);
+        }
+    }
+    _validateRule(rules, value, data) {
+        let errMsg = '';
+        for (let rule of rules) {
+            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 (!ruleFns.pattern(rule.rule, value)) {
+                    errMsg = rule.message;
+                }
+            }
+            if (errMsg !== '') {
+                break;
+            }
+        }
+        return errMsg;
+    }
+    _parseStringRule(rule) {
+        let rules = [];
+        let trule = rule.split('|');
+        for (let r of trule) {
+            let message = defaultMsg;
+            let rrule;
+            let sameKey;
+            if (ruleRegexs.same.test(r)) {
+                let m = r.match(ruleRegexs.same);
+                if (m != null) {
+                    rrule = ruleRegexs.same;
+                    sameKey = r.match(ruleRegexs.same)[1];
+                    message = defaultMsgs['same'];
+                }
+            }
+            else if (ruleRegexs.hasOwnProperty(r)) {
+                rrule = ruleRegexs[r];
+                message = defaultMsgs[r] || defaultMsg;
+            }
+            rules.push({ rule: rrule, message: message, sameKey });
+        }
+        return rules;
+    }
+}
+export default Validator;

package/package.json

@@ -5,7 +5,7 @@
   "module": "lib/index_m.js",
   "types": "lib/index.d.ts",
   "browser": "lib/index_m.js",
-  "version": "0.1.5",
+  "version": "0.2.1",
   "repository": {
     "type": "git",
     "url": "git+https//gitee.com/towardly/ph.git",