yi-bi-ez-table 1.0.0

package/.idea/ez-table.iml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="WEB_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$">
+      <excludeFolder url="file://$MODULE_DIR$/.tmp" />
+      <excludeFolder url="file://$MODULE_DIR$/temp" />
+      <excludeFolder url="file://$MODULE_DIR$/tmp" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

package/.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/ez-table.iml" filepath="$PROJECT_DIR$/.idea/ez-table.iml" />
+    </modules>
+  </component>
+</project>

package/angular/formatNumber.js

@@ -0,0 +1,39 @@
+export function formatNumber(num, locale, digitsInfo) {
+    // const parts = digitsInfo.split('.')[1].split('-');
+    // const minFractionDigits = parseInt(parts[0]);
+    // const maxFractionDigits = parseInt(parts[1]);
+    // const format = {
+    //   style: 'decimal',
+    //   minimumFractionDigits: minFractionDigits,
+    //   maximumFractionDigits: maxFractionDigits,
+    // };
+    // return new Intl.NumberFormat(locale, format).format(num);
+    // return angularFormatNumber(num, locale, digitsInfo);
+    const parts = digitsInfo.split('.')[1].split('-');
+    const minDigits = parseInt(parts[0]);
+    const maxDigits = parseInt(parts[1]);
+    // 四舍五入到最大小数位
+    num = roundNumber(num, maxDigits);
+    const [integerPart, decimalPart] = num.toString().split('.');
+    // 千分位
+    const formattedInteger = integerPart.replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+    // 补充最小小数位
+    let formattedDecimal = decimalPart ? decimalPart : '';
+    while (formattedDecimal.length < minDigits) {
+        formattedDecimal += '0';
+    }
+    return decimalPart || minDigits > 0 ? `${formattedInteger}.${formattedDecimal}` : formattedInteger;
+}
+function roundNumber(num, scale) {
+    if (!("" + num).includes("e")) {
+        return +(Math.round((num + "e+" + scale)) + "e-" + scale);
+    }
+    else {
+        const arr = ("" + num).split("e");
+        let sig = "";
+        if (+arr[1] + scale > 0) {
+            sig = "+";
+        }
+        return +(Math.round((+arr[0] + "e" + sig + (+arr[1] + scale))) + "e-" + scale);
+    }
+}

package/angular/formatPercent.js

@@ -0,0 +1,4 @@
+import { formatNumber } from "./formatNumber";
+export function formatPercent(num, locale, digitsInfo) {
+    return formatNumber(num * 100, locale, digitsInfo) + '%';
+}

package/calc-measure/calc-measure-hander.js

@@ -0,0 +1,239 @@
+import { calcAgg } from "../ez-agg-cunc-hander";
+import { calcDateRangeSum, calculateAccumulation, getDateDate, getGroupSumExtra, getSumExtra, handleCalc, recursionForLastButTwo, setCustomRank, setGroupCalc, setGroupCustomRank, setGroupRank, setRank, } from "./utils";
+// export type TMeasureType = 'NORMAL' | 'SUM' | 'DIFFERENCE' | 'DIVISION' | 'RATE' | 'RATIO' | 'CUSTOM' | 'CONDITION' | 'DATE_RANGE_SUM' | 'CORRELATION' | 'GLOBAL_ACC' | 'GROUP_ACC' | 'MAX' | 'GROUP_MAX' | 'MIN' | 'GROUP_MIN' | 'AVG' | 'AVG_NON_ZERO' | 'GROUP_AVG' | 'GROUP_AVG_NON_ZERO' | 'CUSTOM_RANK' | 'GROUP_RATIO';export type TAggFunc = 'SUM' | 'MEDIAN' | 'AVG' | 'AVG_NON_ZERO' | 'MAX' | 'MIN' | 'COUNT' | 'DISTINC COUNT' | 'DISTINC_COUNT' | 'CUSTOM';
+// 计算度量
+const EZCalcMeasureHander = {
+    // 求和
+    'SUM': (params) => {
+        return handleCalc(params.header.computeFn, { data: params.data.data }, params.headerKeysDic);
+    },
+    // 差值
+    'DIFFERENCE': (params) => {
+        const newData = getDateDate(params);
+        return handleCalc(params.header.computeFn, { data: newData }, params.headerKeysDic);
+    },
+    // 比值
+    'DIVISION': (params) => {
+        return handleCalc(params.header.computeFn, { data: params.data.data }, params.headerKeysDic);
+    },
+    // 增长率
+    'RATE': (params) => {
+        return handleCalc(params.header.computeFn, { data: params.data.data }, params.headerKeysDic);
+    },
+    // 占比
+    'RATIO': (params) => {
+        const { header, data, headerKeysDic } = params;
+        const extra = {
+            sum: {},
+        };
+        if (header.sumKeyList?.length) {
+            extra.sum = {
+                ...extra.sum,
+                ...getSumExtra(header, data),
+            };
+        }
+        return handleCalc(header.computeFn, { data: data.data, extra }, headerKeysDic);
+    },
+    // 分组占比
+    'GROUP_RATIO': (params) => {
+        const { header, data, headerKeysDic } = params;
+        const extra = {
+            sum: {},
+        };
+        if (header.groupSumKeyList?.length) {
+            extra.sum = {
+                ...extra.sum,
+                ...getGroupSumExtra(header, data),
+            };
+        }
+        return handleCalc(header.computeFn, { data: data.data, extra }, headerKeysDic);
+    },
+    // 日期区间求和
+    'DATE_RANGE_SUM': (params) => {
+        const { header, data } = params;
+        return calcDateRangeSum(header, data.data);
+    },
+    // 全局累加
+    'GLOBAL_ACC': (params) => {
+        const { header, dataList, firstDim, headerKeysDic } = params;
+        const sortList = header.computeParam?.sortListOfAcc?.length ?
+            header.computeParam.sortListOfAcc :
+            [{
+                    displayNameList: ['维度', firstDim.key],
+                    value: 'ascend'
+                }];
+        const field = header.calcKeyList[0];
+        calculateAccumulation(dataList, header.key, field, sortList, headerKeysDic);
+    },
+    // 分组累加
+    'GROUP_ACC': (params) => {
+        const { header, tree, firstDim, headerKeysDic } = params;
+        const sortList = header.computeParam?.sortListOfAcc?.length ?
+            header.computeParam.sortListOfAcc :
+            [{
+                    displayNameList: ['维度', firstDim.key],
+                    value: 'ascend'
+                }];
+        const field = header.calcKeyList[0];
+        // calcGroupAcc(tree, header, field, sortList, headerKeysDic);
+        recursionForLastButTwo(tree, data => {
+            calculateAccumulation(data.children, header.key, field, sortList, headerKeysDic);
+        });
+    },
+    // 最大值
+    'MAX': (params) => {
+        const { header, dataList, data, tree } = params;
+        const headerKey = header.key;
+        const field = header.calcKeyList[0];
+        const max = calcAgg({
+            aggKey: 'MAX',
+            calcKey: field,
+            dataList: dataList,
+        });
+        dataList.forEach(item => {
+            item.data[headerKey] = max;
+        });
+    },
+    // 最小值
+    'MIN': (params) => {
+        const { header, dataList } = params;
+        const headerKey = header.key;
+        const field = header.calcKeyList[0];
+        const min = calcAgg({
+            aggKey: 'MIN',
+            calcKey: field,
+            dataList: dataList,
+        });
+        dataList.forEach(item => {
+            item.data[headerKey] = min;
+        });
+    },
+    // 分组最大值
+    'GROUP_MAX': (params) => {
+        const { header, tree } = params;
+        const field = header.calcKeyList[0];
+        setGroupCalc('MAX', header.key, field, tree);
+    },
+    // 分组最小值
+    'GROUP_MIN': (params) => {
+        const { header, tree } = params;
+        const field = header.calcKeyList[0];
+        setGroupCalc('MIN', header.key, field, tree);
+    },
+    // 平均值
+    'AVG': (params) => {
+        const { header, dataList } = params;
+        const headerKey = header.key;
+        const field = header.calcKeyList[0];
+        const value = calcAgg({
+            aggKey: 'AVG',
+            calcKey: field,
+            dataList: dataList,
+        });
+        dataList.forEach(item => {
+            item.data[headerKey] = value;
+        });
+    },
+    // 平均值非零
+    'AVG_NON_ZERO': (params) => {
+        const { header, dataList } = params;
+        const calcKey = header.key;
+        const field = header.calcKeyList[0];
+        const value = calcAgg({
+            aggKey: 'AVG_NON_ZERO',
+            calcKey: field,
+            dataList: dataList,
+        });
+        dataList.forEach(item => {
+            item.data[calcKey] = value;
+        });
+    },
+    // 分组平均值
+    'GROUP_AVG': (params) => {
+        const { header, tree } = params;
+        const field = header.calcKeyList[0];
+        setGroupCalc('AVG', header.key, field, tree);
+    },
+    // 分组平均值(非零)
+    'GROUP_AVG_NON_ZERO': (params) => {
+        const { header, tree } = params;
+        const field = header.calcKeyList[0];
+        setGroupCalc('AVG_NON_ZERO', header.key, field, tree);
+    },
+    // 全局降序排名
+    'GLOBAL_RANK_DESC': (params) => {
+        const { header, dataList } = params;
+        const headerKey = header.key;
+        const field = header.calcKeyList[0];
+        setRank('descend', dataList, headerKey, field, header.computeParam?.measureList);
+    },
+    // 全局升序排名
+    'GLOBAL_RANK_ASC': (params) => {
+        const { header, dataList } = params;
+        const headerKey = header.key;
+        const field = header.calcKeyList[0];
+        setRank('ascend', dataList, headerKey, field, header.computeParam?.measureList);
+    },
+    // 分组升序排名
+    'GROUP_RANK_ASC': (params) => {
+        const { header, tree } = params;
+        const headerKey = header.key;
+        const field = header.calcKeyList[0];
+        setGroupRank('ascend', headerKey, field, tree, header.computeParam?.measureList);
+    },
+    // 分组降序排名
+    'GROUP_RANK_DESC': (params) => {
+        const { header, tree } = params;
+        const headerKey = header.key;
+        const field = header.calcKeyList[0];
+        setGroupRank('descend', headerKey, field, tree, header.computeParam?.measureList);
+    },
+    // 自定义排名
+    'CUSTOM_RANK': (params) => {
+        const { header, dataList, tree } = params;
+        const { rankTarget, rankOrder, rankWay } = header.computeParam;
+        const headerKey = header.key;
+        const field = header.calcKeyList[0];
+        switch (rankTarget) {
+            case 'GLOBAL':
+                setCustomRank(rankOrder, rankWay, dataList, headerKey, field, header.computeParam?.measureList, header.computeParam?.rankDimList);
+                break;
+            case 'GROUP':
+                setGroupCustomRank(rankOrder, rankWay, tree, headerKey, field, header.computeParam?.measureList, header.computeParam?.rankDimList);
+                break;
+            default:
+                break;
+        }
+    },
+    'CUSTOM': (params) => {
+        const { header, data, headerKeysDic } = params;
+        const extra = {
+            sum: {},
+            header,
+        };
+        if (header.sumKeyList?.length) {
+            extra.sum = {
+                ...extra.sum,
+                ...getSumExtra(header, data),
+            };
+        }
+        if (header.groupSumKeyList?.length) {
+            extra.sum = {
+                ...extra.sum,
+                ...getGroupSumExtra(header, data),
+            };
+        }
+        const newData = getDateDate(params);
+        const value = handleCalc(header.computeFn, { data: newData, extra }, headerKeysDic);
+        return value;
+    },
+    'CONDITION': (params) => {
+        return EZCalcMeasureHander['CUSTOM'](params);
+    },
+};
+export function getCalcRowValue(params) {
+    if (EZCalcMeasureHander[params.header.measureType || params.header.dimType]) {
+        return EZCalcMeasureHander[params.header.measureType || params.header.dimType](params);
+    }
+    return undefined;
+}

package/calc-measure/utils.js

@@ -0,0 +1,384 @@
+import { format, addDays, differenceInDays } from "date-fns";
+import { calcAgg } from "../ez-agg-cunc-hander";
+import { convertToTree, getCalcValue, getDateList, setSortDataList } from "../utils";
+export function handleCalc(computeFn, data, headerKeysDic) {
+    //(window as any).getSize = measure => getSize(measure, data, headerKeysDic);
+    return getCalcValue(computeFn, data);
+}
+export function getTopData(item) {
+    let top = item;
+    const findTop = (data) => {
+        if (data?.parent) {
+            top = data.parent;
+            findTop(data.parent);
+        }
+    };
+    findTop(item);
+    return top;
+}
+export function calcDateRangeSum(header, initData) {
+    const headerDate = header.label;
+    const firstDate = format(addDays(new Date(headerDate), 1), 'yyyy-MM-dd');
+    const first = header.dateRangeSumList[0];
+    const second = header.dateRangeSumList[1];
+    const firstIndex = first.dateList.findIndex(d => d === headerDate);
+    const prefixI = first.key.indexOf(']');
+    const firstIndexOfKey = prefixI > -1 ? `${first.key.substring(0, prefixI)}[${first.dateList[firstIndex]}]${first.key.substring(prefixI)}` : `${first.key}[${first.dateList[firstIndex]}]`;
+    let lastIndex = firstIndex;
+    for (let i = firstIndex + 1, leng = first.dateList.length; i < leng; i++) {
+        const date = first.dateList[i];
+        const dateFirstKey = prefixI > -1 ? `${first.key.substring(0, prefixI)}[${date}]${first.key.substring(prefixI)}` : `${first.key}[${date}]`;
+        if (initData.data[dateFirstKey] || initData.data[dateFirstKey] === 0) {
+            lastIndex = i - 1;
+            break;
+        }
+        if (i === first.dateList.length - 1) {
+            // 标志结尾
+            lastIndex = -2;
+        }
+    }
+    let total = null;
+    if (initData.data[firstIndexOfKey] || initData.data[firstIndexOfKey] === 0) {
+        const dateList = getDateList(new Date(addDays(new Date(headerDate), 1)), lastIndex !== -2 ?
+            new Date(addDays(new Date(headerDate), lastIndex - firstIndex + 1)) :
+            new Date(second.dateList[second.dateList.length - 1]));
+        total = 0;
+        const secondPrefixI = second.key.indexOf(']');
+        dateList.forEach(d => {
+            const dateSecondKey = secondPrefixI > -1 ? `${second.key.substring(0, secondPrefixI)}[${d}]${second.key.substring(secondPrefixI)}` : `${second.key}[${d}]`;
+            total += (initData.data[dateSecondKey] || 0);
+        });
+        initData.data[header.key] = total;
+    }
+    return total;
+}
+const sumData = ({ sum = {}, children = [] }, key, accessor = d => d.sum[key] || 0) => {
+    return sum[key] = children.reduce((total, child) => total + accessor(child), 0);
+};
+const sumParent = (data, normalMeasureKeyList) => {
+    if (!data.parent.sum) {
+        data.parent.sum = {};
+    }
+    for (const header of normalMeasureKeyList) {
+        sumData(data.parent, header.key);
+    }
+    if (data.parent.parent && data.parent.parent.children[data.parent.parent.children - 1] === data.parent) {
+        sumParent(data.parent, normalMeasureKeyList);
+    }
+};
+export function calculateAccumulation(dataList, accKey, measureKey, sortList, headerKeysDic, inData = true) {
+    sortList = [...sortList].reverse();
+    const newDataList = setSortDataList(dataList, sortList, headerKeysDic);
+    let previousAccumulation = 0;
+    for (let leaf of newDataList) {
+        if (inData) {
+            leaf.data[accKey] = (leaf.data[measureKey] || 0) + previousAccumulation;
+            previousAccumulation = leaf.data[accKey] || 0;
+        }
+        else {
+            leaf[accKey] = (leaf[measureKey] || 0) + previousAccumulation;
+            previousAccumulation = leaf[accKey] || 0;
+        }
+    }
+}
+export function setGroupCalc(type, headerKey, calcKey, tree) {
+    recursionForLastButTwo(tree, data => {
+        const value = calcAgg({
+            aggKey: type,
+            calcKey,
+            dataList: data.children,
+        });
+        for (const child of data.children) {
+            child.data[headerKey] = value;
+        }
+    });
+}
+export function setRank(sortOrder, dataList, headerKey, calcKey, measureList) {
+    const newDataList = [...dataList];
+    newDataList.sort((a, b) => {
+        let aValue = a.data[calcKey] || 0;
+        let bValue = b.data[calcKey] || 0;
+        if (aValue === bValue && measureList?.length > 1) {
+            for (let i = 1, leng = measureList.length; i < leng; i++) {
+                const item = measureList[i];
+                aValue = a.data[item.value] || 0;
+                bValue = b.data[item.value] || 0;
+                if (aValue !== bValue) {
+                    break;
+                }
+            }
+        }
+        return sortOrder === 'ascend' ? aValue - bValue : bValue - aValue;
+    });
+    newDataList.forEach((item, index) => {
+        item.data[headerKey] = index + 1;
+    });
+}
+export function setGroupRank(type, headerKey, calcKey, tree, measureList) {
+    recursionForLastButTwo(tree, data => {
+        setRank(type, data.children, headerKey, calcKey, measureList);
+    });
+}
+export function setCustomRank(sortOrder, rankWay, dataList, headerKey, calcKey, measureList, rankDimList) {
+    // let newDataList = [...dataList];
+    if (rankDimList?.length) {
+        const tree = convertToTree(dataList, rankDimList.map(item => ({ key: item })), '总合计');
+        recursionForLastButTwo(tree, data => {
+            setCustomRankFunc(sortOrder, rankWay, data.children, headerKey, calcKey, measureList);
+        });
+        return;
+    }
+    setCustomRankFunc(sortOrder, rankWay, dataList, headerKey, calcKey, measureList);
+    // newDataList.sort((a, b) => {
+    //   let aValue = a.data[calcKey] || 0;
+    //   let bValue = b.data[calcKey] || 0;
+    //   if (aValue === bValue && measureList?.length > 1) {
+    //     for (let i = 1, leng = measureList.length; i < leng; i++) {
+    //       const item = measureList[i];
+    //       aValue = a.data[item.value] || 0;
+    //       bValue = b.data[item.value] || 0;
+    //       if (aValue !== bValue) {
+    //         break;
+    //       }
+    //     }
+    //   }
+    //   return sortOrder === 'ascend' ? aValue - bValue : bValue - aValue;
+    // });
+    // switch(rankWay) {
+    //   // 不并列
+    //   case 'NOT_ABREAST':
+    //     newDataList.forEach((item, index) => {
+    //       item.data[headerKey] = index + 1;
+    //     })
+    //     break;
+    //   // 间隔并列
+    //   case 'INTERVAL_ABREAST':
+    //     newDataList.forEach((item, index) => {
+    //       item.data[headerKey] = index + 1;
+    //       if (
+    //         index !== 0 &&
+    //         (item.data[calcKey] || 0) === (newDataList[index - 1][calcKey] || 0)
+    //       ) {
+    //         item.data[headerKey] = newDataList[index - 1][headerKey];
+    //       }
+    //     })
+    //     break;
+    //   // 连续并列
+    //   case 'CONTINUE_ABREAST':
+    //     newDataList.forEach((item, index) => {
+    //       if (index === 0) {
+    //         item[headerKey] = index + 1;
+    //       } else if (
+    //         index !== 0 &&
+    //         (item[calcKey] || 0) === (newDataList[index - 1][calcKey] || 0)
+    //       ) {
+    //         item[headerKey] = newDataList[index - 1][headerKey];
+    //       } else if (
+    //         index !== 0 &&
+    //         (item[calcKey] || 0) !== (newDataList[index - 1][calcKey] || 0)
+    //       ) {
+    //         item[headerKey] = newDataList[index - 1][headerKey] + 1;
+    //       }
+    //     })
+    //     break;
+    //   default:
+    //     break;
+    // }
+}
+export function setCustomRankFunc(sortOrder, rankWay, dataList, headerKey, calcKey, measureList) {
+    const newDataList = [...dataList];
+    newDataList.sort((a, b) => {
+        let aValue = a.data[calcKey] || 0;
+        let bValue = b.data[calcKey] || 0;
+        if (aValue === bValue && measureList?.length > 1) {
+            for (let i = 1, leng = measureList.length; i < leng; i++) {
+                const item = measureList[i];
+                aValue = a.data[item.value] || 0;
+                bValue = b.data[item.value] || 0;
+                if (aValue !== bValue) {
+                    break;
+                }
+            }
+        }
+        return sortOrder === 'ascend' ? aValue - bValue : bValue - aValue;
+    });
+    switch (rankWay) {
+        // 不并列
+        case 'NOT_ABREAST':
+            newDataList.forEach((item, index) => {
+                item.data[headerKey] = index + 1;
+            });
+            break;
+        // 间隔并列
+        case 'INTERVAL_ABREAST':
+            newDataList.forEach((item, index) => {
+                item.data[headerKey] = index + 1;
+                if (index !== 0 &&
+                    (item.data[calcKey] || 0) === (newDataList[index - 1].data[calcKey] || 0)) {
+                    item.data[headerKey] = newDataList[index - 1].data[headerKey];
+                }
+            });
+            break;
+        // 连续并列
+        case 'CONTINUE_ABREAST':
+            newDataList.forEach((item, index) => {
+                if (index === 0) {
+                    item.data[headerKey] = index + 1;
+                }
+                else if (index !== 0 &&
+                    (item.data[calcKey] || 0) === (newDataList[index - 1].data[calcKey] || 0)) {
+                    item.data[headerKey] = newDataList[index - 1].data[headerKey];
+                }
+                else if (index !== 0 &&
+                    (item.data[calcKey] || 0) !== (newDataList[index - 1].data[calcKey] || 0)) {
+                    item.data[headerKey] = newDataList[index - 1].data[headerKey] + 1;
+                }
+            });
+            break;
+        default:
+            break;
+    }
+}
+export function setGroupCustomRank(sortOrder, rankWay, tree, headerKey, calcKey, measureList, rankDimList) {
+    recursionForLastButTwo(tree, data => {
+        setCustomRank(sortOrder, rankWay, data.children, headerKey, calcKey, measureList, rankDimList);
+    });
+}
+// 获取倒数第二层的数据
+export function recursionForLastButTwo(tree, callback) {
+    const recursionFn = (list) => {
+        for (const item of list) {
+            if (item.children?.length && item.children[0].children) {
+                recursionFn(item.children);
+            }
+            else if (item.children?.length && !item.children[0].children) {
+                callback(item);
+            }
+        }
+    };
+    recursionFn(tree);
+}
+// 获取所有父节点，即合计行
+export function recursionForParent(tree, callback) {
+    const recursionFn = (list) => {
+        for (const item of list) {
+            // 如果有子节点，先递归计算子节点
+            if (item.children?.length && item.children[0].children) {
+                recursionFn(item.children);
+            }
+            // 计算当前节点的值
+            if (item.children) {
+                callback(item);
+            }
+        }
+    };
+    recursionFn(tree);
+}
+// 获取 sum({销售数量}) 的值
+export function getSumExtra(header, data) {
+    const sum = {};
+    if (header.sumKeyList?.length) {
+        header.sumKeyList.forEach(sumKey => {
+            const topData = getTopData(data);
+            // 处理占比依赖其他计算度量的和的情况
+            if (!topData.sum || topData.sum[sumKey] === undefined) {
+                calcSum([topData], [{ key: sumKey }]);
+            }
+            sum[sumKey] = topData.sum?.[sumKey];
+        });
+    }
+    return sum;
+}
+// 获取分组占比合计值的 data
+function getGroupParent(data, groupTotal) {
+    if (data.totalType === groupTotal) {
+        return data;
+    }
+    if (data.parent) {
+        return getGroupParent(data.parent, groupTotal);
+    }
+}
+// 获取 group_sum({销售数量}) 的值
+export function getGroupSumExtra(header, data) {
+    const sum = {};
+    let parent = null;
+    if (header.computeParam?.groupByList?.length) {
+        const { computeParam: { groupByList } } = header;
+        let sumOfGroup = null;
+        sumOfGroup = data.children
+            ? groupByList.find(item => item.displayName === data.totalType)
+            : groupByList[groupByList.length - 1];
+        if (sumOfGroup?.groupTotal) {
+            parent = getGroupParent(data, sumOfGroup.groupTotal);
+        }
+    }
+    if (header.groupSumKeyList?.length) {
+        header.groupSumKeyList.forEach(sumKey => {
+            // 处理分组占比依赖其他计算度量的和的情况
+            if (!data.parent?.sum || data.parent.sum[sumKey] === undefined) {
+                const topData = getTopData(data);
+                calcSum([topData], [{ key: sumKey }]);
+            }
+            if (parent && (!parent.sum || parent.sum[sumKey] === undefined)) {
+                const topData = getTopData(parent);
+                calcSum([topData], [{ key: sumKey }]);
+            }
+            sum[sumKey] = data.parent ? data.parent.sum[sumKey] : data.sum[sumKey];
+            if (parent) {
+                sum[sumKey] = parent.sum[sumKey];
+            }
+        });
+    }
+    return sum;
+}
+function setTreeSum(tree, header) {
+    for (const node of tree) {
+        sumDataByHeaderKey(node, header);
+    }
+}
+function sumDataByHeaderKey(node, header) {
+    if (!node)
+        return 0;
+    const { key } = header;
+    let childrenSum = 0;
+    for (let child of node.children || []) {
+        childrenSum += sumDataByHeaderKey(child, header);
+    }
+    if (!node.children) {
+        return node.data[key] || 0;
+    }
+    else {
+        if (!node.sum) {
+            node.sum = {};
+        }
+        node.sum[key] = childrenSum;
+        return childrenSum;
+    }
+}
+export function calcSum(tree, headerKeysList) {
+    for (const header of headerKeysList) {
+        setTreeSum(tree, header);
+    }
+}
+export function getDateDate(params) {
+    const { header, data, headerKeysDic } = params;
+    const newData = { ...data.data };
+    const dateKeyList = [];
+    header.calcKeyList?.forEach(k => {
+        const h = headerKeysDic[k];
+        if (h?.dataType === 'DATE') {
+            dateKeyList.push(k);
+        }
+    });
+    if (dateKeyList?.length) {
+        dateKeyList.forEach(k => {
+            if (data.data[k]) {
+                newData[k] = differenceInDays(new Date(data.data[k]), new Date('1970-01-01'));
+            }
+            else {
+                newData[k] = undefined;
+            }
+        });
+    }
+    return newData;
+}