yi-bi-ez-table 1.0.0

package/table-header.js

@@ -0,0 +1,1680 @@
+import _ from 'lodash';
+import { chnToEn, getDateList, getYearList, getMonthList, getCatchFunction, expr2FnBody, getMeasureDataType, getWeekName } from './utils';
+import { CALCULATED_REGEX, RANK_TYPES } from './constants';
+import { deepRenameExprKey, getStyleType } from './utils';
+export class EZTableHeader {
+    constructor() {
+        this.getShowSizeExprKey = (measureList) => {
+            return measureList.filter(item => !item.expr && item.supportSize && item.showSize).map(item => item.exprKey);
+        };
+        this.checkMerge = (measureList, hasMergeGroup, dateRangeDicList, dateRangeDic, measureDic, measureSizeGroup, queryMeasureList) => {
+            if (!hasMergeGroup) {
+                return false;
+            }
+            let mergeGroupCount = 0;
+            let passed = false;
+            for (let i = 0, leng = measureList.length; i < leng; i++) {
+                const m = measureList[i];
+                if (m.isGroup && m.isMerge) {
+                    mergeGroupCount++;
+                    passed = this.checkMergeOfGroup(m.children || []);
+                }
+                else if (m.isGroup && !m.isMerge) {
+                    this.checkMerge(m.children || [], hasMergeGroup, dateRangeDicList, dateRangeDic, measureDic, measureSizeGroup, queryMeasureList);
+                }
+            }
+            if (mergeGroupCount > 1) {
+                // console.error('一张表只能有一个合并分日期的分组');
+                throw new Error('一张表只能有一个合并分日期的分组');
+            }
+            passed = mergeGroupCount === 1 && passed;
+            if (passed) {
+                for (let i = 0, leng = measureList.length; i < leng; i++) {
+                    const m = measureList[i];
+                    if (m.isGroup && m.isMerge) {
+                        // m.originalChildren = [...m.children];
+                        m.originalChildren = _.cloneDeep(m.children);
+                        this.setMergeGroup(m, dateRangeDicList, dateRangeDic, measureDic, measureSizeGroup, queryMeasureList);
+                        break;
+                    }
+                    else if (m.isGroup && !m.isMerge) {
+                        this.checkMerge(m.children || [], hasMergeGroup, dateRangeDicList, dateRangeDic, measureDic, measureSizeGroup, queryMeasureList);
+                    }
+                }
+            }
+            return passed;
+        };
+        this.deepSizeList = (children, isFirst, parentKeys = [], group, groupKey, sizeList = [], dataList, measureSizeKey, sizeGroupDic, measureSizeGroup, measureListDic) => {
+            if (children && children.length) {
+                children.forEach((child, i) => {
+                    // let key = this.getNewKey(child, [...parentKeys]);
+                    let key = this.getNewKey(child, _.cloneDeep(parentKeys));
+                    const firstLabel = parentKeys && parentKeys.length ? parentKeys[0] : key.substring(0, key.indexOf('['));
+                    if (!isFirst || i !== 0) {
+                        isFirst = false;
+                    }
+                    if (isFirst && i === 0) {
+                        dataList.forEach(data => data[key] = data.尺码组);
+                    }
+                    else if (!child.isGroup) {
+                        const groupStr = groupKey.split(']')[0];
+                        let count = groupStr.split('[').length;
+                        if (group.expr) {
+                            let expr = child.expr;
+                            const fields = expr?.match(CALCULATED_REGEX);
+                            if (fields && fields.length) {
+                                for (let fI = 0, leng = fields.length; fI < leng; fI++) {
+                                    let sizeArr = key.split(groupStr)[1].split('[').map(item => item.split(']')[0]).slice(1);
+                                    const field = fields[fI];
+                                    const sizeIndex = measureSizeKey.findIndex(item => item === field.substring(1, field.length - 1));
+                                    if (sizeList && sizeList.length) {
+                                        const f = field.substring(1, field.length - 1);
+                                        const sizeArrI = sizeArr.findIndex(s => s !== 'null');
+                                        if (sizeArrI === -1) {
+                                            continue;
+                                        }
+                                        const sizeI = sizeGroupDic[sizeList[sizeArrI]].findIndex(s => s === sizeArr[sizeArrI]);
+                                        const groupList = measureSizeGroup[f]?.sort();
+                                        const newSizeArr = [];
+                                        groupList?.forEach(g => {
+                                            if (sizeGroupDic[g]) {
+                                                newSizeArr.push(sizeGroupDic[g][sizeI]);
+                                            }
+                                        });
+                                        sizeArr = newSizeArr;
+                                    }
+                                    if (sizeIndex > -1) {
+                                        let k = measureSizeKey[sizeIndex].split(']')[0] + '[';
+                                        k = k.split(']')[0];
+                                        sizeArr.forEach((size, sizeI) => {
+                                            k += `${size + (sizeI === sizeArr.length - 1 ? '' : '[')}`;
+                                        });
+                                        count = k.split('[').length - 1;
+                                        k = k.padEnd(k.length + count, ']');
+                                        expr = expr.replace(field, `{${k}}`);
+                                    }
+                                }
+                            }
+                            child.expr = expr;
+                        }
+                        else {
+                            const sizeArr = key.split(groupStr)[1].split('[').map(item => item.split(']')[0]).slice(1);
+                            sizeArr.forEach((size, sizeI) => {
+                                let k = `${groupStr}[${size}`;
+                                k = k.padEnd(k.length + count, ']');
+                                dataList.forEach((data, dataI) => {
+                                    if (data[k] || data[k] === 0) {
+                                        const groupI = measureSizeGroup[firstLabel]?.indexOf(data.尺码组);
+                                        if (sizeI === groupI) {
+                                            if (child.displayName === '度量') {
+                                                let mKey = child.exprKey;
+                                                if (child.children && child.children.length === 1 && child.children[0].displayName === '度量') {
+                                                    mKey = child.children[0].exprKey;
+                                                }
+                                                // key = this.getNewKey({ displayName: data[mKey] }, [...parentKeys]);
+                                                key = this.getNewKey({ displayName: data[mKey] }, _.cloneDeep(parentKeys));
+                                                if (data.same?.index || data.same?.index === 0) {
+                                                    dataList.forEach((item, itemI) => {
+                                                        if (item.same?.index === data.same.index) {
+                                                            item[key] = data[k];
+                                                        }
+                                                    });
+                                                }
+                                            }
+                                            data[key] = data[k];
+                                        }
+                                    }
+                                });
+                            });
+                        }
+                        if (child.style?.conditionList?.length) {
+                            child.style = _.cloneDeep(child.style);
+                            child.style.conditionList.forEach(c => {
+                                if (c.op === 'expr') {
+                                    let expr = c.value;
+                                    const fields = _.uniq(expr.match(CALCULATED_REGEX));
+                                    if (fields && fields.length) {
+                                        for (let fI = 0, leng = fields.length; fI < leng; fI++) {
+                                            let sizeArr = key.split(groupStr)[1].split('[').map(item => item.split(']')[0]).slice(1);
+                                            const field = fields[fI];
+                                            const measureKey = field.substring(1, field.length - 1);
+                                            let sizeIndex = measureSizeKey.findIndex(item => item === measureKey);
+                                            if (sizeIndex < 0) {
+                                                const calcExprList = measureListDic[measureKey]?.expr?.match(CALCULATED_REGEX);
+                                                for (let i = 0; i < calcExprList?.length; i++) {
+                                                    let m = calcExprList[i];
+                                                    m = m.substring(1, m.length - 1);
+                                                    sizeIndex = measureSizeKey.findIndex(item => item === m);
+                                                    if (sizeIndex > -1) {
+                                                        const sizeArrI = sizeArr.findIndex(s => s !== 'null');
+                                                        if (sizeArrI === -1) {
+                                                            continue;
+                                                        }
+                                                        const sizeI = sizeGroupDic[sizeList[sizeArrI]].findIndex(s => s === sizeArr[sizeArrI]);
+                                                        const groupList = measureSizeGroup[m]?.sort();
+                                                        const newSizeArr = [];
+                                                        groupList?.forEach(g => {
+                                                            if (sizeGroupDic[g]) {
+                                                                newSizeArr.push(sizeGroupDic[g][sizeI]);
+                                                            }
+                                                        });
+                                                        sizeArr = newSizeArr;
+                                                        break;
+                                                    }
+                                                }
+                                            }
+                                            else if (sizeList && sizeList.length) {
+                                                const f = field.substring(1, field.length - 1);
+                                                const sizeArrI = sizeArr.findIndex(s => s !== 'null');
+                                                if (sizeArrI === -1) {
+                                                    continue;
+                                                }
+                                                const sizeI = sizeGroupDic[sizeList[sizeArrI]].findIndex(s => s === sizeArr[sizeArrI]);
+                                                const groupList = measureSizeGroup[f]?.sort();
+                                                const newSizeArr = [];
+                                                groupList?.forEach(g => {
+                                                    newSizeArr.push(sizeGroupDic[g][sizeI]);
+                                                });
+                                                sizeArr = newSizeArr;
+                                            }
+                                            if (sizeIndex > -1) {
+                                                // let k = measureSizeKey[sizeIndex].split(']')[0] + '[';
+                                                // k = k.split(']')[0];
+                                                let k = measureKey + '[';
+                                                sizeArr.forEach((size, sizeI) => {
+                                                    k += `${size + (sizeI === sizeArr.length - 1 ? '' : '[')}`;
+                                                });
+                                                count = k.split('[').length - 1;
+                                                k = k.padEnd(k.length + count, ']');
+                                                expr = expr.replace(field, `{${k}}`);
+                                            }
+                                        }
+                                    }
+                                    c.value = expr;
+                                    const computeExpr = c.value.replaceAll('{', '(data.data["').replaceAll('}', '"] || 0)');
+                                    c.computeFn = getCatchFunction(expr2FnBody(computeExpr));
+                                }
+                            });
+                        }
+                    }
+                    if (child.children && child.children.length) {
+                        this.deepSizeList(child.children, isFirst, [...parentKeys, child.displayName], group, groupKey, sizeList, dataList, measureSizeKey, sizeGroupDic, measureSizeGroup, measureListDic);
+                    }
+                });
+            }
+        };
+        this.setExprDateRange = (item, dateList, keyList) => {
+            if (!item.expr) {
+                return;
+            }
+            if (!dateList || Object.keys(dateList).length <= 0) {
+                return;
+            }
+            const children = [];
+            const valueList = [];
+            let keyOfMaxLeng = keyList[0];
+            keyList.forEach(k => {
+                const list = dateList[k];
+                valueList.push(list);
+                if (list.length > dateList[keyOfMaxLeng].length) {
+                    keyOfMaxLeng = k;
+                }
+            });
+            // @ts-ignore
+            const diff = valueList.length > 1 ? _.difference(...valueList) : [];
+            dateList[keyOfMaxLeng].forEach((d, dI) => {
+                const child = {
+                    ...item,
+                    displayName: diff && diff.length ? `${dI + 1}` : d,
+                    isGroup: false,
+                    mark: undefined,
+                };
+                if (item.expr) {
+                    let expr = item.expr;
+                    const fields = expr.match(CALCULATED_REGEX);
+                    fields?.forEach(field => {
+                        const count = field.split('[').length - 1;
+                        const key = keyList.find(k => `{${k}}` === field);
+                        if (key) {
+                            const j = key.indexOf(']');
+                            const date = dateList[key][dI];
+                            let k = key.substring(0, j > -1 ? j : undefined) + '[' + date + ']';
+                            k = k.padEnd(k.length + count, ']');
+                            expr = expr.replace(field, `{${k}}`);
+                        }
+                    });
+                    child.expr = expr;
+                }
+                children.push(child);
+            });
+            item.isGroup = true;
+            item.children = children;
+        };
+        this.setExprDateRangeOld = (item, dateList, keyList) => {
+            if (!item.expr) {
+                return;
+            }
+            const children = [];
+            dateList.forEach((d, dI) => {
+                const child = {
+                    ...item,
+                    displayName: d,
+                    isGroup: false,
+                    mark: undefined,
+                };
+                if (item.expr) {
+                    let expr = item.expr;
+                    const fields = expr.match(CALCULATED_REGEX);
+                    fields?.forEach(field => {
+                        const count = field.split('[').length - 1;
+                        const key = keyList.find(k => `{${k}}` === field);
+                        if (key) {
+                            const j = key.indexOf(']');
+                            let k = key.substring(0, j > -1 ? j : undefined) + '[' + d + ']';
+                            k = k.padEnd(k.length + count, ']');
+                            expr = expr.replace(field, `{${k}}`);
+                        }
+                    });
+                    child.expr = expr;
+                }
+                children.push(child);
+            });
+            item.isGroup = true;
+            item.children = children;
+        };
+        // 分时段
+        this.setHourMeasure = (queryMeasureList) => {
+            const hourMeasureKeys = [];
+            this.findHourMeasures(queryMeasureList, hourMeasureKeys);
+            this.findHoureRange(queryMeasureList, hourMeasureKeys);
+        };
+        this.findHoureRange = (measureList, hourMeasureKeys, parentKeys = []) => {
+            if (measureList && measureList.length) {
+                measureList.forEach((item, itemI) => {
+                    const time = this.findHourDateType(item);
+                    if (time) {
+                        const { start, end } = this.getHourStartAndEnd(time);
+                        const children = [];
+                        for (let i = start; i <= end; i++) {
+                            let name = `${i}`;
+                            name = name.length === 1 ? `0${name}` : name;
+                            const data = {
+                                ...item,
+                                dateType: undefined,
+                                isGroup: false,
+                                displayName: name,
+                                mark: undefined,
+                            };
+                            children.push(data);
+                        }
+                        item.isGroup = true;
+                        item.children = children;
+                    }
+                    else if (item.expr && !item.children) {
+                        const expr = item.expr;
+                        const hourList = [];
+                        const fields = expr.match(CALCULATED_REGEX);
+                        fields?.forEach((f, i) => {
+                            const k = f.substring(1, f.length - 1);
+                            const hourItem = hourMeasureKeys.find(h => h.key === k);
+                            if (hourItem) {
+                                for (let j = hourItem.start; j <= hourItem.end; j++) {
+                                    let name = `${j}`;
+                                    name = name.length === 1 ? `0${name}` : name;
+                                    if (!hourList.includes(name)) {
+                                        hourList.push(name);
+                                    }
+                                }
+                            }
+                        });
+                        if (hourList && hourList.length) {
+                            hourList.sort();
+                            hourMeasureKeys.push({
+                                key: item.exprKey,
+                                start: Number(hourList[0]),
+                                end: Number(hourList[hourList.length - 1])
+                            });
+                            const children = [];
+                            hourList.forEach(h => {
+                                let newExpr = item.expr;
+                                fields?.forEach((f, i) => {
+                                    const k = f.substring(1, f.length - 1);
+                                    const hourItem = hourMeasureKeys.find(h => h.key === k);
+                                    if (hourItem) {
+                                        newExpr = newExpr.replace(f, `{${this.getKey(hourItem.key, h)}}`);
+                                    }
+                                });
+                                children.push({
+                                    ...item,
+                                    expr: newExpr,
+                                    displayName: h,
+                                    mark: undefined,
+                                });
+                            });
+                            item.isGroup = true;
+                            item.children = children;
+                        }
+                    }
+                    else if (item.isGroup && item.children && item.children.length) {
+                        this.findHoureRange(item.children, hourMeasureKeys, [...parentKeys, item.displayName]);
+                    }
+                });
+            }
+        };
+        this.setMeasureWeekGroup = (value, group, queryMeasureList) => {
+            const weekMeasureKeys = [];
+            this.findWeekMeasure(value, queryMeasureList, weekMeasureKeys);
+            this.findWeekGroup(value, queryMeasureList, group, weekMeasureKeys);
+        };
+        this.getHeaderKey = (header, rowspan, suffixDic, groupByDimList, combineChildren, key, bindDimOfParent) => {
+            const isRank = RANK_TYPES.some(item => item.value === header.measureType);
+            if (isRank) {
+                // fixed 之前添加的排名增加了 aggFunc 导致报错的问题
+                delete header.aggFunc;
+            }
+            let subLabel = '';
+            if (suffixDic && key && suffixDic[key]) {
+                subLabel += `(${suffixDic[key]})`;
+            }
+            // const itemCalculate = isRank ? null : header.expr;
+            const itemCalculate = header.expr;
+            let h = {
+                rowspan,
+                label: header.displayName,
+                subLabel: subLabel || header.subLabel,
+                key: header.realKey || key,
+                dataType: header.dataType || getMeasureDataType(header),
+                customNumberFilter: header.vtype === 0 || !!(header.expr && header.measureType !== 'CONDITION'),
+                customDateFilter: header.vtype === 2,
+                customFilter: header.measureType === 'CONDITION',
+                format: header.format,
+                styleType: getStyleType(header.format),
+                itemCalculate,
+                totalCalculate: isRank ? 'CUSTOM' : (header.aggFunc || (header.vtype === 0 || !!header.expr ? 'SUM' : header.vtype ? 'MAX' : undefined)),
+                rank: isRank ? { measure: header.expr, type: header.measureType } : null,
+                measureType: header.measureType,
+                isHide: header.isHide,
+                backgroundColor: header.style && header.style.backgroundColor ? header.style.backgroundColor : null,
+                color: header.style && header.style.color ? header.style.color : null,
+                styleConditionList: header.style?.conditionList || null,
+                type: 'MEASURE',
+                width: header.width,
+                dateRangeSumList: header.dateRangeSumList,
+                mark: header.mark,
+                fixed: header.fixed,
+                groupList: header.groupList,
+                mergeCalcList: header.mergeCalcList,
+                groupAggFunc: header.groupAggFunc,
+                style: header.style,
+                bindDim: header.bindDim,
+                bindDimOrder: header.bindDimOrder,
+                bindDimOrderMeasureName: header.bindDimOrderMeasureName,
+                bindDimMeasureAlign: header.bindDimMeasureAlign,
+                code: header.code,
+                bindDimOfParent,
+                computeParam: header.computeParam,
+                aggRange: header.aggRange,
+            };
+            if (h.measureType === 'GROUP_RATIO' && h.computeParam?.groupByList?.length) {
+                h.computeParam.groupByList = h.computeParam.groupByList.filter(item => groupByDimList.some(g => g.displayName === item.displayName));
+            }
+            if (combineChildren && combineChildren.length) {
+                const action = combineChildren.find(child => {
+                    if (child.action &&
+                        child.action.anchor &&
+                        child.action.anchor.valueList &&
+                        child.action.anchor.valueList.length &&
+                        child.action.anchor.valueList[0] === '度量') {
+                        const valueList = [...child.action.anchor.valueList];
+                        valueList.shift();
+                        const m = {
+                            displayName: valueList.pop(),
+                        };
+                        const itemKey = this.getNewKey(m, valueList);
+                        // 处理绑定维度跳转问题
+                        if (h.bindDimOfParent) {
+                            if (valueList[0] === h.bindDimOfParent.code && m.displayName === h.label) {
+                                return true;
+                            }
+                        }
+                        if (itemKey === h.key) {
+                            return true;
+                        }
+                    }
+                });
+                if (action) {
+                    h.customDrill = true;
+                    h.action = action.action;
+                }
+            }
+            if (header.headerFilter) {
+                h = { ...h, ...header.headerFilter };
+            }
+            return h;
+        };
+        this.deepMeasureTree = (hideSizeGroup, measureList, rowSpan, i, parentKeys = [], groupKey = '', bindDimOfParent = null, params) => {
+            const { headers, queryMeasureList, hasMergeGroup, passedOfMergeGroup, dataList, suffixDic, groupByDimList, combineChildren, measureSizeGroup, hasVerticalOfBindDim, maxRowspan, } = params;
+            if (measureList && measureList.length) {
+                if (!headers[i]) {
+                    headers[i] = [];
+                }
+                let bindDimCode = null;
+                measureList.forEach((item, j) => {
+                    if (measureList === queryMeasureList) {
+                        bindDimOfParent = null;
+                    }
+                    if (!item.isGroup) {
+                        const key = this.getNewKey(item, parentKeys);
+                        // 设置合并分日期分组 -> 分尺码的数据格式，样式等
+                        if (hasMergeGroup && item.isMerge && passedOfMergeGroup && !item.dataType && item.originalChildren?.length) {
+                            dataList.forEach((data, dI) => {
+                                if (!data.dataType) {
+                                    data.dataType = {};
+                                }
+                                if (!data.format) {
+                                    data.format = {};
+                                }
+                                if (!data.style) {
+                                    data.style = {};
+                                }
+                                const h = item.originalChildren[dI % item.originalChildren.length];
+                                data.dataType[key] = data.dataType[item.exprKey];
+                                data.format[key] = h.format;
+                                data.style[key] = h.style;
+                            });
+                        }
+                        const headerItem = this.getHeaderKey(item, rowSpan, suffixDic, groupByDimList, combineChildren, key, bindDimOfParent);
+                        headers[i].push(headerItem);
+                        // 添加隐藏尺码组逻辑
+                        if (hideSizeGroup && item.isSizeGroup) {
+                            headerItem.isHide = true;
+                        }
+                    }
+                    else if (item.isGroup && item.children?.length) {
+                        let isHide = item.isHide;
+                        if (item.children && item.children.length) {
+                            isHide = this.getIsGroupHide(item.children);
+                        }
+                        // 添加隐藏尺码组逻辑
+                        if (hideSizeGroup && item.isSizeGroup) {
+                            isHide = true;
+                        }
+                        const isMerge = item.isGroup && item.isMerge;
+                        const header = {
+                            label: item.displayName,
+                            colspan: this.getColSpan(hideSizeGroup, item.children),
+                            realColspan: item.children?.length,
+                            isHide: item.isHide || isHide,
+                            mark: item.mark,
+                            isMerge,
+                            originalChildren: isMerge ? item.originalChildren : null,
+                            mergeChildren: isMerge ? item.children : null,
+                            width: item.width,
+                            style: item.style,
+                            bindDim: item.bindDim,
+                            bindDimOrder: item.bindDimOrder,
+                            bindDimOrderMeasureName: item.bindDimOrderMeasureName,
+                            bindDimMeasureAlign: item.bindDimMeasureAlign,
+                            code: item.code,
+                        };
+                        bindDimOfParent = header.bindDim ? {
+                            code: item.code,
+                            bindDim: header.bindDim,
+                            bindDimOrder: header.bindDimOrder,
+                            bindDimOrderMeasureName: header.bindDimOrderMeasureName,
+                            bindDimMeasureAlign: header.bindDimMeasureAlign,
+                            leng: header.realColspan,
+                        } : null;
+                        const headerKey = this.getNewKey(item, parentKeys);
+                        if (measureSizeGroup && measureSizeGroup[headerKey]) {
+                            header.showSize = true;
+                            header.groupKey = headerKey;
+                        }
+                        const timeRange = item.dateType?.find(d => d.type === 'TIME_RANGE');
+                        if (timeRange && timeRange.valueList && timeRange.valueList.length) {
+                            const dateValue = timeRange.valueList[0];
+                            header.isDateRange = dateValue === 1;
+                            header.isTimeRange = dateValue === 2;
+                            header.groupKey = headerKey;
+                        }
+                        if (hasVerticalOfBindDim && header.bindDimMeasureAlign === 'vertical') {
+                            header.colspan = header.realColspan = item.children.find(child => child.isGroup) ? item.children.length : 1;
+                            const lastChildren = this.deleteLastChildren(item);
+                            header.originalChildren = lastChildren.children;
+                            if (bindDimOfParent) {
+                                bindDimOfParent.originalChildren = lastChildren.children;
+                            }
+                            else {
+                                header.originalChildren = lastChildren.children;
+                            }
+                            if (!item.children || !item.children.length) {
+                                header.key = this.getNewKey(item, parentKeys);
+                                header.dataType = 'NUMBER';
+                            }
+                            if (bindDimCode !== header.code || (!bindDimOfParent && !bindDimCode && !headers[i].some(h => h.key === '度量'))) {
+                                headers.forEach(headerList => {
+                                    headerList.forEach(h => {
+                                        if (h.type === 'DIM' && h.rowspan > 1) {
+                                            h.rowspan--;
+                                        }
+                                    });
+                                });
+                                bindDimCode = header.code;
+                                headers[i].push({
+                                    label: '度量',
+                                    key: '度量',
+                                    dataType: 'STRING',
+                                    type: 'MEASURE',
+                                    rowspan: lastChildren.rowspan,
+                                    originalChildren: lastChildren.children,
+                                    isHide: headers[i].some(h => h.key === '度量' && h.label === '度量' && h.type === 'MEASURE' && h.originalChildren?.length),
+                                });
+                            }
+                        }
+                        headers[i].push(header);
+                        if (item.children && item.children.length) {
+                            const key = this.getNewKey(item, parentKeys);
+                            if (measureSizeGroup[key] && measureSizeGroup[key].length) {
+                                groupKey = key;
+                            }
+                            this.deepMeasureTree(hideSizeGroup, item.children, maxRowspan - i - 1, i + 1, [...parentKeys, item.displayName], groupKey, bindDimOfParent, params);
+                        }
+                    }
+                });
+            }
+        };
+        // setCustomFilter(headers: Array<Array<IHeaderKey>>, dataList: any[]): void {
+        //   headers.forEach(header => {
+        //     header.forEach(h => {
+        //       if (h.customFilter) {
+        //         h.filterVisible = false;
+        //         h.filterSelectedList = h.filterSelectedList || [];
+        //         const listOfFilter: Array<IListOfFilter> = [];
+        //         const listOfMap = {};
+        //         const allListOfFilter: Array<IListOfFilter> = [];
+        //         const allListOfMap = {};
+        //         dataList.forEach(item => {
+        //           const value = h.isProductImage ? getImageDisplayName(item[h.key]) : item[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];
+        //       }
+        //     });
+        //   });
+        // }
+    }
+    getAllHeaders(params) {
+        const { dimList, measureList, measureDic, measureSizeGroup, sizeGroupDic, dataList, suffixDic, dateRangeDic, combineChildren, } = params;
+        const measureListDic = {};
+        measureList.forEach(item => {
+            measureListDic[item.exprKey] = item;
+        });
+        const headers = this.getTableHeaders(measureDic, measureSizeGroup, sizeGroupDic, dataList, suffixDic, dimList, measureList, dateRangeDic, measureListDic, combineChildren);
+        let headersOfMerge = [];
+        const hasMergeGroup = measureList.some(item => item.isMerge);
+        if (hasMergeGroup) {
+            headersOfMerge = this.getTableHeaders(measureDic, measureSizeGroup, sizeGroupDic, dataList, suffixDic, dimList, measureList, dateRangeDic, measureListDic, combineChildren, true);
+        }
+        let headersOfBindDimVertical = [];
+        const hasVerticalOfBindDim = measureList.some(item => item.bindDimMeasureAlign === 'vertical');
+        if (hasVerticalOfBindDim) {
+            headersOfBindDimVertical = this.getTableHeaders(measureDic, measureSizeGroup, sizeGroupDic, dataList, suffixDic, dimList, measureList, dateRangeDic, measureListDic, combineChildren, false, true);
+        }
+        return {
+            headers,
+            headersOfMerge,
+            headersOfBindDimVertical,
+        };
+    }
+    getTableHeaders(measureDic, measureSizeGroup, sizeGroupDic, dataList, suffixDic, dimList, measureList, dateRangeDic, measureListDic, combineChildren, hasMergeGroup, hasVerticalOfBindDim) {
+        dimList[dimList.length - 1].groupBy = false;
+        return this.getHeaders(measureDic, dimList, measureList, measureSizeGroup, sizeGroupDic, dataList, suffixDic, dateRangeDic, measureListDic, combineChildren, hasMergeGroup, hasVerticalOfBindDim);
+    }
+    getHeaders(measureDic, dimList, queryMeasureList, measureSizeGroup, sizeGroupDic, dataList, suffixDic, dateRangeDic, measureListDic, combineChildren, hasMergeGroup, hasVerticalOfBindDim) {
+        const headers = [];
+        this.setMaxLengSizeList(measureSizeGroup);
+        this.initTree(queryMeasureList);
+        const dateRangekeys = Object.keys(dateRangeDic || {});
+        const dateRangeDicList = this.getDateRangeDicList(dateRangekeys, dateRangeDic);
+        const passedOfMergeGroup = this.checkMerge(queryMeasureList, hasMergeGroup, dateRangeDicList, dateRangeDic, measureDic, measureSizeGroup, queryMeasureList);
+        const measureSizeKey = Object.keys(measureSizeGroup || {});
+        this.setMeasureSize(queryMeasureList, measureSizeKey, measureSizeGroup);
+        const sizeDim = dimList.find(d => (d.dimCode === '尺码组' || d.displayName === '尺码组'));
+        const hideSizeGroup = sizeDim && sizeDim.paramList && sizeDim.paramList.length > 0 && sizeDim.paramList[0].valueList[0] === 3;
+        this.findMeasureGroup(hideSizeGroup, queryMeasureList, [], measureSizeGroup, sizeGroupDic, dataList, measureSizeKey, measureListDic);
+        // 分日期
+        this.findDateRangeDic(queryMeasureList, dateRangeDicList, dateRangekeys, dateRangeDic);
+        // 分时段dateType
+        this.setHourMeasure(queryMeasureList);
+        // 5 分自然周，6 分周次
+        this.setMeasureWeekGroup(5, measureDic?.measureWeekGroup, queryMeasureList);
+        this.setMeasureWeekGroup(6, measureDic?.measureSingleWeekGroup, queryMeasureList);
+        const maxRowspan = this.getRowSpan(queryMeasureList);
+        this.setDimHeader(dimList, headers, maxRowspan, combineChildren);
+        const groupByDimList = this.getGroupByDimList(dimList);
+        this.deepMeasureTree(hideSizeGroup, queryMeasureList, maxRowspan, 0, [], '', null, {
+            headers,
+            queryMeasureList,
+            hasMergeGroup,
+            passedOfMergeGroup,
+            dataList,
+            suffixDic,
+            groupByDimList,
+            combineChildren,
+            measureSizeGroup,
+            hasVerticalOfBindDim,
+            maxRowspan,
+        });
+        // this.setCustomFilter(headers, dataList)
+        // console.log('headers = ', JSON.parse(JSON.stringify(headers)))
+        // console.log('headers = ', headers);
+        return headers;
+    }
+    setMeasureSize(measureList, measureSizeKey, measureSizeGroup) {
+        measureList.forEach(item => {
+            if (item.expr) {
+                const keys = [];
+                measureSizeKey.forEach(sizeKey => {
+                    const reg = new RegExp(_.escapeRegExp(`{${sizeKey}}`), 'g');
+                    const sizeMatch = item.expr.match(reg);
+                    if (sizeMatch && sizeMatch.length) {
+                        const firstMatch = sizeMatch[0];
+                        const firstKey = firstMatch.substring(1, firstMatch.length - 1);
+                        keys.push(firstKey);
+                    }
+                });
+                const sizeList = [];
+                keys.forEach(k => {
+                    measureSizeGroup[k]?.forEach(size => {
+                        if (!sizeList.includes(size)) {
+                            sizeList.push(size);
+                        }
+                    });
+                });
+                if (sizeList && sizeList.length) {
+                    measureSizeGroup[item.exprKey] = sizeList;
+                    measureSizeKey.push(item.exprKey);
+                }
+            }
+        });
+    }
+    setMaxLengSizeList(measureSizeGroup) {
+        if (measureSizeGroup) {
+            let maxLengSizeList = [];
+            Object.keys(measureSizeGroup).forEach(item => {
+                maxLengSizeList = maxLengSizeList.concat(measureSizeGroup[item]);
+            });
+            maxLengSizeList = _.uniq(maxLengSizeList);
+            Object.keys(measureSizeGroup).forEach(item => {
+                measureSizeGroup[item] = maxLengSizeList;
+            });
+        }
+    }
+    getHourStartAndEnd(time) {
+        let [type, start, end] = time.valueList;
+        start = start || 0;
+        end = !end && end !== 0 ? 24 : end;
+        return {
+            start,
+            end,
+        };
+    }
+    findHourDateType(measure) {
+        let time = null;
+        if (!measure.isGroup && measure.dateType) {
+            time = measure.dateType.find(d => d.type === 'TIME_RANGE' && d.valueList && d.valueList.length && d.valueList[0] === 2);
+        }
+        return time;
+    }
+    initTree(measureList) {
+        if (measureList && measureList.length) {
+            measureList.forEach(item => {
+                if (item.isGroup && item.isHide && item.children?.length) {
+                    item.children.forEach(c => {
+                        if (!c.isHide) {
+                            c.isHide = true;
+                        }
+                    });
+                }
+                if (!item.isGroup && item.expr) {
+                    item.expr = chnToEn(item.expr);
+                }
+                else if (item.isGroup && item.children && item.children.length) {
+                    this.initTree(item.children);
+                }
+            });
+        }
+    }
+    getKey(key, name) {
+        let lastIndex = key.indexOf(']');
+        if (lastIndex === -1) {
+            lastIndex = key.length;
+        }
+        key = key.slice(0, lastIndex) + `[${name}]` + key.slice(lastIndex);
+        return key;
+    }
+    getNewKey(item, parentKeys = []) {
+        let key = item.displayName;
+        if (parentKeys.length) {
+            key = '';
+            parentKeys.forEach((p, pI) => {
+                if (pI === 0) {
+                    key = p;
+                }
+                else {
+                    key = this.getKey(key, p);
+                }
+            });
+            key = this.getKey(key, item.displayName);
+        }
+        return key;
+    }
+    getDateRangeDicList(dateRangekeys, dateRangeDic) {
+        const dateRangeDicList = {};
+        dateRangekeys?.forEach(k => {
+            if (dateRangeDic[k].startDate && dateRangeDic[k].endDate) {
+                const dateList = getDateList(new Date(dateRangeDic[k].startDate), new Date(dateRangeDic[k].endDate));
+                dateRangeDicList[k] = dateList;
+            }
+            if (dateRangeDic[k].startYear && dateRangeDic[k].endYear) {
+                const yearList = getYearList(new Date(dateRangeDic[k].startYear), new Date(dateRangeDic[k].endYear));
+                dateRangeDicList[k] = yearList;
+            }
+            if (dateRangeDic[k].startMonth && dateRangeDic[k].endMonth) {
+                const monthList = getMonthList(new Date(dateRangeDic[k].startMonth), new Date(dateRangeDic[k].endMonth));
+                dateRangeDicList[k] = monthList;
+            }
+        });
+        return dateRangeDicList;
+    }
+    getMergeGroupChildKey(measureList) {
+        return measureList.map(item => item.exprKey);
+    }
+    getDateTypeExprKey(measureList) {
+        return measureList.filter(item => !item.expr && item.dateType?.length).map(item => item.exprKey);
+    }
+    findDateType(measureList) {
+        let dateType = null;
+        const findItem = (list) => {
+            for (let i = 0, leng = list.length; i < leng; i++) {
+                const item = list[i];
+                if (!item.expr && item.dateType?.length && item.dateType.some(d => d.type === 'TIME_RANGE') && !dateType) {
+                    dateType = item.dateType.find(d => d.type === 'TIME_RANGE');
+                    return true;
+                }
+                else if (item.isGroup && item.children?.length && findItem(item.children)) {
+                    return true;
+                }
+            }
+        };
+        findItem(measureList);
+        return dateType;
+    }
+    findShowSize(measureList) {
+        let showSize = false;
+        const findItem = (list) => {
+            for (let i = 0, leng = list.length; i < leng; i++) {
+                const item = list[i];
+                if (!item.expr && !showSize) {
+                    showSize = item.supportSize && item.showSize;
+                    return true;
+                }
+                else if (item.isGroup && item.children?.length && findItem(item.children)) {
+                    return true;
+                }
+            }
+        };
+        findItem(measureList);
+        return showSize;
+    }
+    checkMergeOfGroup(measureList) {
+        let warningMessage = '';
+        const dateType = this.findDateType(measureList);
+        const showSize = this.findShowSize(measureList);
+        const mergeGroupChildKey = this.getMergeGroupChildKey(measureList);
+        const check = (list) => {
+            for (let i = 0, leng = list.length; i < leng; i++) {
+                const item = list[i];
+                if (!showSize) {
+                    if (!item.expr &&
+                        !item.isGroup &&
+                        item.dateType?.length &&
+                        !item.dateType.some(d => d.type === dateType.type && d.valueList[0] === dateType.valueList[0])) {
+                        warningMessage = '合并分日期的分组中的度量， 分日期方式须相同或都分尺码';
+                    }
+                    if (item.expr && !mergeGroupChildKey.some(k => item.expr.includes(k))) {
+                        warningMessage = '合并分日期的分组中的计算度量或条件度量， 须包含该分组下的度量';
+                    }
+                }
+                else {
+                    if (!item.expr &&
+                        !item.isGroup &&
+                        (!item.supportSize ||
+                            !item.showSize)) {
+                        warningMessage = '合并分日期的分组中的度量， 分日期方式须相同或都分尺码';
+                    }
+                    if (item.expr && !mergeGroupChildKey.some(k => item.expr.includes(k))) {
+                        warningMessage = '合并分日期的分组中的计算度量或条件度量， 须包含该分组下的度量';
+                    }
+                }
+            }
+        };
+        if (showSize || dateType) {
+            check(measureList);
+        }
+        if (warningMessage) {
+            throw new Error(warningMessage);
+        }
+        return !warningMessage;
+    }
+    // 设置合并分日期 分组的 children
+    setMergeGroup(m, dateRangeDicList, dateRangeDic, measureDic, measureSizeGroup, queryMeasureList) {
+        // const measureList = [...m.children];
+        const measureList = _.cloneDeep(m.children);
+        // const measureListLeng = measureList.length;
+        let exprKeyList = this.getDateTypeExprKey(measureList);
+        const showSize = this.findShowSize(measureList);
+        if (showSize) {
+            exprKeyList = this.getShowSizeExprKey(measureList);
+        }
+        const dateType = this.findDateType(measureList);
+        let exprKey = exprKeyList[0];
+        exprKey = exprKey?.substring(0, exprKey?.lastIndexOf('[') + 1) + '度量' + exprKey?.substring(exprKey?.indexOf(']'));
+        const firstChild = {
+            displayName: '度量',
+            vtype: 1,
+            fixed: m.groupFixed,
+            exprKey,
+        };
+        const children = [firstChild];
+        const childNotExpr = measureList.filter(item => !item.expr && !item.isGroup);
+        if (!showSize) {
+            if (dateType.type === 'TIME_RANGE' && dateType.valueList[0] === 1) {
+                // 分日期
+                const dateList = [];
+                exprKeyList.forEach(item => {
+                    dateRangeDicList[item]?.forEach(date => {
+                        if (!dateList.includes(date)) {
+                            dateList.push(date);
+                        }
+                    });
+                });
+                dateList.sort();
+                dateList.forEach(d => {
+                    children.push({
+                        displayName: d,
+                    });
+                });
+            }
+            else if (dateType.type === 'TIME_RANGE' && dateType.valueList[0] === 2) {
+                // 分时段
+                const hourList = [];
+                childNotExpr?.forEach(c => {
+                    const time = this.findHourDateType(c);
+                    if (time) {
+                        const { start, end } = this.getHourStartAndEnd(time);
+                        for (let h = start; h <= end; h++) {
+                            if (!hourList.includes(h)) {
+                                hourList.push(h);
+                            }
+                        }
+                    }
+                });
+                hourList.sort((a, b) => a - b);
+                hourList.forEach(d => {
+                    children.push({
+                        displayName: d,
+                    });
+                });
+            }
+            else if (dateType.type === 'TIME_RANGE' && dateType.valueList[0] === 3) {
+                // 分年份
+                const yearList = [];
+                exprKeyList.forEach(k => {
+                    const list = getYearList(new Date(dateRangeDic[k].startYear), new Date(dateRangeDic[k].endYear));
+                    list.forEach(year => {
+                        if (!yearList.includes(year)) {
+                            yearList.push(year);
+                        }
+                    });
+                });
+                yearList.sort();
+                yearList.forEach(d => {
+                    children.push({
+                        displayName: d,
+                    });
+                });
+            }
+            else if (dateType.type === 'TIME_RANGE' && dateType.valueList[0] === 4) {
+                // 分月份
+                const monthList = [];
+                exprKeyList.forEach(k => {
+                    const list = getMonthList(new Date(dateRangeDic[k].startMonth), new Date(dateRangeDic[k].endMonth));
+                    list.forEach(month => {
+                        if (!monthList.includes(month)) {
+                            monthList.push(month);
+                        }
+                    });
+                });
+                monthList.sort();
+                monthList.forEach(d => {
+                    children.push({
+                        displayName: d,
+                    });
+                });
+            }
+            else if (dateType.type === 'TIME_RANGE' && dateType.valueList[0] === 5) {
+                // 分自然周
+                const weekList = [];
+                exprKeyList.forEach(item => {
+                    measureDic?.measureWeekGroup[item].forEach(week => {
+                        if (!weekList.includes(week)) {
+                            weekList.push(week);
+                        }
+                    });
+                });
+                weekList.sort();
+                weekList.forEach(d => {
+                    children.push({
+                        displayName: d,
+                    });
+                });
+            }
+            else if (dateType.type === 'TIME_RANGE' && dateType.valueList[0] === 6) {
+                // 分周次
+                const weekList = [];
+                exprKeyList.forEach(item => {
+                    measureDic?.measureSingleWeekGroup[item].forEach(week => {
+                        if (!weekList.includes(week)) {
+                            weekList.push(week);
+                        }
+                    });
+                });
+                // 上市分析（/insight/product-launch）中不排序
+                if (!dateType.notSort) {
+                    weekList.sort();
+                }
+                weekList.forEach(d => {
+                    children.push({
+                        displayName: d,
+                    });
+                });
+            }
+        }
+        else {
+            // 分尺码
+            const groupList = [];
+            exprKeyList.forEach(item => {
+                measureSizeGroup[item]?.forEach(group => {
+                    if (!groupList.includes(group)) {
+                        groupList.push(group);
+                    }
+                });
+            });
+            groupList.sort();
+            m.isGroup = false;
+            measureSizeGroup[m.displayName] = groupList;
+        }
+        m.children = children;
+        deepRenameExprKey(queryMeasureList);
+    }
+    setSizeGroupChildren(deepCount, children, sizeI, size, data, groupList, sizeGroupDic, isSizeGroup) {
+        const child = children[sizeI];
+        if (!child.children) {
+            child.children = [];
+        }
+        // const deepChildren = (item: IDisplayMeasure, count: number) => {
+        //   if (count === deepCount) {
+        //     const pushData: any = { ...data, isGroup: false, displayName: size, mark: undefined, groupList };
+        //     if (sizeI === 0) {
+        //       pushData.expr = undefined;
+        //     }
+        //     // if (Object.keys(sizeGroupDic).includes(size)) {
+        //     //   pushData.dataType = 'STRING';
+        //     // }
+        //     if (sizeGroupDic[size]) {
+        //       pushData.dataType = 'STRING';
+        //     }
+        //     item.children = [pushData];
+        //     item.isGroup = true;
+        //     delete item.headerKey;
+        //     return false;
+        //   }
+        //   if (deepChildren(item.children[0], count + 1)) {
+        //     return true;
+        //   }
+        // };
+        this.deepChildrenOfSizeGroup(child, 0, deepCount, data, size, sizeI, groupList, sizeGroupDic, isSizeGroup);
+    }
+    deepChildrenOfSizeGroup(item, count, deepCount, data, size, sizeI, groupList, sizeGroupDic, isSizeGroup) {
+        if (count === deepCount) {
+            // 隐藏分尺码的尺码组逻辑 isSizeGroup
+            const pushData = { ...data, isGroup: false, displayName: size, mark: undefined, groupList, isSizeGroup };
+            if (sizeI === 0) {
+                pushData.expr = undefined;
+                pushData.aggFunc = 'NOT_SHOW';
+            }
+            // if (Object.keys(sizeGroupDic).includes(size)) {
+            //   pushData.dataType = 'STRING';
+            // }
+            if (sizeGroupDic[size]) {
+                pushData.dataType = 'STRING';
+            }
+            item.children = [pushData];
+            item.isGroup = true;
+            delete item.headerKey;
+            return false;
+        }
+        if (this.deepChildrenOfSizeGroup(item.children[0], count + 1, deepCount, data, size, sizeI, groupList, sizeGroupDic, isSizeGroup)) {
+            return true;
+        }
+    }
+    setSizeDataList(group, groupKey, sizeList = [], dataList, measureSizeKey, sizeGroupDic, measureSizeGroup, measureListDic) {
+        this.deepSizeList(group.children, true, [groupKey], group, groupKey, sizeList, dataList, measureSizeKey, sizeGroupDic, measureSizeGroup, measureListDic);
+    }
+    setSizeGroup(hideSizeGroup, item, key, measureSizeGroup, sizeGroupDic, sizeList) {
+        const children = [];
+        let maxLeng = 0;
+        const groupList = (sizeList || measureSizeGroup[key]).sort();
+        groupList.forEach(g => {
+            if (sizeGroupDic[g] && sizeGroupDic[g].length) {
+                maxLeng = Math.max(maxLeng, sizeGroupDic[g].length);
+            }
+        });
+        const originChildren = item.children;
+        groupList.forEach((g, gI) => {
+            if (gI === 0) {
+                // 隐藏分尺码的尺码组
+                children.push({
+                    displayName: g,
+                    width: item.width,
+                    groupList,
+                    isSizeGroup: true
+                });
+            }
+            else {
+                this.setSizeGroupChildren(gI - 1, children, 0, g, item, groupList, sizeGroupDic, true);
+            }
+        });
+        // 隐藏分尺码的尺码组逻辑
+        if (!hideSizeGroup && groupList.length === 1) {
+            this.setSizeGroupChildren(0, children, 0, groupList[0], item, groupList, sizeGroupDic, false);
+        }
+        groupList.forEach((g, gI) => {
+            if (sizeGroupDic[g]) {
+                const oldLeng = sizeGroupDic[g].length;
+                sizeGroupDic[g].length = maxLeng;
+                sizeGroupDic[g].fill(null, oldLeng);
+                sizeGroupDic[g].forEach((size, sizeI) => {
+                    if (gI === 0) {
+                        children.push({
+                            ...item,
+                            displayName: size,
+                            headerKey: size,
+                            expr: item.expr,
+                            width: item.width,
+                            mark: undefined,
+                            groupList,
+                        });
+                    }
+                    else {
+                        this.setSizeGroupChildren(gI - 1, children, sizeI + 1, size, item, groupList, sizeGroupDic, false);
+                    }
+                });
+            }
+        });
+        if (originChildren && originChildren.length) {
+            children.splice(1, 0, ...originChildren);
+        }
+        item.isGroup = true;
+        item.children = children;
+    }
+    findMeasureGroup(hideSizeGroup, measureList, parentKeys, measureSizeGroup, sizeGroupDic, dataList, measureSizeKey, measureListDic) {
+        if (measureList && measureList.length) {
+            measureList.forEach((item, itemI) => {
+                if (!item.isGroup) {
+                    const key = this.getNewKey(item, parentKeys);
+                    if (measureSizeGroup?.[key]?.length) {
+                        this.setSizeGroup(hideSizeGroup, item, key, measureSizeGroup, sizeGroupDic);
+                        this.setSizeDataList(item, key, [], dataList, measureSizeKey, sizeGroupDic, measureSizeGroup, measureListDic);
+                    }
+                    else if (item.expr) {
+                        const keys = [];
+                        measureSizeKey.forEach(sizeKey => {
+                            const reg = new RegExp(_.escapeRegExp(`{${sizeKey}}`), 'g');
+                            const sizeMatch = item.expr.match(reg);
+                            if (sizeMatch && sizeMatch.length) {
+                                const firstMatch = sizeMatch[0];
+                                const firstKey = firstMatch.substring(1, firstMatch.length - 1);
+                                keys.push(firstKey);
+                            }
+                        });
+                        const sizeList = [];
+                        keys.forEach(k => {
+                            measureSizeGroup[k]?.forEach(size => {
+                                if (!sizeList.includes(size)) {
+                                    sizeList.push(size);
+                                }
+                            });
+                        });
+                        if (sizeList && sizeList.length) {
+                            measureSizeGroup[item.exprKey] = sizeList;
+                            measureSizeKey.push(item.exprKey);
+                            this.setSizeGroup(hideSizeGroup, item, null, measureSizeGroup, sizeGroupDic, sizeList);
+                            this.setSizeDataList(item, key, sizeList, dataList, measureSizeKey, sizeGroupDic, measureSizeGroup, measureListDic);
+                        }
+                    }
+                }
+                else if (item.children && item.children.length) {
+                    this.findMeasureGroup(hideSizeGroup, item.children, [...parentKeys, item.displayName], measureSizeGroup, sizeGroupDic, dataList, measureSizeKey, measureListDic);
+                }
+            });
+        }
+    }
+    setDateRange(item, key, dateRangeDicList) {
+        const children = [];
+        const showWeek = item.dateType.find(d => d.type === 'TIME_RANGE' && d.valueList && d.valueList.length && d.valueList[0] === 1 && d.valueList[1] === true);
+        dateRangeDicList[key].forEach((d, dI) => {
+            const child = {
+                ...item,
+                displayName: d,
+                isGroup: false,
+                mark: undefined,
+            };
+            if (d && showWeek) {
+                child.subLabel = getWeekName(d, true);
+            }
+            if (child.style?.conditionList?.length) {
+                child.style.conditionList.forEach(c => {
+                    if (c.op === 'expr') {
+                        let expr = c.value;
+                        const fields = _.uniq(expr.match(CALCULATED_REGEX));
+                        fields.forEach((f) => {
+                            const dr = f.replace('{', '').replace('}', '');
+                            if (dateRangeDicList[dr]) {
+                                const date = dateRangeDicList[dr][dI];
+                                if (date) {
+                                    // expr
+                                    const count = f.split('[').length;
+                                    const j = f.indexOf(']');
+                                    let k = dr.substring(0, j > -1 ? j : undefined) + '[' + date + ']';
+                                    k = k.padEnd(count, ']');
+                                    expr = expr.replaceAll(f, `{${k}}`);
+                                    c.value = expr;
+                                }
+                            }
+                        });
+                        const computeExpr = c.value.replaceAll('{', '(data.data["').replaceAll('}', '"] || 0)');
+                        c.computeFn = getCatchFunction(expr2FnBody(computeExpr));
+                    }
+                });
+            }
+            if (item.expr) {
+                let expr = item.expr;
+                const fields = expr.match(CALCULATED_REGEX);
+                fields?.forEach(field => {
+                    const count = field.split('[').length;
+                    if (field === `{${key}}`) {
+                        const j = field.indexOf(']');
+                        let k = key.substring(0, j > -1 ? j : undefined) + '[' + d + ']';
+                        k = k.padEnd(count, ']');
+                        expr = expr.replace(field, `{${k}}`);
+                    }
+                });
+                child.expr = expr;
+            }
+            children.push(child);
+        });
+        item.isGroup = true;
+        item.children = children;
+    }
+    // 分日期
+    findDateRangeDic(measureList, dateRangeDicList, dateRangekeys, dateRangeDic, parentKeys = []) {
+        if (measureList && measureList.length) {
+            measureList.forEach((item, itemI) => {
+                if (!item.isGroup) {
+                    const key = this.getNewKey(item, parentKeys);
+                    if (dateRangeDicList[key] && dateRangeDicList[key].length) {
+                        this.setDateRange(item, key, dateRangeDicList);
+                    }
+                    if (item.expr && !item.children && item.measureType !== 'DATE_RANGE_SUM') {
+                        const keys = [];
+                        dateRangekeys.forEach(dateKey => {
+                            const reg = new RegExp(_.escapeRegExp(`{${dateKey}}`), 'g');
+                            const sizeMatch = item.expr.match(reg);
+                            if (sizeMatch && sizeMatch.length && !item.children) {
+                                const firstMatch = sizeMatch[0];
+                                const firstKey = firstMatch.substring(1, firstMatch.length - 1);
+                                keys.push(firstKey);
+                                dateRangekeys.push(item.exprKey);
+                            }
+                        });
+                        // 设置计算日期范围
+                        if (keys.length) {
+                            const dateList = {};
+                            keys.forEach(k => {
+                                if (dateRangeDic[k] && dateRangeDic[k].startDate) {
+                                    const itemDateList = getDateList(new Date(dateRangeDic[k].startDate), new Date(dateRangeDic[k].endDate));
+                                    itemDateList.forEach(date => {
+                                        if (!dateList[k]) {
+                                            dateList[k] = [];
+                                        }
+                                        if (!dateList[k].includes(date)) {
+                                            dateList[k].push(date);
+                                        }
+                                    });
+                                }
+                                if (dateRangeDic[k] && dateRangeDic[k].startYear) {
+                                    const itemDateList = getYearList(new Date(dateRangeDic[k].startYear), new Date(dateRangeDic[k].endYear));
+                                    itemDateList.forEach(date => {
+                                        if (!dateList[k]) {
+                                            dateList[k] = [];
+                                        }
+                                        if (!dateList[k].includes(date)) {
+                                            dateList[k].push(date);
+                                        }
+                                    });
+                                }
+                                if (dateRangeDic[k] && dateRangeDic[k].startMonth) {
+                                    const itemDateList = getMonthList(new Date(dateRangeDic[k].startMonth), new Date(dateRangeDic[k].endMonth));
+                                    itemDateList.forEach(date => {
+                                        if (!dateList[k]) {
+                                            dateList[k] = [];
+                                        }
+                                        if (!dateList[k].includes(date)) {
+                                            dateList[k].push(date);
+                                        }
+                                    });
+                                }
+                            });
+                            Object.keys(dateList).forEach(k => {
+                                dateList[k].sort();
+                            });
+                            this.setExprDateRange(item, dateList, keys);
+                            // 修复计算度量和条件度量引用的计算或条件度量存在分日期导致该度量无法分日期的问题
+                            if (item.children && item.children.length && /^\d{4}-\d{2}-\d{2}$/.test(item.children[0].displayName)) {
+                                dateRangeDic[item.exprKey] = {
+                                    startDate: item.children[0].displayName,
+                                    endDate: item.children[0].displayName
+                                };
+                                if (item.children.length > 0) {
+                                    dateRangeDic[item.exprKey].endDate = item.children[item.children.length - 1].displayName;
+                                }
+                            }
+                        }
+                    }
+                    else if (item.expr && !item.children && item.measureType === 'DATE_RANGE_SUM') {
+                        const expr = item.expr;
+                        const fields = expr.match(CALCULATED_REGEX);
+                        const dateRangeSumList = [];
+                        fields.forEach((f, i) => {
+                            const k = f.substring(1, f.length - 1);
+                            if (i === 0) {
+                                if (dateRangeDicList[k]) {
+                                    this.setExprDateRangeOld(item, dateRangeDicList[k], []);
+                                }
+                            }
+                            if (dateRangeDicList[k]) {
+                                dateRangeSumList.push({
+                                    key: k,
+                                    dateList: dateRangeDicList[k],
+                                });
+                            }
+                        });
+                        item.children?.forEach(child => child.dateRangeSumList = dateRangeSumList);
+                    }
+                }
+                else if (item.children && item.children.length) {
+                    this.findDateRangeDic(item.children, dateRangeDicList, dateRangekeys, dateRangeDic, [...parentKeys, item.displayName]);
+                }
+            });
+        }
+    }
+    findHourMeasures(measureList, hourMeasureKeys, parentKeys = []) {
+        measureList.forEach(item => {
+            const time = this.findHourDateType(item);
+            if (time) {
+                const key = this.getNewKey(item, parentKeys);
+                const { start, end } = this.getHourStartAndEnd(time);
+                hourMeasureKeys.push({
+                    key,
+                    start,
+                    end,
+                });
+            }
+            else if (item.isGroup && item.children && item.children.length) {
+                this.findHourMeasures(item.children, [...parentKeys, item.displayName]);
+            }
+        });
+    }
+    findWeekType(measure, value) {
+        let week = null;
+        if (!measure.isGroup && measure.dateType) {
+            week = measure.dateType.find(d => d.type === 'TIME_RANGE' && d.valueList && d.valueList.length && d.valueList[0] === value);
+        }
+        return week;
+    }
+    findWeekMeasure(value, measureList, weekMeasureKeys, parentKeys = []) {
+        measureList.forEach(item => {
+            const week = this.findWeekType(item, value);
+            if (week) {
+                const key = this.getNewKey(item, parentKeys);
+                weekMeasureKeys.push(key);
+            }
+            else if (item.isGroup && item.children && item.children.length) {
+                this.findWeekMeasure(value, item.children, weekMeasureKeys, [...parentKeys, item.displayName]);
+            }
+        });
+    }
+    findWeekGroup(value, measureList, group, weekMeasureKeys, parentKeys = []) {
+        if (measureList && measureList.length) {
+            measureList.forEach((item, itemI) => {
+                const week = this.findWeekType(item, value);
+                if (week) {
+                    const key = this.getNewKey(item, parentKeys);
+                    const children = [];
+                    for (let i = 0, leng = group[key].length; i < leng; i++) {
+                        const name = group[key][i];
+                        const data = {
+                            ...item,
+                            dateType: undefined,
+                            isGroup: false,
+                            displayName: name,
+                            mark: undefined,
+                        };
+                        children.push(data);
+                    }
+                    item.isGroup = true;
+                    item.children = children;
+                }
+                else if (item.expr && !item.children) {
+                    const expr = item.expr;
+                    const weekList = {};
+                    const fields = expr.match(CALCULATED_REGEX);
+                    let keyInFieldsOfWeekMeasure = '';
+                    fields?.forEach((f, i) => {
+                        const k = f.substring(1, f.length - 1);
+                        const weekItem = weekMeasureKeys.find(h => h === k);
+                        if (weekItem) {
+                            if (!keyInFieldsOfWeekMeasure) {
+                                keyInFieldsOfWeekMeasure = weekItem;
+                            }
+                            if (!weekList[weekItem]) {
+                                weekList[weekItem] = [];
+                            }
+                            for (let j = 0, leng = group[weekItem].length; j < leng; j++) {
+                                const name = group[weekItem][j];
+                                if (!weekList[weekItem].includes(name)) {
+                                    weekList[weekItem].push(name);
+                                }
+                            }
+                        }
+                    });
+                    if (item.calcRule === 'SEQUENCE' && weekList) {
+                        const list = [];
+                        Object.keys(weekList).forEach(k => {
+                            weekList[k].forEach(item => {
+                                if (!list.some(l => l === item)) {
+                                    list.push(item);
+                                }
+                            });
+                        });
+                        list.sort();
+                        Object.keys(weekList).forEach(k => {
+                            weekList[k] = [...list];
+                        });
+                    }
+                    const valueList = [];
+                    let keyOfMaxLeng = keyInFieldsOfWeekMeasure || weekMeasureKeys[0];
+                    weekMeasureKeys.forEach(k => {
+                        const list = weekList[k];
+                        valueList.push(list);
+                        if (list?.length > weekList[keyOfMaxLeng]?.length) {
+                            keyOfMaxLeng = k;
+                        }
+                    });
+                    // @ts-ignore
+                    const diff = valueList.length > 1 ? _.difference(...valueList) : [];
+                    if (weekList[keyOfMaxLeng] && weekList[keyOfMaxLeng].length) {
+                        weekList[keyOfMaxLeng].sort();
+                        const children = [];
+                        weekList[keyOfMaxLeng]?.forEach((h, hI) => {
+                            const child = {
+                                ...item,
+                                displayName: diff && diff.length ? `${hI + 1}` : h,
+                                mark: undefined,
+                            };
+                            let newExpr = item.expr;
+                            fields?.forEach((f, i) => {
+                                const k = f.substring(1, f.length - 1);
+                                const weekItem = weekMeasureKeys.find(w => w === k);
+                                if (weekItem) {
+                                    newExpr = newExpr.replace(f, `{${this.getKey(weekItem, weekList[weekItem][hI])}}`);
+                                }
+                            });
+                            child.expr = newExpr;
+                            children.push(child);
+                        });
+                        item.isGroup = true;
+                        item.children = children;
+                        weekMeasureKeys.push(item.exprKey);
+                        group[item.exprKey] = children.map(child => child.displayName);
+                    }
+                }
+                else if (item.isGroup && item.children && item.children.length) {
+                    this.findWeekGroup(value, item.children, group, weekMeasureKeys, [...parentKeys, item.displayName]);
+                }
+            });
+        }
+    }
+    getRowSpan(measureList) {
+        let globalRowSpan = 1;
+        let rowSpan = 1;
+        const deepList = (list, level = 1) => {
+            if (list && list.length) {
+                list.forEach(item => {
+                    if (item.isGroup && item.children && item.children.length) {
+                        rowSpan = level + 1;
+                        deepList(item.children, level + 1);
+                    }
+                    else {
+                        if (rowSpan > globalRowSpan) {
+                            globalRowSpan = rowSpan;
+                        }
+                    }
+                });
+            }
+        };
+        deepList(measureList);
+        return globalRowSpan > 1 ? globalRowSpan : null;
+    }
+    getColSpan(hideSizeGroup, measureList, isReal = false) {
+        let colSpan = 0;
+        const deepList = (list) => {
+            if (list && list.length) {
+                list.forEach(item => {
+                    // 隐藏分尺码的尺码组逻辑
+                    if (!hideSizeGroup || !item.isSizeGroup) {
+                        if (!isReal && !item.isGroup && !item.isHide) {
+                            colSpan++;
+                        }
+                        if (isReal && !item.isGroup) {
+                            colSpan++;
+                        }
+                    }
+                    if (item.isGroup && item.children && item.children.length) {
+                        deepList(item.children);
+                    }
+                });
+            }
+        };
+        deepList(measureList);
+        return colSpan >= 1 ? colSpan : null;
+    }
+    setDimHeader(dimList, headers, maxRowspan, combineChildren) {
+        dimList.forEach(item => {
+            if (!headers[0]) {
+                headers[0] = [];
+            }
+            let trigger = null;
+            if (item.paramList && item.paramList.length) {
+                const triggerParam = item.paramList.find(p => p.type === 'TRIGGER');
+                const triggerValue = triggerParam?.valueList[0];
+                if (triggerValue === 1) {
+                    trigger = 'hover';
+                }
+                else if (triggerValue === 3) {
+                    trigger = 'thumbnail';
+                }
+            }
+            let h = {
+                rowspan: maxRowspan,
+                label: item.displayName,
+                key: item.displayName,
+                dataType: 'STRING',
+                customFilter: item.customFilter ?? true,
+                groupBy: item.groupBy,
+                isProductImage: item.dimCode?.includes('图片地址'),
+                type: 'DIM',
+                width: item.width,
+                fixed: item.fixed,
+                mark: item.mark,
+                trigger,
+                backgroundColor: item.style && item.style.backgroundColor ? item.style.backgroundColor : null,
+                color: item.style && item.style.color ? item.style.color : null,
+                styleConditionList: item.style?.conditionList || null,
+                style: item.style,
+                showItemGroupSummary: item.showItemGroupSummary,
+                itemCalculate: item.expr || undefined,
+                dimType: item.dimType,
+                expr: item.expr,
+                totalCalculate: item.expr ? 'CUSTOM' : undefined,
+                dimExpanded: item.dimExpanded,
+            };
+            if (combineChildren && combineChildren.length) {
+                const action = combineChildren.find(child => {
+                    if (!child.action.anchor || !child.action.anchor.valueList || !child.action.anchor.valueList.length) {
+                        const lastDimAndFilter = child.action.dimAndFilterList[child.action.dimAndFilterList.length - 1];
+                        return lastDimAndFilter.parent &&
+                            lastDimAndFilter.parent.dataSet === item.dataSet &&
+                            lastDimAndFilter.parent.dimCode === item.dimCode &&
+                            lastDimAndFilter.parent.displayName === item.displayName;
+                    }
+                    else if (child.action.anchor.valueList[0] === '维度') {
+                        const { valueList } = child.action.anchor;
+                        return item.displayName === valueList[valueList.length - 1];
+                    }
+                });
+                if (action) {
+                    h.customDrill = true;
+                    h.action = action.action;
+                }
+            }
+            if (item.headerFilter) {
+                h = { ...h, ...item.headerFilter };
+            }
+            headers[0].push(h);
+        });
+    }
+    getGroupByDimList(dimList) {
+        let groupByDimList = [];
+        const groupList = dimList.filter((item) => !!item.dimCode);
+        if (groupList?.length) {
+            const groupByI = groupList.findIndex((item) => !item.groupBy);
+            if (groupByI > -1) {
+                groupByDimList = groupList.filter((item, i) => i <= groupByI);
+            }
+        }
+        return groupByDimList;
+    }
+    getIsGroupHide(list) {
+        // let isHide = true;
+        // const deepChildren = (list: Array<IDisplayMeasure>) => {
+        //   if (list && list.length) {
+        //     for (let i = 0, leng = list.length; i < leng; i++) {
+        //       const item = list[i];
+        //       if (!item.isHide) {
+        //         isHide = false;
+        //         return false;
+        //       } else if (item.children && item.children.length && deepChildren(item.children)) {
+        //         return true;
+        //       }
+        //     }
+        //   }
+        // };
+        // deepChildren(list);
+        // return isHide;
+        if (!list) {
+            return true;
+        }
+        for (const item of list) {
+            if (!item.isHide) {
+                return false; // 直接返回结果，避免不必要的循环
+            }
+            if (item.children) {
+                // 如果子项没隐藏（即getIsGroupHide(item.children)返回false），返回false
+                if (!this.getIsGroupHide(item.children)) {
+                    return false;
+                }
+            }
+        }
+        // 如果所有项都隐藏，返回true
+        return true;
+    }
+    deleteLastChildren(measure) {
+        const lastData = {
+            rowspan: 1,
+            children: null,
+        };
+        const getLast = (data, rowspan = 1) => {
+            if (data?.children?.find(item => !item.isGroup)) {
+                lastData.rowspan = rowspan;
+                lastData.children = data.children;
+                data.isGroup = false;
+                data.children = undefined;
+            }
+            else if (data?.children?.length) {
+                for (let j = 0, leng = data.children.length; j < leng; j++) {
+                    const item = data.children[j];
+                    getLast(item, rowspan + 1);
+                }
+            }
+        };
+        getLast(measure);
+        return lastData;
+        // const getLast = (data: IDisplayMeasure, rowspan = 1) => {
+        //   if (data?.children?.find(item => !item.isGroup)) {
+        //     data.isGroup = false;
+        //     data.children = undefined;
+        //     return {
+        //       rowspan,
+        //       children: data.children,
+        //     };
+        //   } else if (data?.children?.length) {
+        //     for (let j = 0, leng = data.children.length; j < leng; j++) {
+        //       const item = data.children[j];
+        //       const result = getLast(item, rowspan + 1);
+        //       if (result) return result;
+        //     }
+        //   }
+        //   return null;
+        // }
+        // return getLast(measure) || { rowspan: 1, children: null };
+    }
+}