@publishfx/publish-chart 2.1.31 → 2.1.33

package/CHANGELOG.md

@@ -1,3 +1,33 @@
+**2.1.33** fix(chart): 修复几个问题
+- 2026-03-13T15:39:21+08:00 [fix(chart): 修复几个问题](http://lf.git.oa.mt/publish_platform/web/publish/commit/8007ec69939e98bacdb694b917c73fff6f8254d2)
+- 2026-03-11T16:17:35+08:00 [fix(chart): 离线分析compareTimeValue为空时补充字符。](http://lf.git.oa.mt/publish_platform/web/publish/commit/9f042730b66e8378c90400981cd86376e8b3018d)
+- 2026-03-10T22:15:37+08:00 [fix(chart): 横向展示矩形图时label间距设置为30](http://lf.git.oa.mt/publish_platform/web/publish/commit/67cf0e022b39355d03cba75d3fc69d52eb12282c)
+- 2026-03-10T21:41:26+08:00 [fix(chart): 组合图同一指标tooltip兼容](http://lf.git.oa.mt/publish_platform/web/publish/commit/a3894b7e59c8a33e9f1d0b487e620e085abbc281)
+- 2026-03-10T21:05:02+08:00 [feat(chart): 柱状图空值tooltip展示-](http://lf.git.oa.mt/publish_platform/web/publish/commit/86baec40eb6fdff60a71571ed42adc850dd8f0ed)
+- 2026-03-10T20:47:26+08:00 [feat(chart): NaN数据处理](http://lf.git.oa.mt/publish_platform/web/publish/commit/95c631436b870c525f8b1a97d365a15b255e2e18)
+- 2026-03-10T20:38:08+08:00 [fix(chart): 处理label自适应宽度的临时方案](http://lf.git.oa.mt/publish_platform/web/publish/commit/563fc86358654fa2249a75d8748586029cb4e1f2)
+- 2026-03-10T20:15:42+08:00 [fix(chart): X轴label最小值调整，以适配国家维度](http://lf.git.oa.mt/publish_platform/web/publish/commit/cef0e9687ccf1404a739b78655c6d322006f1373)
+- 2026-03-10T17:50:32+08:00 [feat(chart): 优化辅助线文本展示](http://lf.git.oa.mt/publish_platform/web/publish/commit/9975aca40e6cb006596355c36ee3ad37a7120315)
+- 2026-03-10T17:43:12+08:00 [fix(chart): timeRange判断增加null的判断](http://lf.git.oa.mt/publish_platform/web/publish/commit/8d13a0938a894afc58badf678b8d8052dde00e35)
+- 2026-03-10T17:18:11+08:00 [fix(chart): ts问题修复](http://lf.git.oa.mt/publish_platform/web/publish/commit/38aee4e4f0c23d93778df8fc43ef120ed59dca45)
+- 2026-03-10T17:16:05+08:00 [fix(chart): 节点颜色修复](http://lf.git.oa.mt/publish_platform/web/publish/commit/73bc2aac8443ee2c14a74f8466bb1a30a5068970)
+- 2026-03-10T16:46:01+08:00 [feat(chart): 辅助线文本完全按照设计稿来](http://lf.git.oa.mt/publish_platform/web/publish/commit/92224f3f8d5a9c7f6de83d21b616c3c29859d910)
+- 2026-03-10T15:40:23+08:00 [feat(chart): 图表右边margin预留30防止X轴刻度超出](http://lf.git.oa.mt/publish_platform/web/publish/commit/376e7d802ab76ec77311bc661bddfff605398e74)
+- 2026-03-10T15:38:51+08:00 [fix(chart): 辅助线还是改成非render模式](http://lf.git.oa.mt/publish_platform/web/publish/commit/abdd0300801d70a00559e11f4dcd2ab11da4f617)
+- 2026-03-10T15:26:29+08:00 [feat(chart): 组合图空数据tooltip展示](http://lf.git.oa.mt/publish_platform/web/publish/commit/3e19dfc8d52a3ebd26c99505207f6c03f2f5dac1)
+- 2026-03-10T12:10:18+08:00 [fix(chart): 组合图降序排列时的逻辑校正](http://lf.git.oa.mt/publish_platform/web/publish/commit/b6bbc0cbecd9374a399b79508ae5ae09daaa4998)
+- 2026-03-10T11:05:09+08:00 [fix(chart): 移除多余代码](http://lf.git.oa.mt/publish_platform/web/publish/commit/6b28a33b5c383b71abb689914c3698505f779501)
+- 2026-03-10T11:04:22+08:00 [fix(chart): 折线图移除height对render图表的影响](http://lf.git.oa.mt/publish_platform/web/publish/commit/3d30e722de60ded1cf3e132729b5b861363e7f45)
+- 2026-03-10T11:03:20+08:00 [fix(chart): tooltip使用组件自身的bounding](http://lf.git.oa.mt/publish_platform/web/publish/commit/d85690b015d5510d5fca47c3341ff3cb21503118)
+- 2026-03-09T21:14:35+08:00 [feat(chart): 辅助线样式](http://lf.git.oa.mt/publish_platform/web/publish/commit/c6e5ee27606c832807da80ec785c51d2d49844de)
+- 2026-03-09T20:47:53+08:00 [feat(chart): 组合图空值绘制问题&副轴取第一个指标](http://lf.git.oa.mt/publish_platform/web/publish/commit/3557796be46126c6df957078275fa27cfdc3f13c)
+- 2026-03-09T15:56:21+08:00 [feat(chart): 组合图groupValue为空问题](http://lf.git.oa.mt/publish_platform/web/publish/commit/81ffac637ccb092b0934201ce01c57be638b9eba)
+- 2026-03-07T08:07:27+08:00 [fix(chart): 组合图不带分组项且在可视化看板中时不支持对比时间](http://lf.git.oa.mt/publish_platform/web/publish/commit/d78f7cc84e1166f2bd1aee2cc79d52708f878bf8)
+- 2026-03-07T07:24:45+08:00 [fix(chart): 修复横向柱状图刻度空间不够的问题](http://lf.git.oa.mt/publish_platform/web/publish/commit/b074d0457a16104d3d2f48ff8efb10303f72a3d5)
+- 2026-03-07T06:59:58+08:00 [fix(chart): 移除组合图tooltip的mount配置](http://lf.git.oa.mt/publish_platform/web/publish/commit/68c7154f03802da5965b2c6ebe0e76bb307dfdb2)
+- 2026-03-07T06:59:26+08:00 [fix(chart): 修复辅助线重复渲染bug](http://lf.git.oa.mt/publish_platform/web/publish/commit/ecd2001248da429c7d531f0fbf068ca5dcd1450e)
+- 2026-03-07T06:57:26+08:00 [fix(chart): 柱状图启用文本隐藏](http://lf.git.oa.mt/publish_platform/web/publish/commit/80b7ef9d954d5377ebd03799e684feb7d5d4bf45)
+
 **2.1.20** fix(chart): TS错误去除
 - 2026-03-07T04:44:58+08:00 [fix(chart): TS错误去除](http://lf.git.oa.mt/publish_platform/web/publish/commit/d81fbe1bc27f08b5e0c6749ee1334a54a0f5202a)
 - 2026-03-07T04:43:55+08:00 [fix(chart): 堆积图height模式修改](http://lf.git.oa.mt/publish_platform/web/publish/commit/f46992872461144f696f5478c2c70d83bd162fb0)

package/dist/adapters/DataAdapter.js

@@ -156,10 +156,30 @@ class DataAdapter {
                     return row;
                 }
             });
-            if (config.isDescend) tdv.transform({
+            if (config.isDescend) if (config.isGroup) {
+                const xKey = config.x;
+                const yKey = config.y;
+                const groupTotals = tdv.rows.reduce((acc, row)=>{
+                    const key = String(row[xKey]);
+                    const value = Number(row[yKey]);
+                    const safeValue = Number.isFinite(value) ? value : 0;
+                    acc[key] = (acc[key] ?? 0) + safeValue;
+                    return acc;
+                }, {});
+                const groupOrder = Array.from(new Set(tdv.rows.map((row)=>String(row[xKey])))).sort((a, b)=>(groupTotals[b] ?? 0) - (groupTotals[a] ?? 0));
+                tdv.rows.sort((a, b)=>{
+                    const aIndex = groupOrder.indexOf(String(a[xKey]));
+                    const bIndex = groupOrder.indexOf(String(b[xKey]));
+                    return aIndex - bIndex;
+                });
+            } else tdv.transform({
                 type: 'sort',
                 callback (a, b) {
-                    return b.total - a.total;
+                    const aValue = Number(a[config.y]);
+                    const bValue = Number(b[config.y]);
+                    const safeA = Number.isFinite(aValue) ? aValue : -1 / 0;
+                    const safeB = Number.isFinite(bValue) ? bValue : -1 / 0;
+                    return safeB - safeA;
                 }
             });
             const xKey = config.x ?? 'x';

package/dist/adapters/__tests__/DataAdapter.contract.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/adapters/__tests__/DataAdapter.contract.test.js

@@ -0,0 +1,517 @@
+import { DataAdapter } from "../DataAdapter.js";
+jest.mock('@antv/data-set/lib', ()=>{
+    class MockView {
+        rows = [];
+        source(data) {
+            this.rows = (data || []).map((item)=>({
+                    ...item
+                }));
+            return this;
+        }
+        transform(config) {
+            if (!config || !config.type) return this;
+            if ('map' === config.type) {
+                this.rows = this.rows.map((row)=>{
+                    const cloned = {
+                        ...row
+                    };
+                    const next = config.callback ? config.callback(cloned) : cloned;
+                    return next ?? cloned;
+                });
+                return this;
+            }
+            if ('filter' === config.type) {
+                this.rows = this.rows.filter((row)=>config.callback ? config.callback(row) : true);
+                return this;
+            }
+            if ('sort' === config.type) {
+                this.rows = [
+                    ...this.rows
+                ].sort(config.callback);
+                return this;
+            }
+            if ('aggregate' === config.type) {
+                const groupBy = config.groupBy || [];
+                const fields = config.fields || [];
+                const as = config.as || [];
+                const targetField = fields[0];
+                const outputField = as[0] || 'value';
+                const grouped = new Map();
+                this.rows.forEach((row)=>{
+                    const key = groupBy.map((k)=>String(row[k])).join('||');
+                    const prev = grouped.get(key);
+                    const value = Number(row[targetField]) || 0;
+                    if (prev) {
+                        prev[outputField] = (Number(prev[outputField]) || 0) + value;
+                        grouped.set(key, prev);
+                    } else {
+                        const base = {};
+                        groupBy.forEach((k)=>{
+                            base[k] = row[k];
+                        });
+                        base[outputField] = value;
+                        grouped.set(key, base);
+                    }
+                });
+                this.rows = Array.from(grouped.values());
+            }
+            return this;
+        }
+    }
+    class MockDataSet {
+        createView() {
+            return new MockView();
+        }
+    }
+    return {
+        __esModule: true,
+        default: MockDataSet
+    };
+});
+const pickFields = (rows, fields)=>rows.map((row)=>{
+        const next = {};
+        fields.forEach((field)=>{
+            next[field] = row[field];
+        });
+        return next;
+    });
+const expectRequiredFields = (rows, fields)=>{
+    rows.forEach((row)=>{
+        fields.forEach((field)=>{
+            expect(Object.prototype.hasOwnProperty.call(row, field)).toBe(true);
+        });
+    });
+};
+describe('DataAdapter contract', ()=>{
+    describe('bar 数据契约', ()=>{
+        it('应稳定处理空值并保持排序与对比期拼接规则', ()=>{
+            const input = [
+                {
+                    groupName: 'A',
+                    groupType: 'revenue',
+                    groupValue: '10'
+                },
+                {
+                    groupName: 'B',
+                    groupType: 'revenue',
+                    groupValue: '-'
+                },
+                {
+                    groupName: 'C',
+                    groupType: 'revenue',
+                    groupValue: '3'
+                },
+                {
+                    groupName: 'A',
+                    groupType: 'revenue_compare',
+                    groupValue: '8'
+                },
+                {
+                    groupName: 'B',
+                    groupType: 'revenue_compare',
+                    groupValue: '2'
+                }
+            ];
+            const rows = DataAdapter.transform(input, 'bar', {
+                type: 'bar',
+                x: 'groupName',
+                y: 'groupValue',
+                isDescend: true,
+                isHorizontal: false
+            });
+            expectRequiredFields(rows, [
+                'groupName',
+                'groupType',
+                'groupValue'
+            ]);
+            const projection = pickFields(rows, [
+                'groupName',
+                'groupType',
+                'groupValue'
+            ]);
+            expect(projection).toEqual([
+                {
+                    groupName: 'A',
+                    groupType: 'revenue',
+                    groupValue: 10
+                },
+                {
+                    groupName: 'C',
+                    groupType: 'revenue',
+                    groupValue: 3
+                },
+                {
+                    groupName: 'B',
+                    groupType: 'revenue',
+                    groupValue: null
+                },
+                {
+                    groupName: 'A',
+                    groupType: 'revenue_compare',
+                    groupValue: 8
+                },
+                {
+                    groupName: 'B',
+                    groupType: 'revenue_compare',
+                    groupValue: 2
+                }
+            ]);
+        });
+    });
+    describe('line 数据契约', ()=>{
+        it('应按折线规则归一化数值（无效值转为 -）', ()=>{
+            const input = [
+                {
+                    groupName: 'A',
+                    groupType: 'ctr',
+                    groupValue: ''
+                },
+                {
+                    groupName: 'B',
+                    groupType: 'ctr',
+                    groupValue: '-'
+                },
+                {
+                    groupName: 'C',
+                    groupType: 'ctr',
+                    groupValue: null
+                },
+                {
+                    groupName: 'D',
+                    groupType: 'ctr',
+                    groupValue: void 0
+                },
+                {
+                    groupName: 'E',
+                    groupType: 'ctr',
+                    groupValue: 'NaN'
+                },
+                {
+                    groupName: 'F',
+                    groupType: 'ctr',
+                    groupValue: '5.5'
+                }
+            ];
+            const rows = DataAdapter.transform(input, 'line', {
+                type: 'line',
+                x: 'groupName',
+                y: 'groupValue'
+            });
+            expectRequiredFields(rows, [
+                'groupName',
+                'groupType',
+                'groupValue'
+            ]);
+            expect(pickFields(rows, [
+                'groupName',
+                'groupValue'
+            ])).toEqual([
+                {
+                    groupName: 'A',
+                    groupValue: '-'
+                },
+                {
+                    groupName: 'B',
+                    groupValue: '-'
+                },
+                {
+                    groupName: 'C',
+                    groupValue: '-'
+                },
+                {
+                    groupName: 'D',
+                    groupValue: '-'
+                },
+                {
+                    groupName: 'E',
+                    groupValue: '-'
+                },
+                {
+                    groupName: 'F',
+                    groupValue: 5.5
+                }
+            ]);
+        });
+    });
+    describe('barLine 数据契约', ()=>{
+        it('应稳定返回统一结构与字段（transformedData/leftData/rightData/xKey）', ()=>{
+            const input = [
+                {
+                    groupName: '2026-01-01',
+                    groupType: 'cost',
+                    groupValue: '10',
+                    total: 10,
+                    isCombine: false
+                },
+                {
+                    groupName: '2026-01-02',
+                    groupType: 'cost',
+                    groupValue: '',
+                    total: 0,
+                    isCombine: false
+                },
+                {
+                    groupName: '2026-01-01',
+                    groupType: 'roi',
+                    groupValue: '0.5',
+                    total: 0.5,
+                    isCombine: true
+                }
+            ];
+            const result = DataAdapter.transform(input, 'barLine', {
+                type: 'barLine',
+                x: 'groupName',
+                y: 'groupValue',
+                isDescend: false
+            });
+            expect(Object.keys(result).sort()).toEqual([
+                'leftData',
+                'rightData',
+                'transformedData',
+                'xKey'
+            ]);
+            expect(Array.isArray(result.transformedData)).toBe(true);
+            expect(Array.isArray(result.leftData)).toBe(true);
+            expect(Array.isArray(result.rightData)).toBe(true);
+            expect(Array.isArray(result.xKey)).toBe(true);
+            expectRequiredFields(result.transformedData, [
+                'groupName',
+                'groupType',
+                'groupValue',
+                'isCombine'
+            ]);
+            expectRequiredFields(result.leftData, [
+                'groupName',
+                'groupType',
+                'groupValue',
+                'isCombine'
+            ]);
+            expectRequiredFields(result.rightData, [
+                'groupName',
+                'groupType',
+                'groupValue',
+                'isCombine'
+            ]);
+            expect(result.leftData.every((row)=>false === row.isCombine)).toBe(true);
+            expect(result.rightData.every((row)=>true === row.isCombine)).toBe(true);
+            expect(result.xKey).toEqual([
+                '2026-01-01',
+                '2026-01-02'
+            ]);
+            expect(pickFields(result.leftData, [
+                'groupName',
+                'groupValue'
+            ])).toEqual([
+                {
+                    groupName: '2026-01-01',
+                    groupValue: 10
+                },
+                {
+                    groupName: '2026-01-02',
+                    groupValue: null
+                }
+            ]);
+        });
+        it('isDescend=true 时右轴数据排序应跟随左轴分类顺序，缺失分类置后', ()=>{
+            const input = [
+                {
+                    groupName: 'A',
+                    groupType: 'cost',
+                    groupValue: '10',
+                    total: 10,
+                    isCombine: false
+                },
+                {
+                    groupName: 'B',
+                    groupType: 'cost',
+                    groupValue: '20',
+                    total: 20,
+                    isCombine: false
+                },
+                {
+                    groupName: 'A',
+                    groupType: 'roi',
+                    groupValue: '0.4',
+                    total: 0.4,
+                    isCombine: true
+                },
+                {
+                    groupName: 'B',
+                    groupType: 'roi',
+                    groupValue: '0.8',
+                    total: 0.8,
+                    isCombine: true
+                },
+                {
+                    groupName: 'C',
+                    groupType: 'roi',
+                    groupValue: '0.2',
+                    total: 0.2,
+                    isCombine: true
+                }
+            ];
+            const result = DataAdapter.transform(input, 'barLine', {
+                type: 'barLine',
+                x: 'groupName',
+                y: 'groupValue',
+                isDescend: true
+            });
+            expect(result.leftData.map((row)=>row.groupName)).toEqual([
+                'B',
+                'A'
+            ]);
+            expect(result.rightData.map((row)=>row.groupName)).toEqual([
+                'B',
+                'A',
+                'C'
+            ]);
+        });
+        it('isGroup=true 且 isDescend=true 时应按分类汇总值降序排序', ()=>{
+            const input = [
+                {
+                    groupName: 'A',
+                    groupType: 'cost',
+                    groupValue: '9',
+                    isCombine: false
+                },
+                {
+                    groupName: 'A',
+                    groupType: 'cost2',
+                    groupValue: '9',
+                    isCombine: false
+                },
+                {
+                    groupName: 'B',
+                    groupType: 'cost',
+                    groupValue: '10',
+                    isCombine: false
+                },
+                {
+                    groupName: 'B',
+                    groupType: 'cost2',
+                    groupValue: '1',
+                    isCombine: false
+                },
+                {
+                    groupName: 'A',
+                    groupType: 'roi',
+                    groupValue: '0.4',
+                    isCombine: true
+                },
+                {
+                    groupName: 'B',
+                    groupType: 'roi',
+                    groupValue: '0.8',
+                    isCombine: true
+                },
+                {
+                    groupName: 'C',
+                    groupType: 'roi',
+                    groupValue: '0.2',
+                    isCombine: true
+                }
+            ];
+            const result = DataAdapter.transform(input, 'barLine', {
+                type: 'barLine',
+                x: 'groupName',
+                y: 'groupValue',
+                isDescend: true,
+                isGroup: true
+            });
+            expect(result.leftData.map((row)=>row.groupName)).toEqual([
+                'A',
+                'A',
+                'B',
+                'B'
+            ]);
+            expect(result.rightData.map((row)=>row.groupName)).toEqual([
+                'A',
+                'B',
+                'C'
+            ]);
+        });
+    });
+    describe('groupCompare 数据契约', ()=>{
+        it('当前实现应保持透传（用于兼容历史逻辑）', ()=>{
+            const input = [
+                {
+                    groupName: 'A',
+                    groupValue: 1,
+                    groupType: 'x'
+                },
+                {
+                    groupName: 'B',
+                    groupValue: 2,
+                    groupType: 'x'
+                }
+            ];
+            const rows = DataAdapter.transform(input, 'groupCompare', {
+                type: 'groupCompare'
+            });
+            expect(rows).toEqual(input);
+        });
+    });
+    describe('迁移字段级 diff 基线', ()=>{
+        it('barLine 关键字段投影应保持稳定（迁移对比基线）', ()=>{
+            const input = [
+                {
+                    groupName: '2026-01-01',
+                    groupType: 'revenue',
+                    groupValue: '100',
+                    total: 100,
+                    isCombine: false,
+                    compareTime: '2025-01-01~2025-01-31',
+                    change: 0.1,
+                    percent: 1
+                },
+                {
+                    groupName: '2026-01-01',
+                    groupType: 'roi',
+                    groupValue: '1.2',
+                    total: 1.2,
+                    isCombine: true,
+                    compareTime: '2025-01-01~2025-01-31',
+                    change: -0.2,
+                    percent: 1
+                }
+            ];
+            const result = DataAdapter.transform(input, 'barLine', {
+                type: 'barLine',
+                x: 'groupName',
+                y: 'groupValue'
+            });
+            const projected = pickFields(result.transformedData, [
+                'groupName',
+                'groupType',
+                'groupValue',
+                'isCombine',
+                'total',
+                'compareTime',
+                'change',
+                'percent'
+            ]);
+            expect(projected).toEqual([
+                {
+                    groupName: '2026-01-01',
+                    groupType: 'revenue',
+                    groupValue: 100,
+                    isCombine: false,
+                    total: 100,
+                    compareTime: '2025-01-01~2025-01-31',
+                    change: 0.1,
+                    percent: 1
+                },
+                {
+                    groupName: '2026-01-01',
+                    groupType: 'roi',
+                    groupValue: 1.2,
+                    isCombine: true,
+                    total: 1.2,
+                    compareTime: '2025-01-01~2025-01-31',
+                    change: -0.2,
+                    percent: 1
+                }
+            ]);
+        });
+    });
+});

package/dist/components/g2/base/G2CombineChart.js

@@ -47,7 +47,7 @@ const transformDataToGroupBarLineFormat = (data, x = "groupName", y = "", indica
                 isCombine: isCombineFlag,
                 total: compareValue,
                 change: changeValue,
-                compareTime: compareTimeValue
+                compareTime: compareTimeValue || '对比时间'
             });
             return rows;
         });
@@ -78,6 +78,8 @@ const G2CombineChart = ({ height = 300, data, x = "", y = "", z = "", indicatorM
     const [xyList, setXYList] = useState([]);
     const [activeIds, setActiveIds] = useState([]);
     const [legendItems, setLegendItems] = useState([]);
+    const lastLegendDataRef = useRef(null);
+    const hasLegendInitializedRef = useRef(false);
     const { transformedData, leftData, rightData, xKey } = useMemo(()=>{
         if (!legend) {
             let result = transformDataToGroupBarLineFormat(data, x, y, indicators);
@@ -128,11 +130,9 @@ const G2CombineChart = ({ height = 300, data, x = "", y = "", z = "", indicatorM
         safeZ
     ]);
     useEffect(()=>{
-        if (!transformedData.length) {
-            setLegendItems([]);
-            setActiveIds([]);
-            return;
-        }
+        if (!transformedData.length) return;
+        const isDataChanged = lastLegendDataRef.current !== data;
+        if (hasLegendInitializedRef.current && !isDataChanged) return;
         const groupTypes = Array.from(new Set(transformedData.map((d)=>d.groupType.replace("_compare", "") + "_" + d.isCombine).filter((v)=>null != v)));
         const sortedGroupTypes = sortByIndicators(groupTypes, indicators);
         const lineGroupTypeArr = sortedGroupTypes.filter((v)=>"true" === v.split("_")[1]);
@@ -151,6 +151,8 @@ const G2CombineChart = ({ height = 300, data, x = "", y = "", z = "", indicatorM
             };
         });
         setLegendItems(items);
+        lastLegendDataRef.current = data;
+        hasLegendInitializedRef.current = true;
         const newIds = items.map((i)=>i.id);
         setActiveIds((prev)=>{
             if (!prev.length) return newIds;
@@ -162,7 +164,8 @@ const G2CombineChart = ({ height = 300, data, x = "", y = "", z = "", indicatorM
         transformedData,
         safeIndicatorMap,
         themeColors,
-        indicators
+        indicators,
+        data
     ]);
     const filterLeftData = useMemo(()=>{
         if (!activeIds.length) return leftData;
@@ -170,24 +173,39 @@ const G2CombineChart = ({ height = 300, data, x = "", y = "", z = "", indicatorM
         if (!isGroupRef.current) return result;
         {
             const groupTypes = Array.from(new Set(result.map((d)=>d.groupType)));
+            const groupNameTotalMap = result.reduce((acc, item)=>{
+                const groupName = String(item.groupName);
+                const value = "" === item.groupValue || "-" === item.groupValue ? 0 : Number(item.groupValue) || 0;
+                acc[groupName] = (acc[groupName] ?? 0) + value;
+                return acc;
+            }, {});
+            const leftDataOrder = new Map();
+            leftData.forEach((item)=>{
+                const key = String(item.groupName);
+                if (!leftDataOrder.has(key)) leftDataOrder.set(key, leftDataOrder.size);
+            });
             let groupResult = [];
             groupTypes.forEach((groupType)=>{
-                const groupData = leftData.filter((d)=>d.groupType === groupType);
-                xKey.forEach((key)=>{
-                    if (!result.filter((d)=>d.groupType === groupType).some((d)=>d.groupName === key)) groupData.push({
-                        groupName: key,
-                        isCombine: false,
-                        groupType: groupType,
-                        groupValue: null,
-                        total: 0,
-                        percent: ""
-                    });
+                const groupData = leftData.filter((d)=>d.groupType === groupType).map((d)=>({
+                        ...d
+                    }));
+                groupData.sort((a, b)=>{
+                    if (isDescend) {
+                        const aTotal = groupNameTotalMap[String(a.groupName)] ?? 0;
+                        const bTotal = groupNameTotalMap[String(b.groupName)] ?? 0;
+                        if (aTotal !== bTotal) return bTotal - aTotal;
+                    }
+                    const aIndex = leftDataOrder.get(String(a.groupName));
+                    const bIndex = leftDataOrder.get(String(b.groupName));
+                    if (void 0 === aIndex && void 0 === bIndex) return xKey.indexOf(a.groupName) - xKey.indexOf(b.groupName);
+                    if (void 0 === aIndex) return 1;
+                    if (void 0 === bIndex) return -1;
+                    return aIndex - bIndex;
                 });
-                if (!isDescend) groupData.sort((a, b)=>xKey.indexOf(a.groupName) - xKey.indexOf(b.groupName));
                 groupResult = groupResult.concat(groupData);
             });
             groupResult.forEach((item)=>{
-                item.total = result.filter((d)=>d.groupName === item.groupName).reduce((acc, d)=>acc + ("" === d.groupValue || "-" === d.groupValue ? 0 : d.groupValue), 0);
+                item.total = groupNameTotalMap[String(item.groupName)] ?? 0;
             });
             return groupResult;
         }
@@ -196,11 +214,36 @@ const G2CombineChart = ({ height = 300, data, x = "", y = "", z = "", indicatorM
         activeIds
     ]);
     const filterRightData = useMemo(()=>{
-        if (!activeIds.length) return rightData;
-        return rightData.filter((d)=>d.groupType ? activeIds.includes(String(d.groupType.replace("_compare", "") + "_" + d.isCombine)) : true);
+        const base = activeIds.length ? rightData.filter((d)=>d.groupType ? activeIds.includes(String(d.groupType.replace("_compare", "") + "_" + d.isCombine)) : true) : [
+            ...rightData
+        ];
+        const leftOrder = new Map();
+        filterLeftData.forEach((item)=>{
+            const key = String(item.groupName);
+            if (!leftOrder.has(key)) leftOrder.set(key, leftOrder.size);
+        });
+        const rightOriginOrder = new Map();
+        rightData.forEach((item)=>{
+            const key = String(item.groupName);
+            if (!rightOriginOrder.has(key)) rightOriginOrder.set(key, rightOriginOrder.size);
+        });
+        base.sort((a, b)=>{
+            const aKey = String(a.groupName);
+            const bKey = String(b.groupName);
+            const aLeftIndex = leftOrder.get(aKey);
+            const bLeftIndex = leftOrder.get(bKey);
+            if (void 0 !== aLeftIndex && void 0 !== bLeftIndex) return aLeftIndex - bLeftIndex;
+            if (void 0 !== aLeftIndex) return -1;
+            if (void 0 !== bLeftIndex) return 1;
+            const aOrigin = rightOriginOrder.get(aKey) ?? Number.MAX_SAFE_INTEGER;
+            const bOrigin = rightOriginOrder.get(bKey) ?? Number.MAX_SAFE_INTEGER;
+            return aOrigin - bOrigin;
+        });
+        return base;
     }, [
         rightData,
-        activeIds
+        activeIds,
+        filterLeftData
     ]);
     const maxLeft = useMemo(()=>filterLeftData.reduce((max, item)=>{
             const key = isGroupRef.current ? "total" : safeY;

package/dist/components/g2/base/g2Helpers.js

@@ -260,7 +260,9 @@ function applyNodeData(view, nodeData, x, y) {
 function adjustDomainMax(domainMin, domainMax) {
     return domainMax === domainMin ? domainMin > 0 ? 1.1 * domainMax : domainMax + 1000 : domainMax;
 }
-const sortByIndicators = (arr, indicators)=>arr.sort((a, b)=>{
+const sortByIndicators = (arr, indicators)=>{
+    const hasDuplicateIndicators = new Set(indicators).size !== indicators.length;
+    if (!hasDuplicateIndicators) return arr.sort((a, b)=>{
         const baseA = a.split('_')[0];
         const baseB = b.split('_')[0];
         const indexA = indicators.indexOf(baseA);
@@ -268,6 +270,44 @@ const sortByIndicators = (arr, indicators)=>arr.sort((a, b)=>{
         if (-1 !== indexA && -1 !== indexB) return indexA - indexB;
         return 0;
     });
+    const indicatorPositions = new Map();
+    indicators.forEach((indicatorId, index)=>{
+        const key = String(indicatorId);
+        if (!indicatorPositions.has(key)) indicatorPositions.set(key, []);
+        indicatorPositions.get(key).push(index);
+    });
+    const usedCount = new Map();
+    const getTypeRank = (value)=>{
+        if (value.endsWith('_false')) return 0;
+        if (value.endsWith('_true')) return 1;
+        return 2;
+    };
+    const decorated = arr.map((value, originalIndex)=>{
+        const base = value.split('_')[0];
+        const positions = indicatorPositions.get(base) ?? [];
+        const used = usedCount.get(base) ?? 0;
+        usedCount.set(base, used + 1);
+        const isIndicatorBase = positions.length > 0;
+        return {
+            value,
+            base,
+            originalIndex,
+            typeRank: getTypeRank(value),
+            isIndicatorBase,
+            orderIndex: used < positions.length ? positions[used] : Number.MAX_SAFE_INTEGER
+        };
+    });
+    decorated.sort((a, b)=>{
+        if (a.typeRank !== b.typeRank) return a.typeRank - b.typeRank;
+        if (0 === a.typeRank) {
+            if (!a.isIndicatorBase || !b.isIndicatorBase) return a.originalIndex - b.originalIndex;
+        }
+        if (a.orderIndex !== b.orderIndex) return a.orderIndex - b.orderIndex;
+        return a.originalIndex - b.originalIndex;
+    });
+    arr.splice(0, arr.length, ...decorated.map((item)=>item.value));
+    return arr;
+};
 function intervalSort(a, b) {
     const itemRank = (item)=>{
         if (item.isChange) return 2;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@publishfx/publish-chart",
-  "version": "2.1.31",
+  "version": "2.1.33",
   "description": "A React chart component library for the Publish platform, including BarChart, LineChart, BarLineChart and other visualization components",
   "type": "module",
   "keywords": [