@zcrkey/js-utils 0.0.4 → 0.0.5

package/src/util.ts

@@ -0,0 +1,656 @@
+import { cloneDeep as _cloneDeep } from 'lodash';
+import Qs from 'qs';
+
+export default class CrUtil {
+  /**
+   * 判断是否为数组
+   * @param value
+   * @returns boolean
+   */
+  static isArray<T = any>(value: any): value is T[] {
+    return Array.isArray(value);
+  }
+
+  /**
+   * 判断是否为对象
+   * @param value
+   * @returns boolean
+   */
+  static isObject<T = any>(
+    value: T,
+  ): value is T extends object ? (T extends any[] ? never : T) : never {
+    return (
+      typeof value === 'object' && value !== null && !CrUtil.isArray(value)
+    );
+  }
+
+  /**
+   * 判断是否为空对象
+   * @param value
+   * @returns boolean
+   */
+  static isEmptyObject(value: object): value is Record<string | number, never> {
+    return Object.keys(value).length === 0 && value.constructor === Object;
+  }
+
+  /**
+   * 判断是否对象的属性是否全部为空
+   * @param value
+   * @returns boolean
+   */
+  static isObjectPropertiesAllEmpty(
+    value: Record<string | number, any>,
+  ): boolean {
+    return Object.keys(value).every((key) => {
+      const _value = value[key];
+      return (
+        _value === undefined ||
+        _value === null ||
+        _value === '' ||
+        (_value === 0 && typeof _value === 'number') ||
+        isNaN(_value)
+      );
+    });
+  }
+
+  /**
+   * 判断是否为日期
+   * @param value
+   * @returns boolean
+   */
+  static isDate(value: unknown) {
+    return Object.prototype.toString.call(value) === '[object Date]';
+  }
+
+  /**
+   * 判断是否为字符串
+   * @param value
+   * @returns boolean
+   */
+  static isString(value: unknown): value is string {
+    return Object.prototype.toString.call(value) === '[object String]';
+  }
+
+  /**
+   * 判断是否为数字
+   * @param value
+   * @returns boolean
+   */
+  static isNumber(value: unknown): value is number {
+    return typeof value === 'number' && !isNaN(value);
+  }
+
+  /**
+   * 判断是否为文件 File
+   * @param value
+   * @returns boolean
+   */
+  static isFile(value: unknown): value is File {
+    return Object.prototype.toString.call(value) === '[object File]';
+  }
+
+  /**
+   * 判断是否为 Boolean
+   * @param value
+   * @returns boolean
+   */
+  static isBoolean(value: unknown): value is boolean {
+    return Object.prototype.toString.call(value) === '[object Boolean]';
+  }
+
+  /**
+   * 判断是否为 Function
+   * @param value
+   * @returns boolean
+   */
+  static isFunction(value: unknown): value is (...args: any[]) => any {
+    return typeof value === 'function';
+  }
+
+  /**
+   * 去掉字符串前后所有空格
+   * @param str
+   * @returns string
+   */
+  static trim(str: string) {
+    return (str + '').replace(/(^[\s\n\t]+|[\s\n\t]+$)/g, '');
+  }
+
+  /**
+   * 获取数组为几维数组
+   * @param arr
+   * @returns number
+   */
+  static getArrayDimension(arr: any[]): number {
+    // 如果不是一个数组，返回 0
+    if (!CrUtil.isArray(arr)) return 0;
+
+    // 找到数组中的最大维度
+    let maxDimension = 0;
+    for (let i = 0; i < arr.length; i++) {
+      const dimension = CrUtil.getArrayDimension(arr[i]);
+      maxDimension = Math.max(maxDimension, dimension);
+    }
+    // 返回最大维度加1，代表当前层数
+    return maxDimension + 1;
+  }
+
+  /**
+   * 深拷贝
+   * @param value
+   * @returns
+   */
+  static cloneDeep<T>(value: T): T {
+    return _cloneDeep(value);
+  }
+
+  /**
+   * 深拷贝
+   * @param target
+   * @deprecated 即将移除，使用 {@link CrUtil.cloneDeep} 替代
+   * @returns
+   */
+  static deepCopy<T = any>(target: T): T {
+    let _target: any;
+    if (CrUtil.isArray(target)) {
+      _target = [];
+      for (let i = 0, len = target.length; i < len; i++) {
+        if (CrUtil.isArray(target[i]) || CrUtil.isObject(target[i])) {
+          _target.push(CrUtil.deepCopy(target[i]));
+        } else {
+          _target.push(target[i]);
+        }
+      }
+    } else if (CrUtil.isObject(target)) {
+      _target = {};
+      for (let i in target) {
+        if (CrUtil.isArray(target[i]) || CrUtil.isObject(target[i])) {
+          _target[i] = CrUtil.deepCopy(target[i]);
+        } else {
+          _target[i] = target[i];
+        }
+      }
+    } else {
+      _target = target;
+    }
+    return _target;
+  }
+
+  /**
+   * 列表数据转树型数据
+   * @param listData
+   * @param settings
+   * @param settings.idField 默认值 id
+   * @param settings.pidField 默认值 parentId
+   * @param settings.childrenField 默认值 children
+   * @deprecated 即将移除，使用 {@link CrObjUtil.listToTree} 替代
+   * @returns
+   */
+  static listToTreeData(
+    listData: any[],
+    settings?: {
+      idField?: string;
+      pidField?: string;
+      childrenField?: string;
+      isDeepCopy?: boolean;
+      getData?: (item: any) => any;
+    },
+  ) {
+    const options = Object.assign(
+      {
+        idField: 'id',
+        pidField: 'parentId',
+        childrenField: 'children',
+        isDeepCopy: false,
+        getData: (item: any) => {
+          return item;
+        },
+      },
+      settings,
+    );
+
+    const { idField, pidField, childrenField, isDeepCopy, getData } = options;
+
+    if (isDeepCopy) {
+      listData = CrUtil.deepCopy(listData);
+    }
+
+    // 构建索引
+    const pidMap = new Map<any, any[]>();
+    const idMap = new Map<any, any>();
+    for (const item of listData) {
+      const pid = item[pidField];
+      const id = item[idField];
+      if (!pidMap.has(pid)) {
+        pidMap.set(pid, []);
+      }
+      pidMap.get(pid)!.push(item);
+      idMap.set(id, item);
+    }
+
+    // 递归构建树 + 字段过滤
+    const buildTree = (pid: any): any[] => {
+      const children = pidMap.get(pid) || [];
+      return children.map((item) => {
+        const rawChildren = buildTree(item[idField]);
+        const node = {
+          ...getData(item),
+        };
+        if (rawChildren.length > 0) {
+          node[childrenField] = rawChildren;
+        }
+        return node;
+      });
+    };
+
+    // 收集所有根节点 pid，去重
+    const rootPids = new Set<any>();
+    for (const pid of pidMap.keys()) {
+      if (pid === undefined || pid === null || pid === 0 || !idMap.has(pid)) {
+        rootPids.add(pid);
+      }
+    }
+
+    // 构建最终树
+    const tree: any[] = [];
+    for (const pid of rootPids) {
+      tree.push(...buildTree(pid));
+    }
+
+    // 只构建根节点（pid 为 null / 0 / undefined / 不存在）
+    // const tree = buildTree(undefined)
+    //   .concat(buildTree(null))
+    //   .concat(buildTree(0))
+    //   .concat(
+    //     Array.from(pidMap.keys())
+    //       .filter((pid) => !idMap.has(pid))
+    //       .flatMap((pid) => buildTree(pid)),
+    //   );
+
+    return tree;
+  }
+
+  /**
+   * 树型数据转列表数据
+   * @param treeData
+   * @param settings
+   * @param settings.idField 默认值 id
+   * @param settings.pidField 默认值 parentId
+   * @param settings.childrenField 默认值 children
+   * @deprecated 即将移除，使用 {@link CrObjUtil.treeToList} 替代
+   * @returns
+   */
+  static treeDataToListData(
+    treeData: any[],
+    pid: string | number = 0,
+    settings?: {
+      childrenField?: string;
+      idField?: string;
+      pidField?: string;
+      isDeepCopy?: boolean;
+    },
+  ) {
+    let options = Object.assign(
+      {
+        idField: 'id',
+        pidField: 'parentId',
+        childrenField: 'children',
+        isDeepCopy: false,
+      },
+      settings,
+    );
+    let listData: any[] = [];
+    for (let i = 0; i < treeData.length; i++) {
+      const node = treeData[i];
+      const item: any = { ...node };
+      item[options.pidField] = pid;
+      delete item[options.childrenField];
+      listData.push(item);
+      if (node[options.childrenField]) {
+        const childrenList = this.treeDataToListData(
+          node[options.childrenField],
+          item[options.idField],
+          settings,
+        );
+        listData.push(...childrenList);
+      }
+    }
+    if (options.isDeepCopy) {
+      listData = CrUtil.deepCopy(listData);
+    }
+    return listData;
+  }
+
+  /**
+   * 获取所有父级数据（包含自身）
+   * @param listData
+   * @param value
+   * @param settings
+   * @param settings.valueField 默认值 value
+   * @param settings.idField 默认值 id
+   * @param settings.pidField 默认值 parentId
+   * @deprecated 即将移除，使用 {@link CrObjUtil.getFlatParentDatas} 替代
+   * @returns
+   */
+  static getParentNodes<T, R extends Record<string, any>>(
+    listData: R[],
+    value: number | string,
+    settings?: {
+      valueField?: string;
+      idField?: string;
+      pidField?: string;
+      getData?: (item: R) => T;
+    },
+  ): T[] {
+    const options = Object.assign(
+      {
+        valueField: 'value',
+        idField: 'id',
+        pidField: 'parentId',
+        getData: (item: R): T => {
+          return item as unknown as T;
+        },
+      },
+      settings,
+    );
+
+    if (!(listData && listData.length > 0) || !value) {
+      return [];
+    }
+    const idField = options.idField;
+    const pidField = options.pidField;
+    const valueField = options.valueField;
+    const nodes: T[] = [];
+    let node: R | undefined = listData.find(
+      (item: R) => item[valueField] == value,
+    );
+    if (node) {
+      nodes.push(options.getData(node));
+      while (node && node[pidField]) {
+        const parentOption: R | undefined = listData.find(
+          // eslint-disable-next-line @typescript-eslint/no-loop-func
+          (item: R) => item[idField] == (node as R)[pidField],
+        );
+        if (parentOption) {
+          nodes.push(options.getData(parentOption));
+        }
+        node = parentOption;
+      }
+    }
+    nodes.reverse();
+    return nodes;
+  }
+
+  /**
+   * 参数序列化
+   * @param params {a:'1',b:{},c:[]}
+   * @returns
+   */
+  static paramsSerializer(
+    params: Record<string, any>,
+    settings?: { isFilterNonNull: boolean },
+  ) {
+    const options = Object.assign(
+      {
+        isFilterNonNull: false,
+      },
+      settings,
+    );
+    if (options.isFilterNonNull) {
+      Object.keys(params).forEach((key) => {
+        if (
+          params[key] === null ||
+          params[key] === undefined ||
+          params[key] === ''
+        ) {
+          delete params[key];
+        }
+      });
+    }
+    return Qs.stringify(params);
+  }
+
+  /**
+   * 参数解析
+   * @param {*} str
+   * @param {*} settings
+   * @returns
+   */
+  static paramsParse(str: string, settings?: { ignoreQueryPrefix: boolean }) {
+    let obj = {};
+    let option = Object.assign(
+      {
+        ignoreQueryPrefix: true,
+      },
+      settings,
+    );
+    if (str) {
+      obj = Qs.parse(str, option);
+    }
+    return obj;
+  }
+
+  /**
+   * 获取 URL 参数
+   * @param {*} url
+   * @returns
+   * @example
+   * "https://example.com?foo=bar&baz=qux" => {"query":{"foo":"bar","baz":"qux"},"hash":{},"all":{"foo":"bar","baz":"qux"}}
+   * "https://example.com/page?foo=1#/?a=1&b=2" => {"query":{"foo":"1"},"hash":{"/":"","a":"1","b":"2"},"all":{"foo":"1","/":"","a":"1","b":"2"}},
+   */
+  static getQueryParams(url: string): {
+    query: Record<string, any>;
+    hash: Record<string, any>;
+    all: Record<string, any>;
+  } {
+    const query: Record<string, any> = {};
+    const hash: Record<string, any> = {};
+    const all: Record<string, any> = {};
+    const parse = (queryString: string) => {
+      if (!queryString) {
+        return {};
+      }
+      try {
+        return Qs.parse(queryString);
+      } catch {
+        const result: Record<string, any> = {};
+        if (!queryString) return result;
+        queryString.split('&').forEach((pair) => {
+          if (!pair) return;
+          const [key, val] = pair.split('=');
+          if (key)
+            result[decodeURIComponent(key)] = decodeURIComponent(val || '');
+        });
+        return result;
+      }
+    };
+    try {
+      const [base, hashPart] = url.split('#');
+      const queryPart = base.split('?')[1];
+      Object.assign(query, parse(queryPart));
+      if (hashPart) {
+        for (const part of hashPart.split('?')) {
+          Object.assign(hash, parse(part));
+        }
+      }
+      Object.assign(all, query, hash);
+    } catch (error) {
+      console.error('getQueryParams:', error);
+    }
+    return { query, hash, all };
+  }
+
+  /**
+   * 版本号比较
+   * @param v1
+   * @param v2
+   * @returns number
+   * @description v1大于v2(1)、v1小于v2(-1)、v1等于v2(0)
+   */
+  static compareVersion(v1: string, v2: string): number {
+    let v1Arr: Array<string> = CrUtil.trim(v1).split('.');
+    let v2Arr: Array<string> = CrUtil.trim(v2).split('.');
+    const len = Math.max(v1.length, v2.length);
+    while (v1Arr.length < len) {
+      v1Arr.push('0');
+    }
+    while (v2Arr.length < len) {
+      v2Arr.push('0');
+    }
+    for (let i = 0; i < len; i++) {
+      const num1 = parseInt(v1Arr[i]);
+      const num2 = parseInt(v2Arr[i]);
+      if (num1 > num2) {
+        return 1;
+      } else if (num1 < num2) {
+        return -1;
+      }
+    }
+    return 0;
+  }
+
+  /**
+   * 根据 ids 获取相对应的数据名称
+   * @param data
+   * @param ids
+   * @param settings
+   * @returns string
+   */
+  static getDataNameByIds<T extends Record<string, any>>(
+    data: T[],
+    ids: (string | number)[],
+    settings?: { sep?: string; nameField?: string; idField?: string },
+  ): string {
+    const options = Object.assign(
+      {
+        sep: '、',
+        idField: 'id',
+        nameField: 'name',
+      },
+      settings,
+    );
+    let str = '';
+    if (ids && ids.length > 0) {
+      str = ids
+        .map((id) => {
+          let item = data.find((item) => item[options.idField] == id);
+          if (item) {
+            return item[options.nameField];
+          } else {
+            return '';
+          }
+        })
+        .join(options.sep);
+    }
+    return str;
+  }
+
+  /**
+   * 追加html标签属性值
+   * @param htmlStr
+   * @param tagName
+   * @param attrName
+   * @param newAttrValue
+   * @returns string
+   */
+  static appendHtmlTagAttr(
+    htmlStr: string,
+    tagName: string,
+    attrName: string,
+    newAttrValue: string,
+  ) {
+    let regex = new RegExp(`(<${tagName}\\s+)([^>]*?)([^>]*>)`, 'g');
+    let replacedHtml = htmlStr.replace(regex, function (match, p1, p2, p3) {
+      let _regex = new RegExp(`${attrName}="(.*?)"`, 'g');
+      if (_regex.exec(match)) {
+        let __regex = new RegExp(
+          `(<${tagName}\\s+)([^>]*?)${attrName}="(.*)"([^>]*>)`,
+          'g',
+        );
+        return match.replace(__regex, function (_match, _p1, _p2, _p3, _p4) {
+          return _p1 + _p2 + `${attrName}="${_p3} ${newAttrValue}"` + _p4;
+        });
+      } else {
+        return p1 + `${attrName}="${newAttrValue}" ` + p3;
+      }
+    });
+    replacedHtml = replacedHtml.replace(
+      new RegExp(`<${tagName}>`, 'g'),
+      `<${tagName} ${attrName}="${newAttrValue}">`,
+    );
+    return replacedHtml;
+  }
+
+  /**
+   * 比较数据差异
+   * @param data1
+   * @param data2
+   * @returns
+   */
+  static compareDataDiff(data1: any, data2: any) {
+    const diffFieldSet: Record<string, 'added' | 'removed' | 'modified'> = {};
+    const compare = (path: string, o1: any, o2: any) => {
+      if (CrUtil.isArray(o1) && CrUtil.isArray(o2)) {
+        // 如果两者都是数组，比较它们的长度和内容
+        const lengthDiff = o1.length - o2.length;
+        if (lengthDiff !== 0) {
+          // 数组长度不同
+          diffFieldSet[path] = 'modified';
+          if (lengthDiff > 0) {
+            // o1比o2长，所以o1中有多余的元素
+            for (let i = o2.length; i < o1.length; i++) {
+              diffFieldSet[`${path}[${i}]`] = 'removed'; // 只在o1中存在
+            }
+          } else {
+            // o2比o1长，所以o2中有新增的元素
+            for (let i = o1.length; i < o2.length; i++) {
+              diffFieldSet[`${path}[${i}]`] = 'added'; // 只在o2中存在
+            }
+          }
+        } else {
+          for (let i = 0; i < o1.length; i++) {
+            compare(`${path}[${i}]`, o1[i], o2[i]);
+          }
+        }
+      } else if (CrUtil.isObject(o1) && CrUtil.isObject(o2)) {
+        // 如果两者都是对象，遍历它们的属性
+        // eslint-disable-next-line guard-for-in
+        for (let key in o1) {
+          const _path = path ? `${path}.${key}` : key;
+          if (Object.prototype.hasOwnProperty.call(o1, key) && !(key in o2)) {
+            diffFieldSet[_path] = 'removed'; // 只在o1中存在
+          } else if (Object.prototype.hasOwnProperty.call(o2, key)) {
+            compare(_path, o1[key], o2[key]);
+          }
+        }
+        // 检查o2中是否存在o1中没有的属性
+        // eslint-disable-next-line guard-for-in
+        for (let key in o2) {
+          const _path = path ? `${path}.${key}` : key;
+          if (Object.prototype.hasOwnProperty.call(o2, key) && !(key in o1)) {
+            diffFieldSet[_path] = 'added'; // 只在o2中存在
+          }
+        }
+      } else if (o1 !== o2) {
+        // 既不是对象也不是数组，直接比较值
+        diffFieldSet[path] = 'modified';
+      }
+    };
+    compare('', data1, data2);
+    return diffFieldSet;
+  }
+
+  /**
+   * 格式化为千分位
+   * @param value
+   * @returns 12345.6789 => 12,345.6789
+   */
+  static fmtThousands(value: number | string | undefined): string {
+    if (value == undefined || value == null || isNaN(Number(value))) {
+      return String(value);
+    }
+    const [intPart, decimalPart] = String(value).split('.');
+    const formattedInt = intPart.replace(/\B(?=(\d{3})+(?!\d))/g, ',');
+    return decimalPart ? `${formattedInt}.${decimalPart}` : formattedInt;
+  }
+}

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "es2015",
+    "downlevelIteration": true,
+    "strict": true,
+    "declaration": true,
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "jsx": "react",
+    "baseUrl": "./",
+    "paths": {
+      "@@/*": [".dumi/tmp/*"],
+      "@zcrkey/js-utils": ["src"],
+      "@zcrkey/js-utils/*": ["src/*", "*"]
+    }
+  },
+  "include": [".dumirc.ts", "src/**/*", "docs/**/*"]
+}