yi-bi-ez-table 1.0.0

package/utils.js

@@ -0,0 +1,910 @@
+import { addMonths, addYears, differenceInMonths, differenceInYears, format, parseISO } from "date-fns";
+import { CALCULATED_REGEX } from "./constants";
+import _ from "lodash";
+import BigNumber from "bignumber.js";
+export const DATA_TYPE_MAP = {
+    0: 'NUMBER',
+    1: 'STRING',
+    2: 'DATE',
+    '-1': 'IMAGE',
+    '-2': 'LINK',
+};
+export function transformChn(str) {
+    // 将单引号‘’都转换成'，将双引号“”都转换成"
+    str = str.replace(/\’|\‘/g, '\'').replace(/\“|\”/g, '"');
+    // 将中括号【】转换成[]，将大括号｛｝转换成{}, 将（）转换成()
+    str = str.replace(/\【/g, '[').replace(/\】/g, ']').replace(/\｛/g, '{').replace(/\｝/g, '}').replace(/\（/g, '(').replace(/\）/g, ')');
+    // 将逗号，转换成,，将：转换成:
+    str = str.replace(/，/g, ',').replace(/：/g, ':');
+    return str;
+}
+// 中文符号转换成英文符号
+export function chnToEn(chineseChar) {
+    const originalExpr = chineseChar;
+    const fields = originalExpr?.match(CALCULATED_REGEX);
+    let expr = transformChn(chineseChar);
+    if (fields?.length) {
+        fields.forEach(item => {
+            const str = transformChn(item);
+            // {变量} 中的转义转换回去
+            expr = expr.replaceAll(str, item);
+        });
+    }
+    return expr;
+}
+// 获取起止日期间的所有日期
+export function getDateList(startDate, endDate, formatStr = 'yyyy-MM-dd') {
+    const dateList = [];
+    const oneDay = 24 * 60 * 60 * 1000;
+    let s = startDate.getTime();
+    const e = endDate.getTime();
+    while (s <= e) {
+        dateList.push(format(new Date(s), formatStr));
+        s += oneDay;
+    }
+    return dateList;
+}
+// 获取起止年份间的所有年份
+export function getYearList(startYear, endYear, formatStr = 'yyyy') {
+    const years = differenceInYears(endYear, startYear);
+    const yearList = [];
+    for (let i = 0; i <= years; i++) {
+        yearList.push(format(addYears(startYear, i), formatStr));
+    }
+    return yearList;
+}
+// 获取起止月份间的所有月份
+export function getMonthList(startMonth, endMonth, formatStr = 'yyyy-MM') {
+    const months = differenceInMonths(endMonth, startMonth);
+    const monthList = [];
+    for (let i = 0; i <= months; i++) {
+        monthList.push(format(addMonths(startMonth, i), formatStr));
+    }
+    return monthList;
+}
+export function getMeasureDataType(data) {
+    if (data.measureType === 'CONDITION') {
+        if (data.hasOwnProperty('vtype')) {
+            return (DATA_TYPE_MAP[data.vtype] || 'STRING');
+        }
+        return 'STRING';
+    }
+    if (data.format && data.format.type === 'percent') {
+        return 'PERCENT';
+    }
+    if (data.expr) {
+        return 'NUMBER';
+    }
+    return (DATA_TYPE_MAP[data.vtype] || 'STRING');
+}
+export const getStyleType = (format) => {
+    if (format &&
+        ((format.type === 'percent' && (!format.styleType || format.styleType === 'progress')) ||
+            format.styleType === 'progress')) {
+        return 'progress';
+    }
+    if (format &&
+        format.showTrend &&
+        (format.type === 'number' ||
+            (format.type === 'percent' && format.styleType && format.styleType === 'trend'))) {
+        return 'trend';
+    }
+    return null;
+};
+export function getCatchFunction(expr) {
+    let func = null;
+    try {
+        func = new Function('data', expr);
+    }
+    catch (error) {
+        func = null;
+    }
+    return func;
+}
+// 表达式转函数体
+export function expr2FnBody(expr) {
+    return expr.includes('return') ? expr : `return ${expr}`;
+}
+export function deepRenameExprKey(measureList, isRenameExpr = true) {
+    // const deepRenameExpr = (list: Array<IDisplayMeasure>, oldExprKey: string, newExprKey: string) => {
+    //   if (list && list.length) {
+    //     const regex = new RegExp(_.escapeRegExp(oldExprKey), 'g');
+    //     list.forEach(item => {
+    //       if (item.expr && item.expr.includes(oldExprKey)) {
+    //         item.expr = item.expr.replace(regex, newExprKey);
+    //       } else if (item.isGroup && item.children && item.children.length) {
+    //         deepRenameExpr(item.children, oldExprKey, newExprKey);
+    //       }
+    //     });
+    //   }
+    // };
+    // const deepRenameExprKey = (list: Array<IDisplayMeasure>, exprKey: string) => {
+    //   if (list && list.length) {
+    //     list.forEach(item => {
+    //       if (!item.isGroup) {
+    //         let newExprKey = exprKey ? `${exprKey}[${item.displayName}` : item.displayName;
+    //         // const prefixArr = newExprKey.split('[');
+    //         // if (prefixArr && prefixArr.length) {
+    //         //   for (let i = 0, leng = prefixArr.length - 1; i < leng; i++) {
+    //         //     newExprKey += ']';
+    //         //   }
+    //         // }
+    //         newExprKey += ']'.repeat(newExprKey.split('[').length - 1);
+    //         if (newExprKey !== item.exprKey) {
+    //           const oldExprKey = item.exprKey;
+    //           item.exprKey = newExprKey;
+    //           if (isRenameExpr) {
+    //             deepRenameExpr(measureList, `{${oldExprKey}}`, `{${newExprKey}}`);
+    //           }
+    //         }
+    //       }
+    //       if (item.children && item.children.length) {
+    //         deepRenameExprKey(item.children, exprKey ? `${exprKey}[${item.displayName}` : item.displayName);
+    //       }
+    //     });
+    //   }
+    // };
+    // deepRenameExprKey(measureList, '');
+    deepChildrenOfRename(measureList, isRenameExpr, measureList, '');
+}
+function deepRenameExpr(list, oldExprKey, newExprKey) {
+    if (list && list.length) {
+        const regex = new RegExp(_.escapeRegExp(oldExprKey), 'g');
+        list.forEach(item => {
+            if (item.expr && item.expr.includes(oldExprKey)) {
+                item.expr = item.expr.replace(regex, newExprKey);
+            }
+            else if (item.isGroup && item.children && item.children.length) {
+                deepRenameExpr(item.children, oldExprKey, newExprKey);
+            }
+        });
+    }
+}
+function deepChildrenOfRename(measureList, isRenameExpr, list, exprKey) {
+    if (list && list.length) {
+        list.forEach(item => {
+            if (!item.isGroup) {
+                let newExprKey = exprKey ? `${exprKey}[${item.displayName}` : item.displayName;
+                // const prefixArr = newExprKey.split('[');
+                // if (prefixArr && prefixArr.length) {
+                //   for (let i = 0, leng = prefixArr.length - 1; i < leng; i++) {
+                //     newExprKey += ']';
+                //   }
+                // }
+                newExprKey += ']'.repeat(newExprKey.split('[').length - 1);
+                if (newExprKey !== item.exprKey) {
+                    const oldExprKey = item.exprKey;
+                    item.exprKey = newExprKey;
+                    if (isRenameExpr) {
+                        deepRenameExpr(measureList, `{${oldExprKey}}`, `{${newExprKey}}`);
+                    }
+                }
+            }
+            if (item.children && item.children.length) {
+                deepChildrenOfRename(measureList, isRenameExpr, item.children, exprKey ? `${exprKey}[${item.displayName}` : item.displayName);
+            }
+        });
+    }
+}
+export function getStyleConditionFn(style, conditionList, key, dataType) {
+    conditionList = _.cloneDeep(conditionList);
+    let fn = `
+    let style = {
+      color: "${style.color}",
+      backgroundColor: "${style.backgroundColor}",
+      fontWeight: "${style && style.bold ? 'bold' : null}",
+      fontStyle: "${style && style.italic ? 'italic' : null}",
+      textDecoration: "${style && style.underline ? 'underline' : null}",
+      fontSize: "${style && style.fontSize ? (style.fontSize + 'px') : null}",
+      textAlign: "${style && style.horizontalAlign ? style.horizontalAlign : null}",
+      childStyle: {
+        textDecoration: "${style && style.strike ? 'line-through' : null}",
+      }
+    };
+    let value = data.data["${key}"];
+    if (!((value || value === 0) && value !== '-')) {
+      value = 0;
+    }
+  `;
+    let value = `(data.data["${key}"] || 0)`;
+    conditionList?.forEach(c => {
+        let isExpr = false;
+        if (c.value) {
+            let formual = c.value;
+            const fields = c.value?.match(CALCULATED_REGEX);
+            if (fields && fields.length) {
+                isExpr = true;
+                for (let fI = 0, fLeng = fields.length; fI < fLeng; fI++) {
+                    const f = fields[fI];
+                    const str = `(data.data[${'"' + (f.substring(1, f.length - 1)) + '"'}] || 0)`;
+                    formual = formual.replace(f, str);
+                }
+                c.value = formual;
+            }
+        }
+        if (!isExpr && dataType === 'DATE') {
+            c.value = format(new Date(c.value), 'yyyy-MM-dd');
+            value = format(new Date(`data.data["${key}"]`), 'yyyy-MM-dd');
+        }
+        let condition = ('"' + value + '"') + c.op + (!isExpr && isFinite(c.value) ? Number(c.value) : ('"' + c.value + '"'));
+        if (c.op !== 'expr') {
+            if (['NUMBER', 'PERCENT'].includes(dataType)) {
+                condition = (value) + c.op + (c.value);
+            }
+            if (dataType === 'STRING') {
+                // @ts-ignore
+                condition = (value) + c.op + ('"' + c.value + '"');
+            }
+        }
+        else if (dataType !== 'DATE') {
+            condition = c.value;
+        }
+        fn += `
+      if (${condition}) {
+        style = {
+          color: "${c.color}",
+          backgroundColor: "${c.backgroundColor}",
+          fontWeight: "${c && c.bold ? 'bold' : null}",
+          fontStyle: "${c && c.italic ? 'italic' : null}",
+          textDecoration: "${c && c.underline ? 'underline' : null}",
+          fontSize: "${c && c.fontSize ? (c.fontSize + 'px') : null}",
+          textAlign: "${c && c.horizontalAlign ? c.horizontalAlign : null}",
+          childStyle: {
+            textDecoration: "${c && c.strike ? 'line-through' : null}",
+          }
+        }
+      }
+    `;
+    });
+    fn += `
+    return style;
+  `;
+    return fn;
+}
+// 设置样式 computeFn
+export function setStyleComputeFn(header) {
+    // const { color, backgroundColor } = header;
+    const dataType = header.dataType;
+    header.styleComputeFn = getCatchFunction(getStyleConditionFn(header.style, header.styleConditionList, header.key, dataType));
+}
+// 数字计算 NaN，Infinity，-Infinity 返回 0
+export function getNotNaNValue(value) {
+    return Object.is(value, NaN) || [Infinity, -Infinity].includes(value) ? 0 : value;
+}
+// 函数计算
+export function getCalcValue(computeFn, data) {
+    let value = null;
+    try {
+        value = computeFn(data);
+    }
+    catch (error) {
+        console.log(error);
+    }
+    value = getNotNaNValue(value);
+    return value;
+}
+export function getSize(measure, data, headerKeysDic) {
+    const item = data.data;
+    const header = headerKeysDic[measure];
+    let size = '';
+    if (!item || !header || !header.groupList || !header.groupList.length) {
+        return size;
+    }
+    const index = header.groupList.indexOf(item['尺码组']);
+    const keys = header.key.split('[');
+    keys[keys.length - 1] = keys[keys.length - 1].replaceAll(']', '');
+    size = keys[index + 1];
+    size = size === 'null' ? '允许空' : size;
+    return size;
+}
+export function getDifferentTypeHeaderKeys(headerKeys) {
+    const dimKeyList = [];
+    const measureKeyList = [];
+    const groupKeyList = [];
+    const normalMeasureKeyList = [];
+    for (const h of headerKeys) {
+        if (h.type === 'DIM') {
+            dimKeyList.push(h);
+        }
+        if (h.type === 'MEASURE') {
+            measureKeyList.push(h);
+            if (!h.measureType || h.measureType === 'NORMAL') {
+                normalMeasureKeyList.push(h);
+            }
+        }
+        if (h.groupBy) {
+            groupKeyList.push(h);
+        }
+    }
+    return {
+        dimKeyList,
+        measureKeyList,
+        groupKeyList,
+        normalMeasureKeyList,
+    };
+}
+export const sortNotFinite = (aValue, bValue) => {
+    if (!isFinite(aValue) && isFinite(bValue)) {
+        return 1;
+    }
+    if (!isFinite(bValue) && isFinite(aValue)) {
+        return -1;
+    }
+    return 0;
+};
+function chineseNumToArabicNum(str) {
+    const numMap = {
+        '一': 1,
+        '二': 2,
+        '三': 3,
+        '四': 4,
+        '五': 5,
+        '六': 6,
+        '七': 7,
+        '八': 8,
+        '九': 9,
+        '十': 10,
+    };
+    const replacedStr = str.replace(/[一二三四五六七八九十]/g, (match) => numMap[match]);
+    const numbers = replacedStr.match(/\d+/g);
+    return {
+        replacedStr,
+        num: numbers ? Number(numbers.join('')) : null,
+    };
+}
+const chineseNum = ['一', '二', '三', '四', '五', '六', '七', '八', '九', '十'];
+export function setSortDataList(dataList, sortList, headerKeysDic, isChangeList = false) {
+    // const newDataList = isChangeList ? dataList : [...dataList];
+    // sortList?.forEach(sort => {
+    //   let key = '';
+    //   const displayNameList = [...sort.displayNameList];
+    //   if (sort.displayNameList && sort.displayNameList.length && ['维度', '度量'].includes(sort.displayNameList[0])) {
+    //     displayNameList.shift();
+    //   }
+    //   displayNameList?.forEach(item => {
+    //     key = key ? `${key}[${item}` : item;
+    //   });
+    //   for (let i = 0, leng = displayNameList?.length; i < leng - 1; i++) {
+    //     key += ']';
+    //   }
+    //   const dataType = headerKeysDic[key]?.dataType;
+    //   if (dataType) {
+    //     newDataList.sort((a, b) => {
+    //       let aValue = a.data[key];
+    //       let bValue = b.data[key];
+    //       if (['NUMBER', 'PERCENT'].includes(dataType)) {
+    //         switch (sort.value) {
+    //           case 'ascend':
+    //             const sortIsFiniteAscend = sortNotFinite(aValue, bValue);
+    //             if (sortIsFiniteAscend) {
+    //               return sortIsFiniteAscend;
+    //             }
+    //             return aValue - bValue;
+    //           case 'descend':
+    //             const sortIsFiniteDescend = sortNotFinite(aValue, bValue);
+    //             if (sortIsFiniteDescend) {
+    //               return sortIsFiniteDescend;
+    //             }
+    //             return bValue - aValue;
+    //           default:
+    //             return 0;
+    //         }
+    //       }
+    //       if (dataType === 'DATE') {
+    //         switch (sort.value) {
+    //           case 'ascend':
+    //             return parseISO(aValue).getTime() - parseISO(bValue).getTime();
+    //           case 'descend':
+    //             return parseISO(bValue).getTime() - parseISO(aValue).getTime();
+    //           default:
+    //             return 0;
+    //         }
+    //       }
+    //       if ((aValue || aValue === 0) && typeof aValue === 'number') {
+    //         aValue = `${aValue}`;
+    //       }
+    //       if ((bValue || bValue === 0) && typeof bValue === 'number') {
+    //         bValue = `${bValue}`;
+    //       }
+    //       let aIncludes = false;
+    //       for (const item of chineseNum) {
+    //         if (aValue?.includes(item)) {
+    //           aIncludes = true;
+    //           break;
+    //         }
+    //       }
+    //       let bIncludes = false;
+    //       for (const item of chineseNum) {
+    //         if (bValue?.includes(item)) {
+    //           bIncludes = true;
+    //           break;
+    //         }
+    //       }
+    //       const c = aValue;
+    //       if (aIncludes && bIncludes) {
+    //         aValue = chineseNumToArabicNum(aValue).num;
+    //         bValue = chineseNumToArabicNum(bValue).num;
+    //         return sort.value === 'ascend' ? aValue - bValue : bValue - aValue;
+    //         // return result;
+    //       }
+    //       switch (sort.value) {
+    //         case 'ascend':
+    //           return aValue?.localeCompare(bValue);
+    //         case 'descend':
+    //           return bValue?.localeCompare(aValue);
+    //         default:
+    //           return 0;
+    //       }
+    //     });
+    //   }
+    // });
+    const newDataList = isChangeList ? dataList : [...dataList];
+    newDataList.sort((a, b) => {
+        for (const sort of sortList) {
+            let key = '';
+            const displayNameList = [...sort.displayNameList];
+            if (sort.displayNameList && sort.displayNameList.length && ['维度', '度量'].includes(sort.displayNameList[0])) {
+                displayNameList.shift();
+            }
+            displayNameList?.forEach(item => {
+                key = key ? `${key}[${item}` : item;
+            });
+            for (let i = 0, leng = displayNameList?.length; i < leng - 1; i++) {
+                key += ']';
+            }
+            const dataType = headerKeysDic[key]?.dataType;
+            if (dataType) {
+                // let aValue = a.data?.[key] ?? a[key];
+                // let bValue = b.data?.[key] ?? b[key];
+                let aValue = getParentValue(a, headerKeysDic[key]);
+                let bValue = getParentValue(b, headerKeysDic[key]);
+                let result = 0;
+                if (['NUMBER', 'PERCENT'].includes(dataType)) {
+                    // result = sortNotFinite(aValue, bValue);
+                    // if (result !== 0) return result;
+                    aValue = aValue || 0;
+                    bValue = bValue || 0;
+                    result = sort.value === 'ascend' ? aValue - bValue : bValue - aValue;
+                }
+                else if (dataType === 'DATE') {
+                    const aTime = aValue ? (typeof aValue === 'number' ? aValue : parseISO(aValue).getTime()) : 0;
+                    const bTime = bValue ? (typeof bValue === 'number' ? bValue : parseISO(bValue).getTime()) : 0;
+                    // console.log('sort date',aTime,bTime);
+                    result = sort.value === 'ascend' ? aTime - bTime : bTime - aTime;
+                }
+                else {
+                    if ((aValue || aValue === 0) && typeof aValue === 'number') {
+                        aValue = `${aValue}`;
+                    }
+                    if ((bValue || bValue === 0) && typeof bValue === 'number') {
+                        bValue = `${bValue}`;
+                    }
+                    // let aIncludes = false;
+                    // for (const item of chineseNum) {
+                    //   if (aValue?.includes(item)) {
+                    //     aIncludes = true;
+                    //     break;
+                    //   }
+                    // }
+                    // let bIncludes = false;
+                    // for (const item of chineseNum) {
+                    //   if (bValue?.includes(item)) {
+                    //     bIncludes = true;
+                    //     break;
+                    //   }
+                    // }
+                    // const c = aValue;
+                    // if (aIncludes && bIncludes) {
+                    //   aValue = chineseNumToArabicNum(aValue).num;
+                    //   bValue = chineseNumToArabicNum(bValue).num;
+                    //   result = sort.value === 'ascend' ? aValue - bValue : bValue - aValue;
+                    // } else {
+                    result = sort.value === 'ascend' ? aValue?.localeCompare(bValue) : bValue?.localeCompare(aValue);
+                    // }
+                }
+                if (result !== 0)
+                    return result;
+            }
+        }
+        return 0;
+    });
+    const hasVertical = newDataList?.[0].same?.index || newDataList?.[0].same?.index === 0;
+    if (hasVertical) {
+        sameIndexSort(newDataList);
+    }
+    return newDataList;
+}
+function sameIndexSort(arr) {
+    const keysIndices = new Map(Array.from(new Set(arr.map(item => item.same.index))).map((key, i) => [key, i]));
+    const originalIndices = new Map(arr.map((item, i) => [item, i]));
+    arr.sort((a, b) => {
+        const aIndex = keysIndices.get(a.same.index);
+        const bIndex = keysIndices.get(b.same.index);
+        if (aIndex !== bIndex) {
+            return aIndex - bIndex;
+        }
+        return Number(originalIndices.get(a)) - Number(originalIndices.get(b));
+    });
+    return arr;
+    ;
+}
+export function getImageDisplayName(src) {
+    let name = src;
+    if (src?.includes('/')) {
+        name = src.split('/').pop();
+        if (name.includes('%2F')) {
+            name = name.split('%2F').pop();
+        }
+    }
+    return name;
+}
+// 删除 tree 中存在 children 属性但是 children 为空的节点
+export function pruneEmptyChildren(tree) {
+    for (let i = tree.length - 1; i >= 0; i--) {
+        const node = tree[i];
+        if (node.children) {
+            if (node.children.length === 0) {
+                tree.splice(i, 1);
+            }
+            else {
+                pruneEmptyChildren(node.children);
+                if (node.children.length === 0) {
+                    tree.splice(i, 1);
+                }
+            }
+        }
+    }
+    return tree;
+}
+export function calcCachedData(dataList, headerKeysDic, cachedData) {
+    const calcMaxAndMin = (dataList, headerKeysDic, cachedData) => {
+        for (const data of dataList) {
+            if (data.children && data.children.length) {
+                calcMaxAndMin(data.children, headerKeysDic, cachedData);
+            }
+            for (const key in cachedData) {
+                if (cachedData.hasOwnProperty(key)) {
+                    const header = headerKeysDic[key];
+                    const value = data.data[key];
+                    if (header && value !== undefined && value !== null) {
+                        if (header.measureType === 'MAX') {
+                            if (!cachedData[key].MAX || cachedData[key].MAX < value) {
+                                cachedData[key].MAX = value;
+                            }
+                        }
+                        if (header.measureType === 'MIN') {
+                            if (!cachedData[key].MIN || cachedData[key].MIN > value) {
+                                cachedData[key].MIN = value;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    };
+    calcMaxAndMin(dataList, headerKeysDic, cachedData);
+}
+function setCurrentGroup(tree, header) {
+    const { key, dataType } = header;
+    const groupDataByHeaderKey = (list) => {
+        for (const item of list) {
+            if (item.children?.length && item.children[0].children) {
+                groupDataByHeaderKey(item.children);
+            }
+            if (item.children) {
+                // let max = -Infinity;
+                // let min = Infinity;
+                let max = undefined;
+                let min = undefined;
+                // let total = 0;
+                // let totalNonZero = 0;
+                let childrenSum = 0;
+                let leng = 0;
+                let lengNonZero = 0;
+                for (const child of item.children) {
+                    let value = child.data[key];
+                    if (dataType === 'DATE' && value) {
+                        value = parseISO(value).getTime();
+                    }
+                    childrenSum += item.children.length && item.children[0].children ? child.current.sum[key] : (value || 0);
+                    leng += item.children.length && item.children[0].children ? child.current.leng[key] : 1;
+                    lengNonZero += item.children.length && item.children[0].children ? child.current.lengNonZero[key] : (value ? 1 : 0);
+                    let maxValue = item.children.length && item.children[0].children ? child.current.max[key] : value;
+                    let minValue = item.children.length && item.children[0].children ? child.current.min[key] : value;
+                    if (max === undefined || maxValue > max) {
+                        max = maxValue;
+                    }
+                    if (min === undefined || minValue < min) {
+                        min = minValue;
+                    }
+                }
+                if (!item.current) {
+                    item.current = {};
+                }
+                if (!item.current.sum) {
+                    item.current.sum = {};
+                }
+                if (!item.current.avg) {
+                    item.current.avg = {};
+                }
+                if (!item.current.avg_non_zero) {
+                    item.current.avg_non_zero = {};
+                }
+                if (!item.current.leng) {
+                    item.current.leng = {};
+                }
+                if (!item.current.lengNonZero) {
+                    item.current.lengNonZero = {};
+                }
+                if (!item.current.max) {
+                    item.current.max = {};
+                }
+                if (!item.current.min) {
+                    item.current.min = {};
+                }
+                item.current.max[key] = max;
+                item.current.min[key] = min;
+                item.current.sum[key] = childrenSum;
+                item.current.leng[key] = leng;
+                item.current.lengNonZero[key] = lengNonZero;
+                item.current.avg[key] = childrenSum / leng;
+                item.current.avg_non_zero[key] = childrenSum / lengNonZero;
+            }
+        }
+    };
+    groupDataByHeaderKey(tree);
+}
+// 计算每个分组的最大值、最小值、平均值、平均值非零
+export function calcCurrentGroup(tree, headerKeysList) {
+    for (const header of headerKeysList) {
+        setCurrentGroup(tree, header);
+    }
+}
+export function getSameLevelArrOfTotal(tree) {
+    // const sameLevelArr = [];
+    // const getSameLevel = (list, level: number = 0) => {
+    //   for (const item of list) {
+    //     if (item.children) {
+    //       if (!sameLevelArr[level]) {
+    //         sameLevelArr[level] = [];
+    //       }
+    //       sameLevelArr[level].push(item);
+    //       getSameLevel(item.children, level + 1);
+    //     }
+    //   }
+    // }
+    // getSameLevel(tree);
+    // return sameLevelArr;
+    return getSameLevel(tree);
+}
+const getSameLevel = (list, level = 0, sameLevelArr = []) => {
+    for (const item of list) {
+        if (item.children) {
+            if (!sameLevelArr[level]) {
+                sameLevelArr[level] = [];
+            }
+            sameLevelArr[level].push(item);
+            getSameLevel(item.children, level + 1, sameLevelArr);
+        }
+    }
+    return sameLevelArr;
+};
+export function getAlertConditionFn(conditionList, headerKeys) {
+    conditionList = _.cloneDeep(conditionList);
+    let expression = '';
+    conditionList?.forEach((c, i) => {
+        let isExpr = false;
+        if (c.value) {
+            let formual = c.value;
+            const fields = c.value?.match(CALCULATED_REGEX);
+            if (fields && fields.length) {
+                isExpr = true;
+                for (let fI = 0, fLeng = fields.length; fI < fLeng; fI++) {
+                    const f = fields[fI];
+                    const str = `(data.data[${'"' + (f.substring(1, f.length - 1)) + '"'}] || 0)`;
+                    formual = formual.replace(f, str);
+                }
+                c.value = formual;
+            }
+        }
+        const header = headerKeys.find(item => item.key === c.displayName);
+        let value = `(data.data["${header.key}"] || 0)`;
+        if (!isExpr && header.dataType === 'DATE') {
+            c.value = format(new Date(c.value), 'yyyy-MM-dd');
+            value = format(new Date(`data.data["${header.key}"]`), 'yyyy-MM-dd');
+        }
+        let condition = ('"' + value + '"') + c.op + (!isExpr && isFinite(c.value) ? Number(c.value) : ('"' + c.value + '"'));
+        if (c.op !== 'expr') {
+            if (['NUMBER', 'PERCENT'].includes(header.dataType)) {
+                condition = (value) + c.op + (c.value);
+            }
+            if (header.dataType === 'STRING') {
+                // @ts-ignore
+                condition = (value) + c.op + ('"' + c.value + '"');
+            }
+        }
+        else if (header.dataType !== 'DATE') {
+            condition = c.value;
+        }
+        expression += i === 0 ? condition : ` && ${condition}`;
+    });
+    const fn = `
+    let boolean = false;
+    if (${expression}) {
+      boolean = true;
+    }
+    return boolean;
+  `;
+    return fn;
+}
+// 度量单位格式化
+export function getFormatUnit(num, unit) {
+    let newNum = Number(num);
+    switch (unit) {
+        case '万':
+            newNum = new BigNumber(newNum).dividedBy(10000).toNumber();
+            break;
+        case '百万':
+            newNum = new BigNumber(newNum).dividedBy(1000000).toNumber();
+            break;
+        case '亿':
+            newNum = new BigNumber(newNum).dividedBy(100000000).toNumber();
+            break;
+        default:
+            break;
+    }
+    return `${newNum}`;
+}
+/**
+ * 数字格式化
+ * num: 数字或字符串
+ * cent: 小数位数
+ * isThousand: 是否千分位
+ * 返回字符串
+ */
+export function formatNumber(num, cent, isThousand) {
+    let newNum = Number(num);
+    if (isNaN(newNum)) {
+        return `${num}`;
+    }
+    const sign = (Number(newNum) === (newNum = Math.abs(newNum)));
+    newNum = Math.floor(newNum * Math.pow(10, cent) + 0.50000000001);
+    let cents = newNum % Math.pow(10, cent);
+    newNum = Math.floor(newNum / Math.pow(10, cent)).toString();
+    cents = cents.toString();
+    while (cents.length < cent) {
+        cents = '0' + cents;
+    }
+    if (isThousand) {
+        for (let i = 0; i < Math.floor((newNum.length - (1 + i)) / 3); i++) {
+            newNum = newNum.substring(0, newNum.length - (4 * i + 3)) + ',' + newNum.substring(newNum.length - (4 * i + 3));
+        }
+    }
+    return cent > 0 ? (((sign) ? '' : '-') + newNum + '.' + cents) : (((sign) ? '' : '-') + newNum);
+}
+function deepCopy(obj) {
+    // 检查传入参数的类型
+    if (typeof obj !== "object" || obj === null) {
+        return obj; // 对于非对象类型直接返回
+    }
+    // 创建一个空对象或数组，用于存储深拷贝后的结果
+    const copy = Array.isArray(obj) ? [] : {};
+    for (let key in obj) {
+        if (key !== 'parent' && Object.prototype.hasOwnProperty.call(obj, key)) {
+            // 递归调用deepCopy进行深拷贝
+            copy[key] = deepCopy(obj[key]);
+        }
+    }
+    return copy;
+}
+export function cloneDeepTree(tree, parent = null) {
+    const copiedTree = [];
+    for (let i = 0; i < tree.length; i++) {
+        const node = tree[i];
+        const copiedNode = {
+            parent: parent
+        };
+        for (const key in node) {
+            if (key !== 'children' && key !== 'parent') {
+                const prop = node[key];
+                if (typeof prop === 'object' && prop !== null) {
+                    copiedNode[key] = deepCopy(prop);
+                }
+                else {
+                    copiedNode[key] = prop;
+                }
+            }
+        }
+        if (node.children?.length > 0) {
+            copiedNode.children = cloneDeepTree(node.children, copiedNode);
+        }
+        copiedTree.push(copiedNode);
+    }
+    return copiedTree;
+}
+export function getSameLevelList(data, aggRange) {
+    const list = [];
+    const stack = [];
+    if (data.children?.length) {
+        stack.push(...data.children);
+    }
+    while (stack.length) {
+        const item = stack.pop();
+        if (item.totalType === aggRange) {
+            list.push(item);
+        }
+        else if (item.children?.length) {
+            stack.push(...item.children);
+        }
+    }
+    return list;
+}
+export function convertToTree(dataList, groupKeyList, firstDimKey) {
+    // const groupKeyList = this.groupKeyList;
+    const root = {
+        children: [],
+        value: "合计",
+        data: { [firstDimKey]: "合计" },
+        totalType: 'TOTAL_SUMMARY',
+    };
+    const nodeMap = { root }; // 哈希表存储节点
+    for (const data of dataList) {
+        let currentNode = root;
+        let nodeId = "root";
+        for (let i = 0; i < groupKeyList.length; i++) {
+            const group = groupKeyList[i];
+            const value = data.data[group.key];
+            nodeId = `${nodeId}_${value}`;
+            let matchingNode = nodeMap[nodeId];
+            if (!matchingNode) {
+                matchingNode = {
+                    nodeId,
+                    value,
+                    children: [],
+                    data: { [group.key]: value },
+                    totalType: group.key,
+                };
+                currentNode.children.push(matchingNode);
+                nodeMap[nodeId] = matchingNode;
+            }
+            currentNode = matchingNode;
+        }
+        currentNode.children.push({ data: data.data });
+    }
+    const makeTreeFn = (list, parent = null) => {
+        for (const item of list) {
+            delete item.nodeId;
+            item.parent = parent;
+            if (item.children?.length) {
+                makeTreeFn(item.children, item);
+            }
+        }
+    };
+    const tree = [root];
+    makeTreeFn(tree);
+    return tree;
+}
+export function getWeekName(time, showZhou = false) {
+    let weekDay = ['星期天', '星期一', '星期二', '星期三', '星期四', '星期五', '星期六'];
+    if (showZhou) {
+        weekDay = ['周日', '周一', '周二', '周三', '周四', '周五', '周六'];
+    }
+    const myDate = new Date(Date.parse(time));
+    return weekDay[myDate.getDay()];
+}
+export function getParentValue(data, header) {
+    const key = header.key;
+    let value = data.data?.[key] ?? data[key];
+    if (header.type === 'MEASURE' || data.data.hasOwnProperty(key) || data.hasOwnProperty(key)) {
+        return value;
+    }
+    let parent = data.parent;
+    while (parent) {
+        value = parent.data?.[key];
+        if (parent.data?.hasOwnProperty(key)) {
+            break;
+        }
+        parent = parent.parent;
+    }
+    return value;
+}