@zcrkey/js-utils 0.0.4 → 0.0.5

package/src/eventCenter.ts

@@ -0,0 +1,112 @@
+export type TSubscribers = {
+  key: string;
+  listeners: Array<(...args: any) => void>;
+};
+
+export type TSubscription = {
+  key: string;
+  listener: (...args: any) => void;
+  remove: () => void;
+};
+
+export default class CrEventCenter {
+  /**
+   * 储存订阅者
+   */
+  static subscribers: TSubscribers[] = [];
+
+  /**
+   * 新增订阅
+   *
+   * @param {*} key 名称
+   * @param {*} listener 执行函数
+   * @returns 订阅信息
+   * @example
+     this.subscription = CrEventCenter.on('名称', (参数) => {});
+   */
+  static on(key: string, listener: (...args: any) => void): TSubscription {
+    const subscriber = this.subscribers.find((item) => item.key == key);
+    if (subscriber) {
+      subscriber.listeners.push(listener);
+    } else {
+      this.subscribers.push({
+        key: key,
+        listeners: [listener],
+      });
+    }
+    let subscription: TSubscription = {
+      key: key,
+      listener: listener,
+      remove: () => {
+        this.off(subscription);
+      },
+    };
+    return subscription;
+  }
+
+  /**
+   * 移除订阅
+   *
+   * @param {*} subscription 
+   * @param {*} type 'all'  
+   * @example
+     CrEventCenter.off(this.subscription);
+   */
+  static off(subscription: TSubscription, type?: 'all') {
+    const index = this.subscribers.findIndex(
+      (item) => item.key == subscription.key,
+    );
+    if (index > -1) {
+      if (type == 'all') {
+        this.subscribers.splice(index, 1);
+      } else {
+        const subscriber = this.subscribers[index];
+        const _index = subscriber.listeners.findIndex(
+          (item) => item == subscription.listener,
+        );
+        if (_index > -1) {
+          subscriber.listeners.splice(_index, 1);
+        }
+      }
+    }
+  }
+
+  /**
+   * 派发事件
+   *
+   * @param {*} key 名称
+   * @param {*} args 其余参数
+   * @example
+     CrEventCenter.emit('名称', 参数数据);
+   */
+  static emit(key: string, ...args: any) {
+    const subscriber = this.subscribers.find((item) => item.key == key);
+    if (subscriber && subscriber.listeners && subscriber.listeners.length > 0) {
+      subscriber.listeners.forEach((listener) => {
+        listener(...args);
+      });
+    }
+  }
+
+  /**
+   * 查找事件
+   *
+   * @param {*} key 名称
+   * @example
+    let subscriber = CrEventCenter.find('名称');
+   */
+  static find(key: string): TSubscribers | undefined {
+    return this.subscribers.find((item) => item.key == key);
+  }
+
+  /**
+   * 清理所有事件
+   *
+   * @memberof CrEventCenter
+   * @example
+     CrEventCenter.clear();
+   */
+  static clear() {
+    this.subscribers.length = 0;
+  }
+}

package/src/index.ts

@@ -0,0 +1,8 @@
+export type * from './eventCenter';
+export { default as CrEventCenter } from './eventCenter';
+export type * from './objUtil';
+export { default as CrObjUtil } from './objUtil';
+export { default as CrStorage } from './storage';
+export type * from './treeUtil';
+export { default as CrTreeUtil } from './treeUtil';
+export { default as CrUtil } from './util';

package/src/objUtil.ts

@@ -0,0 +1,20 @@
+import { get, PropertyPath } from 'lodash';
+
+export type { PropertyPath };
+
+export default class CrObjUtil {
+  /**
+   * 根据字段路径获取对象值
+   * @param obj { 'a': [{ 'b': { 'c': 3 } }] }
+   * @param path 'a[0].b.c' | ['a', '0', 'b', 'c']
+   * @param defaultValue 找不到时返回的默认值
+   * @returns
+   */
+  static getValueByPath(
+    obj: Record<string | number | symbol, any>,
+    propertyPath: PropertyPath,
+    defaultValue?: any,
+  ) {
+    return get(obj, propertyPath, defaultValue);
+  }
+}

package/src/storage.ts

@@ -0,0 +1,101 @@
+export default class CrStorage {
+  /**
+   * 设置本地存储
+   * @param key
+   * @param data
+   */
+  static setLocalItem(key: string, data: any) {
+    try {
+      localStorage.setItem(key, JSON.stringify(data));
+    } catch (error) {
+      console.warn(`setLocalItem:${key}:${error}`);
+    }
+  }
+
+  /**
+   * 获取本地存储
+   * @param key
+   * @returns
+   */
+  static getLocalItem<T = any>(key: string): T | null {
+    const str = localStorage.getItem(key);
+    if (str) {
+      if (str === 'undefined') {
+        return null;
+      }
+      try {
+        return JSON.parse(str);
+      } catch (error) {
+        console.warn(`getLocalItem:${key}:${error}`);
+        return null;
+      }
+    } else {
+      return null;
+    }
+  }
+
+  /**
+   * 清除某个本地存储
+   * @param key
+   */
+  static removeLocalItem(key: string) {
+    localStorage.removeItem(key);
+  }
+
+  /**
+   * 清除所有本地存储
+   */
+  static clearLocal() {
+    localStorage.clear();
+  }
+
+  /**
+   * 设置会话存储
+   * @param key
+   * @param data
+   */
+  static setSessionItem(key: string, data: any) {
+    try {
+      sessionStorage.setItem(key, JSON.stringify(data));
+    } catch (error) {
+      console.warn(`setSessionItem:${key}:${error}`);
+    }
+  }
+
+  /**
+   * 获取会话存储
+   * @param key
+   * @returns
+   */
+  static getSessionItem<T = any>(key: string): T | null {
+    const str = sessionStorage.getItem(key);
+    if (str) {
+      if (str === 'undefined') {
+        return null;
+      }
+      try {
+        return JSON.parse(str);
+      } catch (error) {
+        console.warn(`getSessionItem:${key}:${error}`);
+        return null;
+      }
+    } else {
+      return null;
+    }
+  }
+
+  /**
+   * 清除某个会话存储
+   * @param key
+   */
+  static removeSessionItem(key: string) {
+    sessionStorage.removeItem(key);
+  }
+
+  /**
+   * 清除所有会话存储
+   */
+  static clearSession() {
+    sessionStorage.clear();
+  }
+}

package/src/treeUtil.ts

@@ -0,0 +1,164 @@
+import {
+  cloneDeep as _cloneDeep,
+  find as _find,
+  get as _get,
+  keyBy as _keyBy,
+} from 'lodash';
+
+export default class CrTreeUtil {
+  /**
+   * 列表数据转树形数据
+   * @param list
+   * @param options
+   * @param options.idField 默认值 id
+   * @param options.parentIdField 默认值 parentId
+   * @param options.childrenField 默认值 children
+   * @param options.isCloneDeep 是否需要深拷贝, 默认值为 true
+   * @param options.getData 处理数据
+   * @returns
+   */
+  static listToTree<T extends Record<string, any>>(
+    list: T[],
+    options?: {
+      idField?: string;
+      parentIdField?: string;
+      childrenField?: string;
+      isCloneDeep?: boolean;
+      getData?: (item: T) => any;
+    },
+  ): any[] {
+    const {
+      idField = 'id',
+      parentIdField = 'parentId',
+      childrenField = 'children',
+      isCloneDeep = true,
+      getData = (item: T) => item,
+    } = options || {};
+
+    const listData = isCloneDeep ? _cloneDeep(list) : list;
+    const treeData: any[] = [];
+    const nodeMap = new Map<string | number, any>();
+
+    for (const item of listData) {
+      const id = item[idField];
+      const node = {
+        ...getData(item),
+        __origin_id: id,
+        __origin_pid: item[parentIdField],
+      };
+      nodeMap.set(id, node);
+    }
+
+    for (const node of nodeMap.values()) {
+      const parentId = node.__origin_pid;
+      if (
+        parentId === undefined ||
+        parentId === null ||
+        parentId === 0 ||
+        !nodeMap.has(parentId)
+      ) {
+        treeData.push(node);
+      } else {
+        const parentNode = nodeMap.get(parentId);
+        if (!parentNode[childrenField]) {
+          parentNode[childrenField] = [];
+        }
+        parentNode[childrenField].push(node);
+      }
+    }
+
+    const clean = (nodes: any[]) => {
+      for (const node of nodes) {
+        delete node.__origin_id;
+        delete node.__origin_pid;
+        if (node[childrenField]) {
+          clean(node[childrenField]);
+        }
+      }
+    };
+    clean(treeData);
+
+    return treeData;
+  }
+
+  /**
+   * 树形数据转列表数据
+   * @param tree
+   * @param options
+   * @param options.childrenField 默认值 children
+   * @param options.isCloneDeep 是否需要深拷贝, 默认值为 true
+   * @returns
+   */
+  static treeToList<T extends Record<string, any>>(
+    tree: T[],
+    options?: {
+      childrenField?: string;
+      isCloneDeep?: boolean;
+    },
+  ) {
+    const { childrenField = 'children', isCloneDeep = true } = options || {};
+    const result: T[] = [];
+    const queue: T[] = [...tree];
+    while (queue.length) {
+      const node = queue.shift()!;
+      const children = node[childrenField];
+      const { [childrenField]: _, ...rest } = node;
+      result.push(rest as T);
+      if (children && children.length) {
+        queue.push(...children);
+      }
+    }
+
+    return isCloneDeep ? _cloneDeep(result) : result;
+  }
+
+  /**
+   * 获取扁平化父数据(包含自身)
+   * @param listData
+   * @param value
+   * @param settings
+   * @param settings.valueField 默认值 value
+   * @param settings.idField 默认值 id
+   * @param settings.parentIdField 默认值 parentId
+   * @param settings.getData 过滤数据
+   */
+  static getFlatParentDatas<T = any, R extends Record<string, any> = any>(
+    listData: R[],
+    value: number | string,
+    settings?: {
+      valueField?: string;
+      idField?: string;
+      parentIdField?: string;
+      getData?: (item: R) => T;
+    },
+  ): T[] {
+    if (!Array.isArray(listData) || listData.length === 0 || value == null) {
+      return [];
+    }
+    const options = Object.assign(
+      {
+        valueField: 'value',
+        idField: 'id',
+        parentIdField: 'parentId',
+        getData: (item: R): T => {
+          return item as unknown as T;
+        },
+      },
+      settings,
+    );
+    const nodeMap = _keyBy(listData, options.valueField);
+    const result: T[] = [];
+    const visited = new Set();
+    let current: R | undefined = nodeMap[value];
+    while (current && !visited.has(_get(current, options.idField))) {
+      visited.add(_get(current, options.idField));
+      result.unshift(options.getData(current));
+      const parentId: string | number | undefined | null = _get(
+        current,
+        options.parentIdField,
+      );
+      current = _find(listData, [options.valueField, parentId]);
+    }
+    return result;
+  }
+}