yi-bi-ez-table 1.0.0

package/table-core.js

@@ -0,0 +1,620 @@
+import _ from "lodash";
+import { calcCurrentGroup, cloneDeepTree, convertToTree, getAlertConditionFn, getCalcValue, getCatchFunction, getDifferentTypeHeaderKeys, getImageDisplayName, pruneEmptyChildren, setSortDataList, } from "./utils";
+import { parseISO, startOfDay } from "date-fns";
+import { EZTableHeader } from "./table-header";
+import { EZTableHeaderKeys } from "./table-headerKeys";
+import { getCalcRowValue } from "./calc-measure/calc-measure-hander";
+import { calcSum, recursionForLastButTwo, recursionForParent, } from "./calc-measure/utils";
+import { calcAgg } from "./ez-agg-cunc-hander";
+import { setDisplayData } from "./setDisplayData";
+import { setMergeChildren } from "./setMergeData";
+import { setBindDimChildren, setSortOfBindDim } from "./setBindDim";
+import { ONCE_CALC_LIST } from "./constants";
+export class EZTable {
+    constructor() {
+        this.headers = [];
+        this.headersOfMerge = [];
+        this.headersOfBindDimVertical = [];
+        this.headerKeys = [];
+        this.headerKeysDic = {};
+        this.headerKeysOfMerge = [];
+        this.headerKeysOfBindDimVertical = [];
+        this.dimKeyList = [];
+        this.measureKeyList = [];
+        this.groupKeyList = [];
+        this.normalMeasureKeyList = [];
+        // 计算度量（排除累加等一次性算好全部底层数据的）
+        this.calcHeaderKeys = [];
+        // 累计等一次性算好全部底层数据的计算度量
+        this.accHeaderKeys = [];
+        // 依赖累加等一次性算好全部底层数据的计算度量
+        this.afterAccHeaderKeys = [];
+        this.firstDim = {};
+        this.allData = {
+            dataList: [],
+            tree: [],
+        };
+        this.currentData = {
+            dataList: [],
+            tree: [],
+        };
+        this.data = {
+            dataList: [],
+            tree: [],
+        };
+        // 预警标识
+        this.alertTask = undefined;
+    }
+    getData(config, itemWidth = 100) {
+        this.config = config;
+        const ezTableHeader = new EZTableHeader();
+        const { headers, headersOfMerge, headersOfBindDimVertical } = ezTableHeader.getAllHeaders(config);
+        this.headers = headers;
+        // 1.获取 headerKeys
+        const { headerKeys, headerKeysDic } = new EZTableHeaderKeys().getHeaderKeys(headers, itemWidth);
+        const { headerKeys: headerKeysOfMerge } = new EZTableHeaderKeys().getHeaderKeys(headersOfMerge, itemWidth);
+        const { headerKeys: headerKeysOfBindDimVertical } = new EZTableHeaderKeys().getHeaderKeys(headersOfBindDimVertical, itemWidth);
+        const { dimKeyList, measureKeyList, groupKeyList, normalMeasureKeyList } = getDifferentTypeHeaderKeys(headerKeys);
+        this.headerKeys = headerKeys;
+        this.headersOfMerge = headersOfMerge;
+        this.headersOfBindDimVertical = headersOfBindDimVertical;
+        this.headerKeysDic = headerKeysDic;
+        this.headerKeysOfMerge = headerKeysOfMerge;
+        this.headerKeysOfBindDimVertical = headerKeysOfBindDimVertical;
+        this.dimKeyList = dimKeyList;
+        this.measureKeyList = measureKeyList;
+        this.groupKeyList = groupKeyList;
+        this.normalMeasureKeyList = normalMeasureKeyList;
+        this.firstDim = dimKeyList[0];
+        const calcHeaderKeys = _.orderBy(headerKeys.filter((header) => (header.calcLevel === 0 || header.calcLevel > 0) && typeof header.accLevel !== 'number'), "calcLevel");
+        const calcDimKeys = [];
+        const calcMeasureKeys = [];
+        calcHeaderKeys.forEach(item => {
+            if (item.dimType) {
+                calcDimKeys.push(item);
+            }
+            else {
+                calcMeasureKeys.push(item);
+            }
+        });
+        this.calcHeaderKeys = calcMeasureKeys;
+        const accHeaderKeys = _.orderBy(headerKeys.filter((header) => header.accLevel === 0), 'calcLevel');
+        const afterAccHeaderKeys = _.orderBy(headerKeys.filter((header) => header.accLevel > 0), "accLevel");
+        this.accHeaderKeys = accHeaderKeys;
+        this.afterAccHeaderKeys = afterAccHeaderKeys;
+        // 2.转换为树结构（dataList 和 tree 里的 对象是同一个）
+        let dataList = config.dataList.map((item) => ({ data: item }));
+        // 2.1 计算条件维度
+        calcDimKeys.forEach((header) => {
+            this.calcTree(dataList, header);
+        });
+        let tree = convertToTree(dataList, this.groupKeyList, this.firstDim.key);
+        // 3.行计算（计算所有，包括累加，累加增加个排序方式，选择维度，选择升序降序，和排序一样的 ui）
+        this.calcRowOfAll(tree, dataList);
+        const displayHeaders = this.getDisplayHeader();
+        // 4.设置表头过滤（条件度量(字符类型)需要行计算后才能有值）
+        this.setCustomFilter(displayHeaders, dataList);
+        // 5.表头过滤（表头过滤后值不变，不再计算）
+        this.allData = {
+            tree: [...tree],
+            dataList: [...dataList],
+        };
+        tree = this.searchAll(this.allData.tree);
+        dataList = this.convertToList(tree);
+        this.currentData = {
+            tree,
+            dataList,
+        };
+        // 6.列计算
+        this.calcColOfAll(tree);
+        // 7.排序（如果有分组，则合计项排序）
+        this.setSort(config.sortList, tree, true);
+        // 8.headersOfMerge 或 headersOfBindDimVertical 处理
+        this.setMergeData();
+        // 9.维度绑定处理
+        this.setSortOfBindDim();
+        try {
+            // 10.预警计算
+            this.setAlertTask(config.alertTaskList);
+        }
+        catch (error) {
+            console.error(error);
+        }
+        // 11.计算显示样式
+        this.setDisplayData(tree);
+        return {
+            headers: this.getDisplayHeader(),
+            headerKeys: this.getDisplayHeaderKeys(),
+            dataTree: this.currentData.tree,
+            headerKeysDic: this.headerKeysDic,
+        };
+    }
+    getSearchData(headerSortList, rowLimit) {
+        let tree = cloneDeepTree(this.allData.tree);
+        tree = this.searchAll(tree);
+        // const dataList = this.convertToList(tree);
+        this.calcColOfAll(tree);
+        this.setSort(headerSortList || this.config?.sortList, tree, true);
+        if (rowLimit > 0) {
+            tree[0].children = tree[0].children.slice(0, rowLimit);
+            // const newDataList = this.convertToList(tree);
+            this.calcColOfAll(tree);
+        }
+        this.setMergeData(tree);
+        this.setDisplayData(tree, true);
+        return tree;
+    }
+    getDisplayHeader() {
+        let headers = this.headers;
+        if (this.headersOfMerge.length) {
+            headers = this.headersOfMerge;
+        }
+        if (this.headersOfBindDimVertical?.length) {
+            headers = this.headersOfBindDimVertical;
+        }
+        return headers;
+    }
+    getDisplayHeaderKeys() {
+        let headerKeys = this.headerKeys;
+        if (this.headerKeysOfMerge.length) {
+            headerKeys = this.headerKeysOfMerge;
+        }
+        if (this.headerKeysOfBindDimVertical?.length) {
+            headerKeys = this.headerKeysOfBindDimVertical;
+        }
+        //按headers重新排序headerKeys
+        // const sortHeaderKeys = [];
+        // const headerKeysDic = {};
+        // headerKeys.forEach(h=>{
+        //   headerKeysDic[h.key] = h;
+        // });
+        // this.headers.forEach(list=>{
+        //   list.forEach(item=>{
+        //     if(!item.colspan||item.colspan<=1){
+        //       sortHeaderKeys.push(headerKeysDic[item.key]);
+        //     }
+        //   });
+        // });
+        //
+        // console.log(this.headers,headerKeys,headerKeysDic,sortHeaderKeys);
+        return headerKeys;
+    }
+    // convertToTree(dataList): ITreeData[] {
+    //   const groupKeyList = this.groupKeyList;
+    //   const root = {
+    //     children: [],
+    //     value: "合计",
+    //     data: { [this.firstDim.key]: "合计" },
+    //     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: any[], parent = null) => {
+    //     for (const item of list) {
+    //       delete item.nodeId;
+    //       item.parent = parent;
+    //       if (item.children?.length) {
+    //         makeTreeFn(item.children, item);
+    //       }
+    //     }
+    //   };
+    //   const tree: ITreeData[] = [root];
+    //   makeTreeFn(tree);
+    //   return tree;
+    // }
+    convertToList(tree) {
+        const list = [];
+        const loopTree = (treeData) => {
+            for (const data of treeData) {
+                if (data.children) {
+                    loopTree(data.children);
+                }
+                else {
+                    list.push(data);
+                }
+            }
+        };
+        loopTree(tree);
+        return list;
+    }
+    calcRowOfCItem(child, header) {
+        let value = getCalcRowValue({
+            header,
+            data: child,
+            headerKeysDic: this.headerKeysDic,
+        });
+        if (['IMAGE', 'LINK'].includes(header.dataType)) {
+            if (typeof value !== 'object') {
+                value = {
+                    title: value,
+                    href: value,
+                };
+            }
+            child.data[header.key] = value?.title;
+            if (!child.link) {
+                child.link = {};
+            }
+            child.link[header.key] = value;
+            return;
+        }
+        child.data[header.key] = value;
+    }
+    calcTree(list, header) {
+        for (const data of list) {
+            if (data.children) {
+                this.calcTree(data.children, header);
+            }
+            else {
+                this.calcRowOfCItem(data, header);
+            }
+        }
+    }
+    calcAccOfRow(dataList, tree) {
+        for (const accHeader of this.accHeaderKeys) {
+            getCalcRowValue({
+                header: accHeader,
+                dataList,
+                firstDim: this.firstDim,
+                // data: child,
+                headerKeysDic: this.headerKeysDic,
+                tree,
+            });
+        }
+    }
+    calcRowOfAll(tree, dataList) {
+        // 普通度量求和
+        calcSum(tree, this.normalMeasureKeyList);
+        // 1.先计算普通计算度量（不包括累加等一次性算好全部的）
+        this.calcHeaderKeys.forEach((header) => {
+            this.calcTree(tree, header);
+        });
+        // 2.计算累加等一次性算好全部的计算度量
+        this.calcAccOfRow(dataList, tree);
+        // 3.最后计算依赖累加等一次性算好全部的计算度量
+        this.afterAccHeaderKeys.forEach((header) => {
+            if (ONCE_CALC_LIST.includes(header.measureType)) {
+                getCalcRowValue({
+                    header,
+                    dataList,
+                    firstDim: this.firstDim,
+                    // data: child,
+                    headerKeysDic: this.headerKeysDic,
+                    tree,
+                });
+            }
+            else {
+                this.calcTree(tree, header);
+            }
+        });
+    }
+    getAggFunc(header, data) {
+        const { groupAggFunc } = header;
+        let func = header.totalCalculate;
+        let aggRange = null;
+        if (data.parent && groupAggFunc?.aggFunc) {
+            func = groupAggFunc.aggFunc;
+        }
+        if (!data.parent) {
+            aggRange = header.aggRange;
+        }
+        const c = groupAggFunc?.conditionList.find(item => item.dimList.includes(data.totalType));
+        if (c) {
+            func = c.aggFunc;
+            if (c.dimList?.length === 1 && c.aggRange !== 'GLOBAL') {
+                aggRange = c.aggRange;
+            }
+        }
+        return {
+            func,
+            aggRange,
+        };
+    }
+    recursiveCalc(header, tree) {
+        recursionForParent(tree, (item) => {
+            const { func, aggRange } = this.getAggFunc(header, item);
+            item.data[header.key] = calcAgg({
+                // aggKey: header.totalCalculate as TAggFunc,
+                aggKey: func,
+                aggRange,
+                calcKey: header.key,
+                header,
+                headerKeysDic: this.headerKeysDic,
+                dataList: item.children,
+                data: item,
+            });
+        });
+    }
+    calcAccOfCol(tree, customList, calcList) {
+        if (calcList.length) {
+            calcList.forEach((header) => {
+                this.recursiveCalc(header, tree);
+            });
+        }
+        for (const header of customList) {
+            calcAgg({
+                aggKey: header.totalCalculate,
+                calcKey: header.key,
+                header,
+                headerKeysDic: this.headerKeysDic,
+                tree,
+            });
+        }
+    }
+    getAccTypeListOfCol() {
+        const customList = [];
+        const calcList = [];
+        this.accHeaderKeys.forEach((header) => {
+            if (header.totalCalculate === 'CUSTOM') {
+                customList.push(header);
+            }
+            else {
+                calcList.push(header);
+            }
+        });
+        return {
+            customList,
+            calcList,
+        };
+    }
+    calcColOfAll(tree) {
+        calcCurrentGroup(tree, this.measureKeyList);
+        // 1.先计算普通度量和普通计算度量（不包括累加等一次性算好全部的）
+        [...this.normalMeasureKeyList, ...this.calcHeaderKeys].forEach((header) => {
+            this.recursiveCalc(header, tree);
+        });
+        // 2.计算累加等一次性算好全部的计算度量
+        const { customList, calcList } = this.getAccTypeListOfCol();
+        this.calcAccOfCol(tree, customList, calcList);
+        // 3.最后计算依赖累加等一次性算好全部的计算度量
+        this.afterAccHeaderKeys.forEach((header) => {
+            if (ONCE_CALC_LIST.includes(header.measureType)) {
+                const itemCustomList = [];
+                const itemCalcList = [];
+                if (header.totalCalculate === 'CUSTOM') {
+                    itemCustomList.push(header);
+                }
+                else {
+                    itemCalcList.push(header);
+                }
+                this.calcAccOfCol(tree, itemCustomList, itemCalcList);
+            }
+            else {
+                this.recursiveCalc(header, tree);
+            }
+        });
+    }
+    searchAll(tree) {
+        tree = _.cloneDeep(tree);
+        // tree = cloneDeepTree(tree);
+        tree = this.stringSearch(tree);
+        tree = this.dateRangeSearch(tree);
+        tree = this.numberSearch(tree);
+        return tree;
+    }
+    stringSearch(tree) {
+        const hasFilterSelectedListHeaders = [];
+        const displayHeaders = this.getDisplayHeader();
+        displayHeaders.forEach((header) => {
+            header.forEach((hItem) => {
+                if (hItem.filterSelectedList && hItem.filterSelectedList.length) {
+                    hasFilterSelectedListHeaders.push(hItem);
+                }
+            });
+        });
+        recursionForLastButTwo(tree, (data) => {
+            data.children = this.getStringSearchList(data.children, hasFilterSelectedListHeaders);
+        });
+        tree = pruneEmptyChildren(tree);
+        return tree;
+    }
+    getStringSearchList(list, hasFilterSelectedListHeaders) {
+        return list?.filter((data) => {
+            return hasFilterSelectedListHeaders.every((header) => {
+                if (header.isNotIncludes) {
+                    return !header.filterSelectedList.includes(header.isProductImage
+                        ? getImageDisplayName(data.data[header.key])
+                        : data.data[header.key]);
+                }
+                return header.filterSelectedList.includes(header.isProductImage
+                    ? getImageDisplayName(data.data[header.key])
+                    : data.data[header.key]);
+            });
+        });
+    }
+    dateRangeSearch(tree) {
+        const hasFilterSelectedListHeaders = [];
+        const displayHeaders = this.getDisplayHeader();
+        displayHeaders.forEach((header) => {
+            header.forEach((hItem) => {
+                if (hItem.dateRange && (hItem.dateRange[0] || hItem.dateRange[1])) {
+                    hasFilterSelectedListHeaders.push(hItem);
+                }
+            });
+        });
+        recursionForLastButTwo(tree, (data) => {
+            data.children = this.getDateSearchList(data.children, hasFilterSelectedListHeaders);
+        });
+        tree = pruneEmptyChildren(tree);
+        return tree;
+    }
+    getDateSearchList(list, hasFilterSelectedListHeaders) {
+        return list.filter((data) => {
+            return hasFilterSelectedListHeaders.every((header) => {
+                const [hStartDate, hEndDate] = header.dateRange;
+                let hStartTime = null;
+                let hEndTime = null;
+                if (hStartDate) {
+                    hStartTime = startOfDay(parseISO(hStartDate)).getTime();
+                }
+                if (hEndDate) {
+                    hEndTime = startOfDay(parseISO(hEndDate)).getTime();
+                }
+                const dataTime = startOfDay(parseISO(data.data[header.key])).getTime();
+                if (hStartTime && hEndTime) {
+                    return dataTime >= hStartTime && dataTime <= hEndTime;
+                }
+                if (hStartTime && !hEndTime) {
+                    return dataTime >= hStartTime;
+                }
+                if (!hStartTime && hEndTime) {
+                    return dataTime <= hEndTime;
+                }
+                return false;
+            });
+        });
+    }
+    numberSearch(tree) {
+        const hasFilterSelectedListHeaders = [];
+        const displayHeaders = this.getDisplayHeader();
+        displayHeaders.forEach((header) => {
+            header.forEach((hItem) => {
+                if (hItem.minNum ||
+                    hItem.minNum === 0 ||
+                    hItem.maxNum ||
+                    hItem.maxNum === 0) {
+                    hasFilterSelectedListHeaders.push(hItem);
+                }
+            });
+        });
+        recursionForLastButTwo(tree, (data) => {
+            data.children = this.getNumberSearchList(data.children, hasFilterSelectedListHeaders);
+        });
+        tree = pruneEmptyChildren(tree);
+        return tree;
+    }
+    getNumberSearchList(list, hasFilterSelectedListHeaders) {
+        return list.filter((data) => {
+            return hasFilterSelectedListHeaders.every((header) => {
+                const minNum = header.dataType === "PERCENT" ? header.minNum / 100 : header.minNum;
+                const maxNum = header.dataType === "PERCENT" ? header.maxNum / 100 : header.maxNum;
+                let d = data.data[header.key] || 0;
+                if (d === Infinity) {
+                    d = 0;
+                }
+                if ((header.minNum || header.minNum === 0) &&
+                    (header.maxNum || header.maxNum === 0)) {
+                    return d >= minNum && d <= maxNum;
+                }
+                if ((header.minNum || header.minNum === 0) &&
+                    !(header.maxNum || header.maxNum === 0)) {
+                    return d !== Infinity && d >= minNum;
+                }
+                if (!(header.minNum || header.minNum === 0) &&
+                    (header.maxNum || header.maxNum === 0)) {
+                    return d <= maxNum;
+                }
+                return false;
+            });
+        });
+    }
+    setSort(sortList, tree, isChangeList = false) {
+        if (sortList.length) {
+            recursionForParent(tree, (data) => {
+                setSortDataList(data.children, sortList, this.headerKeysDic, isChangeList);
+            });
+        }
+    }
+    setAlertTask(alertTaskList) {
+        if (alertTaskList?.length) {
+            const task = alertTaskList?.[0];
+            const dataList = this.allData.dataList;
+            let alert = false;
+            const fn = getAlertConditionFn(task.conditionList, this.headerKeys);
+            for (let i = 0, leng = dataList.length; i < leng; i++) {
+                const data = dataList[i];
+                const boolean = getCalcValue(getCatchFunction(fn), { data });
+                if (boolean) {
+                    alert = true;
+                    break;
+                }
+            }
+            this.alertTask = alert;
+        }
+    }
+    // 合并分日期/尺码
+    setMergeData(tree = this.currentData.tree) {
+        if (this.headersOfMerge?.length) {
+            setMergeChildren(tree, this.headerKeysOfMerge, this.headerKeysDic, this.dimKeyList);
+            recursionForParent(tree, (data) => {
+                setMergeChildren(data.children, this.headerKeysOfMerge, this.headerKeysDic, this.dimKeyList);
+            });
+        }
+    }
+    // 绑定维度，竖排数据处理
+    setSortOfBindDim() {
+        if (this.headersOfBindDimVertical?.length) {
+            // setBindDimChildren(this.currentData.tree, this.headerKeysOfBindDimVertical, this.headerKeysDic, this.dimKeyList)
+            setBindDimChildren(this.currentData.tree, this.headerKeysOfBindDimVertical);
+            recursionForParent(this.currentData.tree, (data) => {
+                setBindDimChildren(data.children, this.headerKeysOfBindDimVertical);
+            });
+        }
+        const hasBind = this.headerKeys.find(header => header.bindDimOfParent && header.bindDimOfParent.bindDimOrder && header.bindDimOfParent.bindDimOrderMeasureName?.length);
+        if (hasBind) {
+            setSortOfBindDim(this.headerKeys, this.headers, this.currentData.tree[0].data);
+        }
+    }
+    setDisplayData(tree, onlyTotal = false) {
+        const headerKeys = this.getDisplayHeaderKeys();
+        const dimList = this.dimKeyList;
+        // const { tree } = this.currentData;
+        setDisplayData(headerKeys, dimList, tree, onlyTotal);
+    }
+    setCustomFilter(headers, dataList) {
+        headers.forEach(header => {
+            header.forEach(h => {
+                if (h.customFilter) {
+                    h.filterVisible = false;
+                    h.filterSelectedList = h.filterSelectedList || [];
+                    const listOfFilter = [];
+                    const listOfMap = {};
+                    const allListOfFilter = [];
+                    const allListOfMap = {};
+                    dataList.forEach(item => {
+                        const value = h.isProductImage ? getImageDisplayName(item.data[h.key]) : item.data[h.key];
+                        if (listOfFilter.length <= 100) {
+                            if (!listOfMap[value]) {
+                                listOfFilter.push({
+                                    text: value,
+                                    value,
+                                });
+                                listOfMap[value] = true;
+                            }
+                        }
+                        if (!allListOfMap[value]) {
+                            allListOfFilter.push({
+                                text: value,
+                                value,
+                            });
+                            allListOfMap[value] = true;
+                        }
+                    });
+                    h.listOfFilter = listOfFilter;
+                    h.allListOfFilter = [...allListOfFilter];
+                }
+            });
+        });
+    }
+}