ph-utils 0.18.0 → 0.19.0

package/lib/src/validator.js

@@ -0,0 +1,238 @@
+/**
+ * 数据验证器
+ */
+// 默认的错误提示信息
+const defaultMsgs = {
+    mobile: "请输入正确的手机号",
+    same: "两次输入不一致",
+    required: "%s为必填字段",
+};
+const defaultMsg = "请输入正确的数据";
+// 一些常用的验证正则
+const ruleRegexs = {
+    /** 验证跟其余数据相等的正则，一般用于验证再次输入密码 */
+    same: /^same:(.+)$/i,
+    /** 验证手机号的正则表达式 */
+    mobile: /^1[3456789]\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 {
+    constructor(detail, key, message) {
+        super(message);
+        this.name = "ValidateError";
+        this.key = key;
+        this.detail = detail;
+    }
+}
+/**
+ * 数据验证器
+ */
+class Validator {
+    /**
+     * 构造数据验证转换器
+     *
+     * See {@link https://gitee.com/towardly/ph/wikis/utils/validator|Validator文档}.
+     *
+     * @param schemas 配置验证转换规则
+     *
+     * @example
+     *
+     * const validator = new Validator([
+     *  { key: 'mobile', rules: ['required', 'mobile'] },
+     *  { key: 'code': rules: /^\d{6}$/, message: '请输入正确的验证码' },
+     *  { key: 'confirmPassword', rules: ['required', 'same:password'] }
+     * ])
+     * // 验证某一个字段
+     * validator.validateKey().then(res => {})
+     */
+    constructor(schemas) {
+        this.rules = {};
+        this.addSchemas(schemas);
+    }
+    addSchemas(schemas) {
+        for (let schema of schemas) {
+            this.rules[schema.key] = this._parseSchemaRules(schema);
+        }
+    }
+    addSchema(schema) {
+        this.rules[schema.key] = this._parseSchemaRules(schema);
+    }
+    /**
+     * 进行数据验证
+     * @param data 待验证的数据
+     * @param all 是否全部验证, false - 只要验证错误一个则停止验证
+     * @returns
+     */
+    async validate(data, all = false) {
+        return new Promise((resolve, reject) => {
+            const detail = {};
+            let currentKey = undefined;
+            let currentMessage = undefined;
+            for (let key in this.rules) {
+                let errMsg = this._validateRule(this.rules[key], data[key], data);
+                if (errMsg !== "") {
+                    errMsg = errMsg.replace("%s", key);
+                    detail[key] = errMsg;
+                    currentKey = key;
+                    currentMessage = errMsg;
+                    if (all)
+                        break;
+                }
+            }
+            if (currentKey == null) {
+                resolve(true);
+            }
+            else {
+                reject(new ValidateError(detail, currentKey, currentMessage));
+            }
+        });
+    }
+    /**
+     * 只验证指定 key 的数据格式
+     * @param key   指定待验证的 key
+     * @param value 待验证的数据
+     * @param data 原始数据，当验证确认密码时需要使用
+     */
+    async validateKey(key, value, data) {
+        return new Promise((resolve, reject) => {
+            let keyRules = this.rules[key];
+            if (keyRules == null) {
+                resolve({ key, value });
+                return;
+            }
+            let errMsg = this._validateRule(keyRules, value, data);
+            if (errMsg !== "") {
+                errMsg = errMsg.replace("%s", key);
+                reject(new ValidateError({ [key]: errMsg }, key, errMsg));
+            }
+            else {
+                resolve({ key, value });
+            }
+        });
+    }
+    _validateRule(rules, value, data) {
+        let errMsg = "";
+        for (let rule of rules) {
+            if (!rule)
+                continue;
+            // 如果数据为空，则判断是否是必填
+            if (rule.rule === "required") {
+                if (value == null || !ruleFns.pattern(ruleRegexs.required, value)) {
+                    errMsg = rule.message;
+                }
+            }
+            else 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 && !ruleFns.pattern(rule.rule, value)) {
+                    errMsg = rule.message;
+                }
+            }
+            if (errMsg !== "") {
+                break;
+            }
+        }
+        return errMsg;
+    }
+    _parseSchemaRules(schema) {
+        // 解析规则
+        let rules = [];
+        let rule = schema.rules;
+        if (schema.required === true) {
+            rules.push(...this._parseStringRule("required", schema.message));
+        }
+        if (rule != null) {
+            if (typeof rule === "string") {
+                rules.push(...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 {
+                        const emessage = ruleItem.message || schema.message || defaultMsg;
+                        if (typeof ruleItem.rule === "string") {
+                            rules.push(...this._parseStringRule(ruleItem.rule, emessage));
+                        }
+                        else {
+                            rules.push({
+                                rule: ruleItem.rule,
+                                message: emessage,
+                            });
+                        }
+                    }
+                }
+            }
+            else {
+                rules.push({ rule, message: defaultMsg });
+            }
+        }
+        return rules;
+    }
+    _parseStringRule(rule, ruleErrMsg) {
+        let rules = [];
+        let trule = rule.split("|");
+        for (let r of trule) {
+            let message = ruleErrMsg;
+            let rrule = null;
+            let sameKey;
+            if (rule === "required") {
+                rrule = "required";
+                message = message || ruleErrMsg || defaultMsgs.required;
+            }
+            else 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 (Object.hasOwn(ruleRegexs, r)) {
+                rrule = ruleRegexs[r];
+                message = message || defaultMsgs[r];
+            }
+            if (rrule) {
+                rules.push({ rule: rrule, message: message, sameKey });
+            }
+        }
+        return rules;
+    }
+}
+export default Validator;

package/lib/src/web.d.ts

@@ -0,0 +1,30 @@
+/**
+ * 解析 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;
+};
+/**
+ * 函数节流 - 每隔单位时间，只执行一次
+ * @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;
+    cancel(): void;
+};

package/lib/src/web.js

@@ -0,0 +1,100 @@
+/**
+ * web(浏览器) 端工具类
+ */
+import { isBlank } from "./index.js";
+/**
+ * 解析 Form 表单中的 input 元素的数据为 JSON 格式，key: input-name；value: input-value
+ * @param form {object} Form 节点对象
+ */
+export const formJson = function (form) {
+    let elems = form.elements;
+    let value = {};
+    for (let i = 0, len = elems.length; i < len; i++) {
+        let item = elems[i];
+        if (!isBlank(item.name)) {
+            if ((item.tagName === "INPUT" || item.tagName === "TEXTAREA") &&
+                !isBlank(item.value)) {
+                let dataType = item.getAttribute("data-type");
+                if (dataType === "number") {
+                    value[item.name] = Number(item.value);
+                }
+                else {
+                    value[item.name] = item.value;
+                }
+            }
+            else if (item.tagName === "SELECT") {
+                value[item.name] = item.options[item.selectedIndex].value;
+            }
+        }
+    }
+    return value;
+};
+/**
+ * 获取 url query 参数 (get 请求的参数)
+ * @param search 如果是 React 应用就需要传递 useLocation().search
+ * @returns
+ */
+export function query(search) {
+    if (isBlank(search)) {
+        search = location.search;
+    }
+    const searchParams = new URLSearchParams(search);
+    let query = {};
+    for (const [key, value] of searchParams) {
+        let oldValue = query[key];
+        let newValue = value;
+        if (oldValue != null) {
+            if (oldValue instanceof Array) {
+                oldValue.push(value);
+                newValue = oldValue;
+            }
+            else {
+                newValue = [value, oldValue];
+            }
+        }
+        query[key] = newValue;
+    }
+    return query;
+}
+/**
+ * 函数节流 - 每隔单位时间，只执行一次
+ * @param cb    待节流的函数
+ * @param wait  间隔时间
+ * @returns
+ */
+export function throttle(fn, wait = 500) {
+    // 上一次的请求时间
+    let last = 0;
+    return (...args) => {
+        // 当前时间戳
+        const now = Date.now();
+        if (now - last > wait) {
+            fn(...args);
+            last = now;
+        }
+    };
+}
+/**
+ * 函数防抖 - 当重复触发某一个行为（事件时），只执行最后一次触发
+ * @param fn        防抖函数
+ * @param interval  间隔时间段
+ * @returns
+ */
+export function debounce(fn, interval = 500) {
+    let _t;
+    const handle = (...args) => {
+        if (_t)
+            clearTimeout(_t);
+        _t = setTimeout(() => {
+            //@ts-ignore
+            fn.apply(this, args);
+        }, interval);
+    };
+    handle.cancel = function () {
+        if (_t) {
+            clearTimeout(_t);
+            _t = null;
+        }
+    };
+    return handle;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ph-utils",
-  "version": "0.18.0",
+  "version": "0.19.0",
   "description": "js 开发工具集，前后端都可以使用(commonjs和es module)",
   "keywords": [
     "date",
@@ -96,4 +96,4 @@
     "@types/node": "^22.8.2",
     "typescript": "^5.6.3"
   }
-}
+}