baja-lite 1.1.3 → 1.1.4

package/src/set-ex.ts

@@ -0,0 +1,374 @@
+import iterate from "iterare";
+
+export class SetEx<T> extends Set {
+  private _key: keyof T;
+  private _onExist1?: (oldData: T, newData: T) => void | null;
+  private _onNotExist1?: (newData: T) => void | null;
+  private _replaceIfExits1: boolean;
+  private _onExist2?: (oldData: T, newData: T) => void | null;
+  private _onNotExist2?: (newData: T) => void | null;
+  private _replaceIfExits2: boolean;
+  private _map: Map<string, T> = new 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;
+    }
+  ) {
+    super();
+    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} 当前对象
+   */
+  override add(value: T): this {
+    let flag = false;
+    const key = value[this._key] as string;
+    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: T[]): this {
+    for (const value of values) {
+      this.add(value);
+    }
+    return this;
+  }
+  /**
+   *
+   * 添加
+   * @param {T} value
+   * @returns {T} 添加成功的对象:可能是新加入集合的，也可能是原本存在的
+   */
+  add2(value: T): T {
+    let flag = false;
+    const key = value[this._key] as string;
+    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: T[]): T[] {
+    const result: T[] = [];
+    for (const value of values) {
+      result.push(this.add2(value));
+    }
+    return result;
+  }
+  /**
+   * 用key找到匹配的第一个对象
+   * @param {*} key 这是对象的关键属性,而非对象
+   * @returns {(T | null)}
+   */
+  find(key: T[keyof T]): T | null {
+    return this._map.get(key as string) ?? null;
+  }
+  /**
+   * 用key找到匹配的所有对象
+   * @param {*} key 这是对象的关键属性,而非对象
+   * @returns {T[]}
+   */
+  findAll(key: T[keyof T]): T[] {
+    return iterate(key as string[]).map(k => this._map.get(k)).filter(v => v !== undefined).toArray() as T[];
+  }
+  /**
+   *
+   * 用函数回调找到匹配的第一个对象
+   * @param {(item: T) => boolean} fn
+   * @returns {T[]}
+   */
+  filter(fn: (item: T) => boolean): T | null {
+    for (const item of this) {
+      if (fn(item) === true) {
+        return item;
+      }
+    }
+    return null;
+  }
+  /**
+   *
+   * 用函数回调找到匹配的所有对象
+   * @param {(item: T) => boolean} fn
+   * @returns {T[]}
+   */
+  filterAll(fn: (item: T) => boolean): T[] {
+    const res = new Array<T>();
+    this.forEach((item) => {
+      if (fn(item) === true) {
+        res.push(item);
+      }
+    });
+    return res;
+  }
+  /**
+   *
+   * 是否存在key对应的对象
+   * @param {*} value 这是对象的关键属性,而非对象
+   * @returns {boolean}
+   */
+  override has(key: T[keyof T]): boolean {
+    return this._map.has(key as string);
+  }
+  /**
+   * 转为数组
+   * @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[] {
+    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<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 } {
+    return Object.fromEntries(this.toArray({ sort, each, filter, map }).map(i => [i[key], value ? i[value] : i]));
+  }
+  /**
+   *
+   * 删除key对应的对象
+   * @param {*} _key 这是对象的关键属性,而非对象
+   * @returns {boolean}
+   */
+  override delete(_key: T[keyof T]): boolean {
+    const key = _key as string;
+    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: {
+    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 {
+    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 }: {
+    sort?: (a: T, b: T) => number;
+    each?: (a: T) => void;
+    filter?: (a: T) => boolean;
+    map?: (a: T) => T;
+  } = {}) {
+    const result: { [k: string]: T[keyof T][] } = {};
+    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 }: {
+    sort?: (a: T, b: T) => number;
+    each?: (a: T) => void;
+    filter?: (a: T) => boolean;
+    map?: (a: T) => T;
+  } = {}, ...keys: (keyof T)[]) {
+    if (this.size === 0) { return []; }
+    if (keys.length === 0) { keys = Object.keys(this.values().next().value) as any; }
+    const result: (T[keyof T] | keyof T)[][] = [keys];
+    const list = this.toArray({ sort, each, filter, map });
+    for (const item of list) {
+      const one: T[keyof T][] = [];
+      for (const key of keys) {
+        one.push(item[key]);
+      }
+      result.push(one);
+    }
+    return result;
+  }
+  /**
+   * 转为饼图支持的数组
+   * @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] }[] } {
+    if (this.size === 0) { return {}; }
+    if (keys.length === 0) { keys = Object.keys(this.values().next().value) as any; }
+    const result: { [k: string]: { value: T[keyof T], name: T[keyof T] }[] } = {};
+    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: ((oldData: T, newData: T) => void) | undefined) {
+    this._onExist1 = onExist1;
+  }
+  set onExist2(onExist2: ((oldData: T, newData: T) => void) | undefined) {
+    this._onExist2 = onExist2;
+  }
+  set onNotExist1(onNotExist1: ((newData: T) => void) | undefined) {
+    this._onNotExist1 = onNotExist1;
+  }
+  set onNotExist2(onNotExist2: ((newData: T) => void) | undefined) {
+    this._onNotExist2 = onNotExist2;
+  }
+  set replaceIfExits1(replaceIfExits1: boolean) {
+    this._replaceIfExits1 = replaceIfExits1;
+  }
+  set replaceIfExits2(replaceIfExits2: boolean) {
+    this._replaceIfExits2 = replaceIfExits2;
+  }
+  set key(key: keyof T) {
+    this._key = key;
+  }
+}