baja-lite 1.0.0

package/cjs/object.js

@@ -0,0 +1,212 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arraySplit = exports.array2map = exports.mixList = exports.mixArray = exports.fixEmptyPrototy = exports.coverComplexBean = exports.createBeanFromArray = exports.emptyBean = exports.convertBeans = exports.convertBean = exports.copyBean = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+/**
+ * 对象对象（等同与convertBean）
+ * 仅会将classType有的属性进行转换
+ * 相当与一次属性过滤
+ * @param source
+ * @param classType
+ */
+const copyBean = (source, classType) => {
+    const result = {};
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+    Object.keys(classType).forEach((key) => {
+        result[key] =
+            source[key] !== undefined ? source[key] : (result[key] = null);
+    });
+    return result;
+};
+exports.copyBean = copyBean;
+/**
+ * 对象转换（等同与copyBean）
+ * 仅会将classType有的属性进行转换
+ * 相当与一次属性过滤
+ * @param source
+ * @param classType
+ */
+exports.convertBean = exports.copyBean;
+/**
+ * 批量对象转换（等同与copyBean）
+ * 仅会将classType有的属性进行转换
+ * 相当与一次属性过滤
+ * @param source
+ * @param classType
+ */
+const convertBeans = (source, classType, cb) => {
+    const result = new Array();
+    for (const bean of source) {
+        const data = (0, exports.convertBean)(bean, classType);
+        if (cb) {
+            cb(data, bean);
+        }
+        result.push(data);
+    }
+    return result;
+};
+exports.convertBeans = convertBeans;
+/**
+ * 创建一个空对象
+ * 其内各属性都是null
+ * @param classType
+ */
+const emptyBean = (classType) => {
+    const target = {};
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+    Object.keys(classType).forEach((key) => {
+        target[key] = null;
+    });
+    return target;
+};
+exports.emptyBean = emptyBean;
+/**
+ * 将一个json数组提取为一个json对象
+ * @param source 源数组
+ * @param key 作为新对象的key的字段
+ * @param value 作为新对象value的字段,不传则将自身为value
+ */
+const createBeanFromArray = (source, key, value) => {
+    const result = {};
+    if (value) {
+        source.forEach((item) => {
+            if (item[key]) {
+                result[`${item[key]}`] = item[value];
+            }
+        });
+    }
+    else {
+        source.forEach((item) => {
+            if (item[key]) {
+                result[`${item[key]}`] = item;
+            }
+        });
+    }
+    return result;
+};
+exports.createBeanFromArray = createBeanFromArray;
+/**
+ * 转换复合对象为指定bean
+ * @param source
+ * @param classType
+ */
+const coverComplexBean = (source, classType) => {
+    const result = {};
+    const arrayData = {};
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+    for (const [key, value] of Object.entries(source)) {
+        if (lodash_1.default.isArray(value)) {
+            arrayData[key] = value;
+        }
+        else if (lodash_1.default.isObject(value)) {
+            lodash_1.default.assign(result, value);
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    return {
+        data: (0, exports.convertBean)(result, classType),
+        array: arrayData
+    };
+};
+exports.coverComplexBean = coverComplexBean;
+/**
+ * 将目标对象中为空的字段替换为source中对应key的值或者函数返回值
+ * @param target
+ * @param source
+ */
+const fixEmptyPrototy = async (target, source) => {
+    for (const [key, fn] of Object.entries(source)) {
+        if (!target[key]) {
+            if (typeof fn === 'function') {
+                target[key] = await fn();
+            }
+            else {
+                target[key] = fn;
+            }
+        }
+    }
+};
+exports.fixEmptyPrototy = fixEmptyPrototy;
+const mixArray = (array, key, defKey) => {
+    const obj = array.map(item => item[key]);
+    const result = {};
+    for (const i of obj) {
+        let ki = '';
+        if (i !== undefined && i !== null) {
+            ki = `${i}`;
+        }
+        else if (defKey) {
+            ki = defKey;
+        }
+        if (!result[ki]) {
+            result[ki] = 0;
+        }
+        result[ki]++;
+    }
+    return result;
+};
+exports.mixArray = mixArray;
+const mixList = (array, key, value, defKey) => {
+    const result = {};
+    for (const i of array) {
+        let ki = '';
+        if (i[key] !== undefined && i[key] !== null) {
+            ki = `${i[key]}`;
+        }
+        else if (defKey) {
+            ki = defKey;
+        }
+        if (!result[ki]) {
+            result[ki] = [];
+        }
+        if (value) {
+            result[ki].push(i[value]);
+        }
+        else {
+            result[ki].push(i);
+        }
+    }
+    return result;
+};
+exports.mixList = mixList;
+const array2map = (array, v) => {
+    const ot = {};
+    for (const item of array) {
+        ot[item] = v;
+    }
+    return ot;
+};
+exports.array2map = array2map;
+/**
+ * 数组分割
+ * @param datas
+ * @param config(二选一) everyLength=每组个数(最后一组可能不足次数), groupCount=拆分几组
+ * @returns T[][]
+ */
+const arraySplit = (datas, { everyLength = 0, groupCount = 0 } = {}) => {
+    if (groupCount > 0) {
+        everyLength = Math.floor(datas.length / groupCount + 0.9);
+        const result = [];
+        for (let i = 0; i < groupCount; i++) {
+            result.push(datas.slice(i * everyLength, (i + 1) * everyLength));
+        }
+        return result;
+    }
+    else if (everyLength > 0) {
+        groupCount = Math.ceil(datas.length / everyLength);
+        const result = [];
+        for (let i = 0; i < groupCount; i++) {
+            result.push(datas.slice(i * everyLength, (i + 1) * everyLength));
+        }
+        return result;
+    }
+    else {
+        throw new Error('参数错误!');
+    }
+};
+exports.arraySplit = arraySplit;

package/cjs/set-ex.d.ts

@@ -0,0 +1,171 @@
+export declare class SetEx<T> extends Set {
+    private uniqueKey;
+    private whenOnExist?;
+    private whenOnNotExist?;
+    private replaceItemWhenExits;
+    /**
+     * @param key 识别是否存在的对象的属性名
+     * @param onExist 当存在时作何操作? oldData/newData 哪个将添加到set,由replaceItemWhenExits决定,默认是oldData生效
+     * @param onNotExist 当不存在时作何操作?
+     * @param replaceWhenExits 当存在时是否覆盖？
+     * @param values 初始数组
+     */
+    constructor(key: keyof T | {
+        key: keyof T;
+        onExist?: (oldData: T, newData: T) => void;
+        onNotExist?: (newData: T) => void;
+        replaceWhenExits?: boolean;
+        values?: ReadonlyArray<T> | null;
+    }, onExist?: (oldData: T, newData: T) => void, replaceWhenExits?: boolean, values?: ReadonlyArray<T> | null, onNotExist?: (newData: T) => void);
+    /**
+     *
+     * 添加返回
+     * @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 {*} value 这是对象的关键属性,而非对象
+     * @returns {(T | null)}
+     */
+    find(value: T[keyof T]): T | null;
+    /**
+     * 用key找到匹配的所有对象
+     * @param {*} value 这是对象的关键属性,而非对象
+     * @returns {T[]}
+     */
+    findAll(value: 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(value: 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 {*} value 这是对象的关键属性,而非对象
+     * @returns {boolean}
+     */
+    delete(value: T[keyof T]): boolean;
+    /**
+     *
+     * 重置
+     * @param {keyof T} key
+     * @param {(oldData: T, newData: T) => void} [onExist]
+     * @param {boolean} [replaceWhenExits=false]
+     */
+    reset({ key, onExist, onNotExist, replaceWhenExits }: {
+        key?: keyof T;
+        onExist?: (oldData: T, newData: T) => void | null;
+        onNotExist?: (newData: T) => void | null;
+        replaceWhenExits?: boolean;
+    }): 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 onExist(onExist: ((oldData: T, newData: T) => void) | undefined);
+    set key(key: keyof T);
+    set replaceWhenExits(replaceWhenExits: boolean);
+}

package/cjs/set-ex.js

@@ -0,0 +1,336 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetEx = void 0;
+class SetEx extends Set {
+    /**
+     * @param key 识别是否存在的对象的属性名
+     * @param onExist 当存在时作何操作? oldData/newData 哪个将添加到set,由replaceItemWhenExits决定,默认是oldData生效
+     * @param onNotExist 当不存在时作何操作?
+     * @param replaceWhenExits 当存在时是否覆盖？
+     * @param values 初始数组
+     */
+    constructor(key, onExist, replaceWhenExits = false, values, onNotExist) {
+        super();
+        if (typeof key === 'object') {
+            this.whenOnExist = key.onExist;
+            this.uniqueKey = key.key;
+            this.replaceItemWhenExits = key.replaceWhenExits === true;
+            this.whenOnNotExist = key.onNotExist;
+            if (key.values) {
+                this.addAll(...key.values);
+            }
+        }
+        else {
+            this.whenOnExist = onExist;
+            this.uniqueKey = key;
+            this.replaceItemWhenExits = replaceWhenExits;
+            this.whenOnNotExist = onNotExist;
+            if (values) {
+                this.addAll(...values);
+            }
+        }
+    }
+    /**
+     *
+     * 添加返回
+     * @param {T} value
+     * @returns {this} 当前对象
+     */
+    add(value) {
+        let flag = false;
+        this.forEach((item) => {
+            if (item[this.uniqueKey] === value[this.uniqueKey]) {
+                flag = true;
+                if (this.whenOnExist) {
+                    this.whenOnExist(item, value);
+                }
+                if (this.replaceItemWhenExits === true) {
+                    super.delete(item);
+                    flag = false;
+                }
+                return false;
+            }
+        });
+        if (flag === false) {
+            super.add(value);
+            if (this.whenOnNotExist) {
+                this.whenOnNotExist(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;
+        let tmp = value;
+        this.forEach((item) => {
+            if (item[this.uniqueKey] === value[this.uniqueKey]) {
+                flag = true;
+                if (this.whenOnExist) {
+                    this.whenOnExist(item, value);
+                }
+                if (this.replaceItemWhenExits === true) {
+                    super.delete(item);
+                    flag = false;
+                }
+                else {
+                    tmp = item;
+                }
+                return false;
+            }
+        });
+        if (flag === false) {
+            super.add(value);
+            if (this.whenOnNotExist) {
+                this.whenOnNotExist(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 {*} value 这是对象的关键属性,而非对象
+     * @returns {(T | null)}
+     */
+    find(value) {
+        for (const item of this) {
+            if (item[this.uniqueKey] === value) {
+                return item;
+            }
+        }
+        return null;
+    }
+    /**
+     * 用key找到匹配的所有对象
+     * @param {*} value 这是对象的关键属性,而非对象
+     * @returns {T[]}
+     */
+    findAll(value) {
+        const res = new Array();
+        this.forEach((item) => {
+            if (item[this.uniqueKey] === value) {
+                res.push(item);
+            }
+        });
+        return res;
+    }
+    /**
+     *
+     * 用函数回调找到匹配的第一个对象
+     * @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(value) {
+        for (const item of this) {
+            if (item[this.uniqueKey] === value) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * 转为数组
+     * @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 {*} value 这是对象的关键属性,而非对象
+     * @returns {boolean}
+     */
+    delete(value) {
+        for (const item of this) {
+            if (item[this.uniqueKey] === value) {
+                super.delete(item);
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     *
+     * 重置
+     * @param {keyof T} key
+     * @param {(oldData: T, newData: T) => void} [onExist]
+     * @param {boolean} [replaceWhenExits=false]
+     */
+    reset({ key, onExist, onNotExist, replaceWhenExits }) {
+        if (onExist !== undefined) {
+            this.whenOnExist = onExist;
+        }
+        if (onNotExist !== undefined) {
+            this.whenOnNotExist = onNotExist;
+        }
+        if (key) {
+            this.uniqueKey = key;
+        }
+        if (replaceWhenExits !== undefined) {
+            this.replaceItemWhenExits = replaceWhenExits;
+        }
+        this.clear();
+        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.uniqueKey];
+            for (const key in item) {
+                if (!result[key]) {
+                    result[key] = [];
+                }
+                result[key].push({ name, value: item[key] });
+            }
+        }
+        return result;
+    }
+    set onExist(onExist) {
+        this.whenOnExist = onExist;
+    }
+    set key(key) {
+        this.uniqueKey = key;
+    }
+    set replaceWhenExits(replaceWhenExits) {
+        this.replaceItemWhenExits = replaceWhenExits;
+    }
+}
+exports.SetEx = SetEx;