baja-lite 1.3.3 → 1.3.4

package/index.d.ts

@@ -5,7 +5,6 @@ export * from './fn.js';
 export * from './list.js';
 export * from './math.js';
 export * from './object.js';
-export * from './set-ex.js';
 export * from './snowflake.js';
 export * from './sql.js';
 export * from './sqlite.js';

package/index.js

@@ -5,7 +5,6 @@ export * from './fn.js';
 export * from './list.js';
 export * from './math.js';
 export * from './object.js';
-export * from './set-ex.js';
 export * from './snowflake.js';
 export * from './sql.js';
 export * from './sqlite.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "baja-lite",
-  "version": "1.3.3",
+  "version": "1.3.4",
   "description": "some util for self",
   "homepage": "https://github.com/void-soul/util-man",
   "repository": {

package/validate.js

@@ -337,7 +337,7 @@ export class ValidateItem {
         return [{
                 validator: (_rule, value, callback, _source, _op) => {
                     this.value = value;
-                    runSequentially(Object.keys(this.props).filter(key => this[key] && typeof this[key] === 'function').map(key => this[key])).catch(error => callback(error)).then(() => callback());
+                    runSequentially(Object.keys(this.props).filter(key => this.props[key] !== undefined && this[key] && typeof this[key] === 'function').map(key => () => this[key]())).catch(error => callback(error)).then(() => callback());
                 }, trigger: this.props.mkTrigger
             }];
     }
@@ -346,14 +346,14 @@ export class ValidateItem {
                 required: this.props.required,
                 validator: (val) => {
                     this.value = val;
-                    return runSequentially(Object.keys(this.props).filter(key => this[key] && typeof this[key] === 'function').map(key => this[key]));
+                    return runSequentially(Object.keys(this.props).filter(key => this.props[key] !== undefined && this[key] && typeof this[key] === 'function').map(key => () => this[key]()));
                 }
             }];
     }
     async service() {
         this.value = this.getProp(this.props.mkRealProp || this.props.prop);
         for (const key in this.props) {
-            if (this[key] && typeof this[key] === 'function') {
+            if (this.props[key] !== undefined && this[key] && typeof this[key] === 'function') {
                 await this[key]();
             }
         }

package/set-ex.d.ts

@@ -1,198 +0,0 @@
-export declare class SetEx<T> extends Set {
-    private _key;
-    private _onExist1?;
-    private _onNotExist1?;
-    private _replaceIfExits1;
-    private _onExist2?;
-    private _onNotExist2?;
-    private _replaceIfExits2;
-    private _map;
-    /**
-     * @param key 识别是否存在的对象的属性名
-     * @param onExist 当存在时作何操作? oldData/newData 哪个将添加到set,由replaceItemWhenExits决定,默认是oldData生效
-     * @param onNotExist 当不存在时作何操作?
-     * @param replaceWhenExits 当存在时是否覆盖？
-     * @param values 初始数组
-     */
-    constructor(option: {
-        key: keyof T;
-        /** add&addAll触发 */
-        onExist1?: (oldData: T, newData: T) => void;
-        /** add&addAll触发 */
-        onNotExist1?: (newData: T) => void;
-        /** add&addAll触发 */
-        replaceIfExits1?: boolean;
-        /** add2&addAll2触发 */
-        onExist2?: (oldData: T, newData: T) => void;
-        /** add2&addAll2触发 */
-        onNotExist2?: (newData: T) => void;
-        /** add2&addAll2触发 */
-        replaceIfExits2?: boolean;
-        values?: ReadonlyArray<T> | null;
-    });
-    /**
-     *
-     * 添加返回
-     * @param {T} value
-     * @returns {this} 当前对象
-     */
-    add(value: T): this;
-    /**
-     * 批量添加
-     * @param values
-     * @returns 当前对象
-     */
-    addAll(...values: T[]): this;
-    /**
-     *
-     * 添加
-     * @param {T} value
-     * @returns {T} 添加成功的对象:可能是新加入集合的，也可能是原本存在的
-     */
-    add2(value: T): T;
-    /**
-     *
-     * 添加并返回添加成功的对象:可能是新加入集合的，也可能是原本存在的
-     * @param {T} values
-     * @returns {T}
-     */
-    addAll2(values: T[]): T[];
-    /**
-     * 用key找到匹配的第一个对象
-     * @param {*} key 这是对象的关键属性,而非对象
-     * @returns {(T | null)}
-     */
-    find(key: T[keyof T]): T | null;
-    /**
-     * 用key找到匹配的所有对象
-     * @param {*} key 这是对象的关键属性,而非对象
-     * @returns {T[]}
-     */
-    findAll(key: T[keyof T]): T[];
-    /**
-     *
-     * 用函数回调找到匹配的第一个对象
-     * @param {(item: T) => boolean} fn
-     * @returns {T[]}
-     */
-    filter(fn: (item: T) => boolean): T | null;
-    /**
-     *
-     * 用函数回调找到匹配的所有对象
-     * @param {(item: T) => boolean} fn
-     * @returns {T[]}
-     */
-    filterAll(fn: (item: T) => boolean): T[];
-    /**
-     *
-     * 是否存在key对应的对象
-     * @param {*} value 这是对象的关键属性,而非对象
-     * @returns {boolean}
-     */
-    has(key: T[keyof T]): boolean;
-    /**
-     * 转为数组
-     * @param param0
-     * @returns
-     */
-    toArray({ sort, each, filter, map }?: {
-        sort?: (a: T, b: T) => number;
-        each?: (a: T) => void;
-        filter?: (a: T) => boolean;
-        map?: (a: T) => T;
-    }): T[];
-    /**
-     * 转为JSON对象
-     * @param key
-     * @param value
-     * @param param2
-     * @returns
-     */
-    toJSON<L = T>(key: keyof T, value?: keyof T, { sort, each, filter, map }?: {
-        sort?: (a: T, b: T) => number;
-        each?: (a: T) => void;
-        filter?: (a: T) => boolean;
-        map?: (a: T) => T;
-    }): {
-        [k: string]: L;
-    };
-    /**
-     *
-     * 删除key对应的对象
-     * @param {*} _key 这是对象的关键属性,而非对象
-     * @returns {boolean}
-     */
-    delete(_key: T[keyof T]): boolean;
-    /**
-     *
-     * 重置
-     * @param {keyof T} key
-     * @param {(oldData: T, newData: T) => void} [onExist]
-     * @param {boolean} [replaceWhenExits=false]
-     */
-    reset(option: {
-        key?: keyof T;
-        /** add&addAll触发 */
-        onExist1?: (oldData: T, newData: T) => void;
-        /** add&addAll触发 */
-        onNotExist1?: (newData: T) => void;
-        /** add&addAll触发 */
-        replaceIfExits1?: boolean;
-        /** add2&addAll2触发 */
-        onExist2?: (oldData: T, newData: T) => void;
-        /** add2&addAll2触发 */
-        onNotExist2?: (newData: T) => void;
-        /** add2&addAll2触发 */
-        replaceIfExits2?: boolean;
-        values?: ReadonlyArray<T> | null;
-    }): this;
-    /**
-     *
-     * @param param0 转为JSON对象，value可能是数组
-     * @returns
-     */
-    toJSONArray({ sort, each, filter, map }?: {
-        sort?: (a: T, b: T) => number;
-        each?: (a: T) => void;
-        filter?: (a: T) => boolean;
-        map?: (a: T) => T;
-    }): {
-        [k: string]: T[keyof T][];
-    };
-    /**
-     * 转为hot-table支持的数组
-     * @param param0
-     * @param keys
-     * @returns
-     */
-    toDataGrid({ sort, each, filter, map }?: {
-        sort?: (a: T, b: T) => number;
-        each?: (a: T) => void;
-        filter?: (a: T) => boolean;
-        map?: (a: T) => T;
-    }, ...keys: (keyof T)[]): (keyof T | T[keyof T])[][];
-    /**
-     * 转为饼图支持的数组
-     * @param param0
-     * @param keys
-     * @returns
-     */
-    toPieGrid({ sort, each, filter, map }?: {
-        sort?: (a: T, b: T) => number;
-        each?: (a: T) => void;
-        filter?: (a: T) => boolean;
-        map?: (a: T) => T;
-    }, ...keys: (keyof T)[]): {
-        [k: string]: {
-            value: T[keyof T];
-            name: T[keyof T];
-        }[];
-    };
-    set onExist1(onExist1: ((oldData: T, newData: T) => void) | undefined);
-    set onExist2(onExist2: ((oldData: T, newData: T) => void) | undefined);
-    set onNotExist1(onNotExist1: ((newData: T) => void) | undefined);
-    set onNotExist2(onNotExist2: ((newData: T) => void) | undefined);
-    set replaceIfExits1(replaceIfExits1: boolean);
-    set replaceIfExits2(replaceIfExits2: boolean);
-    set key(key: keyof T);
-}

package/set-ex.js

@@ -1,338 +0,0 @@
-import iterate from "iterare";
-export class SetEx extends Set {
-    /**
-     * @param key 识别是否存在的对象的属性名
-     * @param onExist 当存在时作何操作? oldData/newData 哪个将添加到set,由replaceItemWhenExits决定,默认是oldData生效
-     * @param onNotExist 当不存在时作何操作?
-     * @param replaceWhenExits 当存在时是否覆盖？
-     * @param values 初始数组
-     */
-    constructor(option) {
-        super();
-        this._map = new Map();
-        this._key = option.key;
-        this._onExist1 = option.onExist1;
-        this._onNotExist1 = option.onNotExist1;
-        this._replaceIfExits1 = option.replaceIfExits1 === true;
-        this._onExist2 = option.onExist2;
-        this._onNotExist2 = option.onNotExist2;
-        this._replaceIfExits2 = option.replaceIfExits2 === true;
-        if (option.values) {
-            this.addAll(...option.values);
-        }
-    }
-    /**
-     *
-     * 添加返回
-     * @param {T} value
-     * @returns {this} 当前对象
-     */
-    add(value) {
-        let flag = false;
-        const key = value[this._key];
-        const item = this._map.get(key);
-        if (item) {
-            flag = true;
-            if (this._onExist1) {
-                this._onExist1(item, value);
-            }
-            if (this._replaceIfExits1 === true) {
-                super.delete(item);
-                this._map.delete(key);
-                flag = false;
-            }
-        }
-        if (flag === false) {
-            super.add(value);
-            this._map.set(key, value);
-            if (this._onNotExist1) {
-                this._onNotExist1(value);
-            }
-        }
-        return this;
-    }
-    /**
-     * 批量添加
-     * @param values
-     * @returns 当前对象
-     */
-    addAll(...values) {
-        for (const value of values) {
-            this.add(value);
-        }
-        return this;
-    }
-    /**
-     *
-     * 添加
-     * @param {T} value
-     * @returns {T} 添加成功的对象:可能是新加入集合的，也可能是原本存在的
-     */
-    add2(value) {
-        let flag = false;
-        const key = value[this._key];
-        const item = this._map.get(key);
-        let tmp = value;
-        if (item) {
-            flag = true;
-            if (this._onExist2) {
-                this._onExist2(item, value);
-            }
-            if (this._replaceIfExits2 === true) {
-                super.delete(value);
-                this._map.delete(key);
-                flag = false;
-            }
-            else {
-                tmp = item;
-            }
-        }
-        if (flag === false) {
-            super.add(value);
-            this._map.set(key, value);
-            if (this._onNotExist2) {
-                this._onNotExist2(value);
-            }
-        }
-        return tmp;
-    }
-    /**
-     *
-     * 添加并返回添加成功的对象:可能是新加入集合的，也可能是原本存在的
-     * @param {T} values
-     * @returns {T}
-     */
-    addAll2(values) {
-        const result = [];
-        for (const value of values) {
-            result.push(this.add2(value));
-        }
-        return result;
-    }
-    /**
-     * 用key找到匹配的第一个对象
-     * @param {*} key 这是对象的关键属性,而非对象
-     * @returns {(T | null)}
-     */
-    find(key) {
-        return this._map.get(key) ?? null;
-    }
-    /**
-     * 用key找到匹配的所有对象
-     * @param {*} key 这是对象的关键属性,而非对象
-     * @returns {T[]}
-     */
-    findAll(key) {
-        return iterate(key).map(k => this._map.get(k)).filter(v => v !== undefined).toArray();
-    }
-    /**
-     *
-     * 用函数回调找到匹配的第一个对象
-     * @param {(item: T) => boolean} fn
-     * @returns {T[]}
-     */
-    filter(fn) {
-        for (const item of this) {
-            if (fn(item) === true) {
-                return item;
-            }
-        }
-        return null;
-    }
-    /**
-     *
-     * 用函数回调找到匹配的所有对象
-     * @param {(item: T) => boolean} fn
-     * @returns {T[]}
-     */
-    filterAll(fn) {
-        const res = new Array();
-        this.forEach((item) => {
-            if (fn(item) === true) {
-                res.push(item);
-            }
-        });
-        return res;
-    }
-    /**
-     *
-     * 是否存在key对应的对象
-     * @param {*} value 这是对象的关键属性,而非对象
-     * @returns {boolean}
-     */
-    has(key) {
-        return this._map.has(key);
-    }
-    /**
-     * 转为数组
-     * @param param0
-     * @returns
-     */
-    toArray({ sort, each, filter, map } = {}) {
-        let list = Array.from(this);
-        if (filter) {
-            list = list.filter(filter);
-        }
-        if (sort) {
-            list.sort(sort);
-        }
-        if (each) {
-            list.forEach(each);
-        }
-        if (map) {
-            list = list.map(map);
-        }
-        return list;
-    }
-    /**
-     * 转为JSON对象
-     * @param key
-     * @param value
-     * @param param2
-     * @returns
-     */
-    toJSON(key, value, { sort, each, filter, map } = {}) {
-        return Object.fromEntries(this.toArray({ sort, each, filter, map }).map(i => [i[key], value ? i[value] : i]));
-    }
-    /**
-     *
-     * 删除key对应的对象
-     * @param {*} _key 这是对象的关键属性,而非对象
-     * @returns {boolean}
-     */
-    delete(_key) {
-        const key = _key;
-        const item = this._map.get(key);
-        if (item) {
-            super.delete(item);
-            this._map.delete(key);
-            return true;
-        }
-        return false;
-    }
-    /**
-     *
-     * 重置
-     * @param {keyof T} key
-     * @param {(oldData: T, newData: T) => void} [onExist]
-     * @param {boolean} [replaceWhenExits=false]
-     */
-    reset(option) {
-        this.clear();
-        this._map.clear();
-        if (option.key) {
-            this._key = option.key;
-        }
-        if (option.onExist1) {
-            this._onExist1 = option.onExist1;
-        }
-        if (option.onNotExist1) {
-            this._onNotExist1 = option.onNotExist1;
-        }
-        if (option.replaceIfExits1) {
-            this._replaceIfExits1 = option.replaceIfExits1;
-        }
-        if (option.onExist2) {
-            this._onExist2 = option.onExist2;
-        }
-        if (option.onNotExist2) {
-            this._onNotExist2 = option.onNotExist2;
-        }
-        if (option.replaceIfExits2) {
-            this._replaceIfExits2 = option.replaceIfExits2;
-        }
-        if (option.values) {
-            this.addAll(...option.values);
-        }
-        return this;
-    }
-    /**
-     *
-     * @param param0 转为JSON对象，value可能是数组
-     * @returns
-     */
-    toJSONArray({ sort, each, filter, map } = {}) {
-        const result = {};
-        const list = this.toArray({ sort, each, filter, map });
-        for (const item of list) {
-            for (const key in item) {
-                if (!result[key]) {
-                    result[key] = [];
-                }
-                result[key].push(item[key]);
-            }
-        }
-        return result;
-    }
-    /**
-     * 转为hot-table支持的数组
-     * @param param0
-     * @param keys
-     * @returns
-     */
-    toDataGrid({ sort, each, filter, map } = {}, ...keys) {
-        if (this.size === 0) {
-            return [];
-        }
-        if (keys.length === 0) {
-            keys = Object.keys(this.values().next().value);
-        }
-        const result = [keys];
-        const list = this.toArray({ sort, each, filter, map });
-        for (const item of list) {
-            const one = [];
-            for (const key of keys) {
-                one.push(item[key]);
-            }
-            result.push(one);
-        }
-        return result;
-    }
-    /**
-     * 转为饼图支持的数组
-     * @param param0
-     * @param keys
-     * @returns
-     */
-    toPieGrid({ sort, each, filter, map } = {}, ...keys) {
-        if (this.size === 0) {
-            return {};
-        }
-        if (keys.length === 0) {
-            keys = Object.keys(this.values().next().value);
-        }
-        const result = {};
-        const list = this.toArray({ sort, each, filter, map });
-        for (const item of list) {
-            const name = item[this._key];
-            for (const key in item) {
-                if (!result[key]) {
-                    result[key] = [];
-                }
-                result[key].push({ name, value: item[key] });
-            }
-        }
-        return result;
-    }
-    set onExist1(onExist1) {
-        this._onExist1 = onExist1;
-    }
-    set onExist2(onExist2) {
-        this._onExist2 = onExist2;
-    }
-    set onNotExist1(onNotExist1) {
-        this._onNotExist1 = onNotExist1;
-    }
-    set onNotExist2(onNotExist2) {
-        this._onNotExist2 = onNotExist2;
-    }
-    set replaceIfExits1(replaceIfExits1) {
-        this._replaceIfExits1 = replaceIfExits1;
-    }
-    set replaceIfExits2(replaceIfExits2) {
-        this._replaceIfExits2 = replaceIfExits2;
-    }
-    set key(key) {
-        this._key = key;
-    }
-}