@visactor/vtable 0.13.4-alpha.4 → 0.13.4

package/dist/vtable.js

@@ -40385,21 +40385,11 @@
     }
 
     const DEFAULT_CONTINUOUS_TICK_COUNT = 5;
-    function getAxisDomainRangeAndLabels(min, max, axisOption, isZeroAlign, axisLength, skipTick) {
+    function getAxisDomainRangeAndLabels(min, max, axisOption, isZeroAlign, skipTick) {
         if (axisOption?.zero) {
             min = Math.min(min, 0);
             max = Math.max(max, 0);
         }
-        if (axisOption?.expand) {
-            const domainMin = min;
-            const domainMax = max;
-            if (isValid$6(axisOption.expand.min)) {
-                min = domainMin - (domainMax - domainMin) * axisOption.expand.min;
-            }
-            if (isValid$6(axisOption.expand.max)) {
-                max = domainMax + (domainMax - domainMin) * axisOption.expand.max;
-            }
-        }
         if (isNumber$6(axisOption?.min)) {
             min = axisOption.min;
         }
@@ -40419,16 +40409,8 @@
             scale = new LinearScale();
         }
         scale.domain([min, max], !!axisOption?.nice);
-        if (axisOption?.nice) {
+        if (axisOption?.nice && !isZeroAlign) {
             let tickCount = axisOption.tick?.forceTickCount ?? axisOption.tick?.tickCount ?? 10;
-            if (isFunction$1(tickCount)) {
-                tickCount = tickCount({
-                    axisLength,
-                    labelStyle: axisOption?.label?.style ?? {
-                        fontSize: THEME_CONSTANTS.LABEL_FONT_SIZE
-                    }
-                });
-            }
             if (axisOption.niceType === 'accurateFirst') {
                 tickCount = Math.max(10, tickCount);
             }
@@ -40455,206 +40437,6 @@
         };
     }
 
-    function isValidAlignDomain(domain) {
-        return domain.length === 2 && isValidNumber$1(domain[0]) && isValidNumber$1(domain[1]) && domain[1] >= domain[0];
-    }
-    function getScaleInfo(domain) {
-        const total = domain[1] - domain[0];
-        const includeZero = domain[1] * domain[0] < 0;
-        let negative = domain[0] <= 0 ? 0 - domain[0] : 0;
-        let positive = domain[1] > 0 ? domain[1] - 0 : 0;
-        if (total === 0) {
-            if (domain[0] < 0) {
-                negative = 1;
-                positive = 0;
-            }
-            else if (domain[0] > 0) {
-                negative = 0;
-                positive = 1;
-            }
-        }
-        else {
-            negative = negative / total;
-            positive = positive / total;
-        }
-        return {
-            total,
-            negative,
-            positive,
-            includeZero,
-            domain,
-            extendable_min: true,
-            extendable_max: true
-        };
-    }
-    function inDifferentCrossZero(info1, info2) {
-        const { positive: positive1, negative: negative1, extendable_min: s1Extendable_min, extendable_max: s1Extendable_max, domain: domain1 } = info1;
-        const { positive: positive2, negative: negative2, extendable_min: s2Extendable_min, extendable_max: s2Extendable_max, domain: domain2 } = info2;
-        if (positive2 > 0) {
-            if (!s2Extendable_min) {
-                return false;
-            }
-            let comp = negative1 / positive1;
-            if (s1Extendable_max) {
-                comp = negative1 / Math.max(positive1, positive2);
-                domain1[1] = -domain1[0] / comp;
-            }
-            domain2[0] = -domain2[1] * comp;
-        }
-        else if (negative2 > 0) {
-            if (!s2Extendable_max) {
-                return false;
-            }
-            let comp = positive1 / negative1;
-            if (s1Extendable_min) {
-                comp = positive1 / Math.max(negative1, negative1);
-                domain1[0] = -domain1[1] / comp;
-            }
-            domain2[1] = -domain2[0] * comp;
-        }
-        return true;
-    }
-    function inOnlyZeroDomain(info1, info2) {
-        const { extendable_min: s1Extendable_min, extendable_max: s1Extendable_max, domain: domain1 } = info1;
-        const { positive: positive2, negative: negative2, domain: domain2 } = info2;
-        if (positive2 === 0 && negative2 === 0) {
-            return false;
-        }
-        if (positive2 > 0 && !s1Extendable_max) {
-            return false;
-        }
-        if (negative2 > 0 && !s1Extendable_min) {
-            return false;
-        }
-        domain1[0] = domain2[0];
-        domain1[1] = domain2[1];
-        return true;
-    }
-    function inAllCrossZero(info1, info2) {
-        const { positive: positive1, negative: negative1, extendable_max: s1Extendable_max, domain: domain1 } = info1;
-        const { positive: positive2, negative: negative2, extendable_min: s2Extendable_min, domain: domain2 } = info2;
-        if (s1Extendable_max && s2Extendable_min) {
-            const comp = Math.max(negative1, negative2) / Math.max(positive1, positive2);
-            domain1[1] = -domain1[0] / comp;
-            domain2[0] = -domain2[1] * comp;
-        }
-        else if (s2Extendable_min) {
-            const comp = negative1 / positive1;
-            domain2[0] = -domain2[1] * comp;
-        }
-        else if (s1Extendable_max) {
-            const comp = negative2 / positive2;
-            domain1[1] = -domain1[0] / comp;
-        }
-        else {
-            return false;
-        }
-        return true;
-    }
-    function inNoCrossDifferentSide(info1, info2) {
-        const { extendable_min: s1Extendable_min, domain: domain1 } = info1;
-        const { extendable_max: s2Extendable_max, domain: domain2 } = info2;
-        if (!s1Extendable_min || !s2Extendable_max) {
-            return false;
-        }
-        domain1[0] = -domain1[1];
-        domain2[1] = -domain2[0];
-        return true;
-    }
-    function getNewRangeToAlign(range1, range2) {
-        const domain1 = [range1.min, range1.max];
-        const domain2 = [range2.min, range2.max];
-        if (!isValidAlignDomain(domain1) || !isValidAlignDomain(domain2)) {
-            return undefined;
-        }
-        const info1 = getScaleInfo(domain1);
-        const info2 = getScaleInfo(domain2);
-        const { positive: positive1, negative: negative1, extendable_min: s1Extendable_min, extendable_max: s1Extendable_max, includeZero: includeZero1 } = info1;
-        const { positive: positive2, negative: negative2, extendable_min: s2Extendable_min, extendable_max: s2Extendable_max, includeZero: includeZero2 } = info2;
-        if (positive1 === 0 && negative1 === 0) {
-            if (!inOnlyZeroDomain(info1, info2)) {
-                return undefined;
-            }
-        }
-        else if (positive2 === 0 && negative2 === 0) {
-            if (!inOnlyZeroDomain(info2, info1)) {
-                return undefined;
-            }
-        }
-        else if (!includeZero1 && !includeZero2) {
-            if (negative1 === 0 && positive2 === 0) {
-                if (!inNoCrossDifferentSide(info1, info2)) {
-                    return undefined;
-                }
-            }
-            else if (negative2 === 0 && positive1 === 0) {
-                if (!inNoCrossDifferentSide(info2, info1)) {
-                    return undefined;
-                }
-            }
-            if (negative1 === 0 && negative2 === 0) {
-                if (domain1[0] === 0 && domain2[0] > 0) {
-                    if (!s2Extendable_min) {
-                        return undefined;
-                    }
-                    domain2[0] = 0;
-                }
-                else if (domain2[0] === 0 && domain1[0] > 0) {
-                    if (!s1Extendable_min) {
-                        return undefined;
-                    }
-                    domain1[0] = 0;
-                }
-                else {
-                    return undefined;
-                }
-            }
-            if (positive1 === 0 && positive2 === 0) {
-                if (domain1[1] === 0 && domain2[1] > 0) {
-                    if (!s2Extendable_max) {
-                        return undefined;
-                    }
-                    domain2[1] = 0;
-                }
-                else if (domain2[1] === 0 && domain1[1] > 0) {
-                    if (!s1Extendable_max) {
-                        return undefined;
-                    }
-                    domain1[1] = 0;
-                }
-                else {
-                    return undefined;
-                }
-            }
-        }
-        else if (includeZero1 && !includeZero2) {
-            if (!inDifferentCrossZero(info1, info2)) {
-                return undefined;
-            }
-        }
-        else if (includeZero2 && !includeZero1) {
-            if (!inDifferentCrossZero(info2, info1)) {
-                return undefined;
-            }
-        }
-        else {
-            if (negative1 === negative2) {
-                return undefined;
-            }
-            else if (negative1 > negative2) {
-                if (!inAllCrossZero(info1, info2)) {
-                    return undefined;
-                }
-            }
-            else {
-                if (!inAllCrossZero(info2, info1)) {
-                    return undefined;
-                }
-            }
-        }
-        return { range1: domain1, range2: domain2 };
-    }
-
     function getAxisConfigInPivotChart(col, row, layout) {
         if (!layout._table.isPivotChart()) {
             return undefined;
@@ -40664,22 +40446,23 @@
                 row === layout.columnHeaderLevelCount - 1 &&
                 col >= layout.rowHeaderLevelCount &&
                 col < layout.colCount - layout.rightFrozenColCount) {
-                const axisRange = getRange$1('top', col, row + 1, col, layout.columnHeaderLevelCount - 1, col, row, 1, layout);
-                if (!axisRange) {
+                const { axisOption, isPercent, isZeroAlign, seriesIndice } = getAxisOption(col, row + 1, 'top', layout);
+                if (axisOption?.visible === false) {
                     return;
                 }
-                const { range, ticks, axisOption, isZeroAlign } = axisRange;
-                if (isZeroAlign) {
-                    const subAxisRange = getRange$1('bottom', col, row + 1, col, layout.columnHeaderLevelCount - 1, col, row, 0, layout);
-                    if (subAxisRange) {
-                        const { range: subRange } = subAxisRange;
-                        const align = getNewRangeToAlign(range, subRange);
-                        if (align) {
-                            range.min = align.range1[0];
-                            range.max = align.range1[1];
-                        }
-                    }
+                const indicatorKeys = layout.getIndicatorKeyInChartSpec(col, layout.columnHeaderLevelCount - 1);
+                const colPath = layout.getColKeysPath(col, row);
+                const range = getAxisRange(layout.dataset.collectedValues, indicatorKeys, isZeroAlign, colPath, seriesIndice ?? 1);
+                if (!range) {
+                    return;
+                }
+                if (isPercent) {
+                    range.min = range.min < 0 ? -1 : 0;
+                    range.max = range.max > 0 ? 1 : 0;
                 }
+                const { range: niceRange, ticks } = getAxisDomainRangeAndLabels(range.min, range.max, axisOption, isZeroAlign);
+                range.min = !isNaN(niceRange[0]) ? niceRange[0] : 0;
+                range.max = !isNaN(niceRange[1]) ? niceRange[1] : 1;
                 if (isNumber$6(axisOption?.min)) {
                     range.min = axisOption.min;
                     if (range.min > 0) {
@@ -40706,7 +40489,16 @@
             else if (row === layout.rowCount - layout.bottomFrozenRowCount &&
                 col >= layout.rowHeaderLevelCount &&
                 col < layout.colCount - layout.rightFrozenColCount) {
+                const { axisOption, isPercent, isZeroAlign, seriesIndice } = getAxisOption(col, row - 1, 'bottom', layout);
+                if (axisOption?.visible === false) {
+                    return;
+                }
                 const indicatorKeys = layout.getIndicatorKeyInChartSpec(col, row);
+                const colPath = layout.getColKeysPath(col, row);
+                const range = getAxisRange(layout.dataset.collectedValues, indicatorKeys, isZeroAlign, colPath, seriesIndice ?? 0);
+                if (!range) {
+                    return;
+                }
                 let indicatorInfo = null;
                 indicatorKeys?.forEach(key => {
                     const info = layout.getIndicatorInfo(key);
@@ -40714,22 +40506,13 @@
                         indicatorInfo = info;
                     }
                 });
-                const axisRange = getRange$1('bottom', col, row - 1, col, row, col, row, 0, layout);
-                if (!axisRange) {
-                    return;
-                }
-                const { range, ticks, axisOption, isZeroAlign } = axisRange;
-                if (isZeroAlign) {
-                    const subAxisRange = getRange$1('top', col, row - 1, col, row, col, row, 1, layout);
-                    if (subAxisRange) {
-                        const { range: subRange } = subAxisRange;
-                        const align = getNewRangeToAlign(range, subRange);
-                        if (align) {
-                            range.min = align.range1[0];
-                            range.max = align.range1[1];
-                        }
-                    }
+                if (isPercent) {
+                    range.min = range.min < 0 ? -1 : 0;
+                    range.max = range.max > 0 ? 1 : 0;
                 }
+                const { range: niceRange, ticks } = getAxisDomainRangeAndLabels(range.min, range.max, axisOption, isZeroAlign);
+                range.min = !isNaN(niceRange[0]) ? niceRange[0] : 0;
+                range.max = !isNaN(niceRange[1]) ? niceRange[1] : 1;
                 if (isNumber$6(axisOption?.min)) {
                     range.min = axisOption.min;
                     if (range.min > 0) {
@@ -40786,7 +40569,16 @@
             if (col === layout.rowHeaderLevelCount - 1 &&
                 row >= layout.columnHeaderLevelCount &&
                 row < layout.rowCount - layout.bottomFrozenRowCount) {
+                const { axisOption, isPercent, isZeroAlign, seriesIndice } = getAxisOption(col + 1, row, 'left', layout);
+                if (axisOption?.visible === false) {
+                    return;
+                }
                 const indicatorKeys = layout.getIndicatorKeyInChartSpec(col, row);
+                const rowPath = layout.getRowKeysPath(col, row);
+                const range = getAxisRange(layout.dataset.collectedValues, indicatorKeys, isZeroAlign, rowPath, seriesIndice ?? 0);
+                if (!range) {
+                    return;
+                }
                 let indicatorInfo = null;
                 indicatorKeys?.forEach(key => {
                     const info = layout.getIndicatorInfo(key);
@@ -40794,22 +40586,13 @@
                         indicatorInfo = info;
                     }
                 });
-                const axisRange = getRange$1('left', col + 1, row, col, row, col, row, 0, layout);
-                if (!axisRange) {
-                    return;
-                }
-                const { range, ticks, axisOption, isZeroAlign } = axisRange;
-                if (isZeroAlign) {
-                    const subAxisRange = getRange$1('right', col + 1, row, col, row, col, row, 1, layout);
-                    if (subAxisRange) {
-                        const { range: subRange } = subAxisRange;
-                        const align = getNewRangeToAlign(range, subRange);
-                        if (align) {
-                            range.min = align.range1[0];
-                            range.max = align.range1[1];
-                        }
-                    }
+                if (isPercent) {
+                    range.min = range.min < 0 ? -1 : 0;
+                    range.max = range.max > 0 ? 1 : 0;
                 }
+                const { range: niceRange, ticks } = getAxisDomainRangeAndLabels(range.min, range.max, axisOption, isZeroAlign);
+                range.min = !isNaN(niceRange[0]) ? niceRange[0] : 0;
+                range.max = !isNaN(niceRange[1]) ? niceRange[1] : 1;
                 if (isNumber$6(axisOption?.min)) {
                     range.min = axisOption.min;
                     if (range.min > 0) {
@@ -40841,22 +40624,23 @@
             else if (col === layout.colCount - layout.rightFrozenColCount &&
                 row >= layout.columnHeaderLevelCount &&
                 row < layout.rowCount - layout.bottomFrozenRowCount) {
-                const axisRange = getRange$1('right', col - 1, row, layout.rowHeaderLevelCount - 1, row, col, row, 1, layout);
-                if (!axisRange) {
+                const { axisOption, isPercent, isZeroAlign, seriesIndice } = getAxisOption(col - 1, row, 'right', layout);
+                if (axisOption?.visible === false) {
                     return;
                 }
-                const { range, ticks, axisOption, isZeroAlign } = axisRange;
-                if (isZeroAlign) {
-                    const subAxisRange = getRange$1('left', col - 1, row, layout.rowHeaderLevelCount - 1, row, col, row, 0, layout);
-                    if (subAxisRange) {
-                        const { range: subRange } = subAxisRange;
-                        const align = getNewRangeToAlign(range, subRange);
-                        if (align) {
-                            range.min = align.range1[0];
-                            range.max = align.range1[1];
-                        }
-                    }
+                const indicatorKeys = layout.getIndicatorKeyInChartSpec(layout.rowHeaderLevelCount - 1, row);
+                const rowPath = layout.getRowKeysPath(col, row);
+                const range = getAxisRange(layout.dataset.collectedValues, indicatorKeys, isZeroAlign, rowPath, seriesIndice ?? 1);
+                if (!range) {
+                    return;
+                }
+                if (isPercent) {
+                    range.min = range.min < 0 ? -1 : 0;
+                    range.max = range.max > 0 ? 1 : 0;
                 }
+                const { range: niceRange, ticks } = getAxisDomainRangeAndLabels(range.min, range.max, axisOption, isZeroAlign);
+                range.min = !isNaN(niceRange[0]) ? niceRange[0] : 0;
+                range.max = !isNaN(niceRange[1]) ? niceRange[1] : 1;
                 if (isNumber$6(axisOption?.min)) {
                     range.min = axisOption.min;
                     if (range.min > 0) {
@@ -40997,7 +40781,9 @@
         if (!defaultKey) {
             return null;
         }
-        const data = collectedValues[defaultKey];
+        const data = collectedValues[defaultKey + (isZeroAlign ? '_align' : '')]
+            ? collectedValues[defaultKey + (isZeroAlign ? '_align' : '')]
+            : collectedValues[defaultKey];
         const range = merge$1({}, data?.[colPath ?? ''] ?? { min: 0, max: 1 });
         if (range.positiveMax && range.positiveMax > range.max) {
             range.max = range.positiveMax;
@@ -41015,49 +40801,6 @@
         }
         return range;
     }
-    function getRange$1(position, colForAxisOption, rowForAxisOption, colForIndicatorKey, rowForIndicatorKey, col, row, defaultSeriesIndice, layout) {
-        const { axisOption, isPercent, isZeroAlign, seriesIndice } = getAxisOption(colForAxisOption, rowForAxisOption, position, layout);
-        if (axisOption?.visible === false) {
-            return undefined;
-        }
-        const indicatorKeys = layout.getIndicatorKeyInChartSpec(colForIndicatorKey, rowForIndicatorKey);
-        let path;
-        if (position === 'top' || position === 'bottom') {
-            path = layout.getColKeysPath(col, row);
-        }
-        else {
-            path = layout.getRowKeysPath(col, row);
-        }
-        const range = getAxisRange(layout.dataset.collectedValues, indicatorKeys, isZeroAlign, path, seriesIndice ?? defaultSeriesIndice);
-        if (!range) {
-            return undefined;
-        }
-        if (isPercent) {
-            range.min = range.min < 0 ? -1 : 0;
-            range.max = range.max > 0 ? 1 : 0;
-        }
-        const { range: niceRange, ticks } = getAxisDomainRangeAndLabels(range.min, range.max, axisOption, isZeroAlign, layout._table.getColWidth(col));
-        range.min = !isNaN(niceRange[0]) ? niceRange[0] : 0;
-        range.max = !isNaN(niceRange[1]) ? niceRange[1] : 1;
-        if (isNumber$6(axisOption?.min)) {
-            range.min = axisOption.min;
-            if (range.min > 0) {
-                axisOption.zero = false;
-            }
-        }
-        if (isNumber$6(axisOption?.max)) {
-            range.max = axisOption.max;
-            if (range.max < 0) {
-                axisOption.zero = false;
-            }
-        }
-        return {
-            axisOption,
-            isZeroAlign,
-            range,
-            ticks
-        };
-    }
 
     function computeAxisComponentWidth(config, table) {
         const attribute = merge$1({}, commonAxis, config);
@@ -41669,6 +41412,9 @@
         let rowStart = 0;
         let rowEnd = 0;
         if (row < scene.table.columnHeaderLevelCount) {
+            scene.colHeaderGroup.setAttribute('height', scene.colHeaderGroup.attribute.height + detaY);
+            scene.rowHeaderGroup.setAttribute('y', scene.colHeaderGroup.attribute.y + detaY);
+            scene.bodyGroup.setAttribute('y', scene.bodyGroup.attribute.y + detaY);
             rowStart = row + 1;
             rowEnd = scene.table.columnHeaderLevelCount - 1;
         }
@@ -44283,7 +44029,7 @@
             stroke: false,
             x: padding[3],
             y: padding[0],
-            canvas: table.canvas ?? table.scenegraph.stage.window.getContext().canvas,
+            canvas: table.canvas,
             mode: table.options.mode,
             modeParams: table.options.modeParams,
             spec: chartSpec,
@@ -54039,9 +53785,6 @@
         adjustTableSize(attrs) {
             let width = isFinite(this.legendComponent.AABBBounds.width()) ? this.legendComponent.AABBBounds.width() : 0;
             let height = isFinite(this.legendComponent.AABBBounds.height()) ? this.legendComponent.AABBBounds.height() : 0;
-            if (width <= 0 || height <= 0) {
-                return;
-            }
             const rectWidth = this.table.tableNoFrameWidth;
             const rectHeight = this.table.tableNoFrameHeight;
             const padding = getQuadProps(attrs.padding ?? this.option.padding ?? 10);
@@ -54349,9 +54092,6 @@
         adjustTableSize(attrs) {
             let width = isFinite(this.legendComponent.AABBBounds.width()) ? this.legendComponent.AABBBounds.width() : 0;
             let height = isFinite(this.legendComponent.AABBBounds.height()) ? this.legendComponent.AABBBounds.height() : 0;
-            if (width <= 0 || height <= 0) {
-                return;
-            }
             const rectWidth = this.table.tableNoFrameWidth;
             const rectHeight = this.table.tableNoFrameHeight;
             const padding = getQuadProps(attrs.padding ?? this.option.padding ?? 10);
@@ -54501,7 +54241,7 @@
             return TABLE_EVENT_TYPE;
         }
         options;
-        version = "0.13.4-alpha.4";
+        version = "0.13.4";
         pagination;
         id = `VTable${Date.now()}`;
         headerStyleCache;
@@ -56636,7 +56376,6 @@
             if (this.options.mode !== 'node') {
                 return;
             }
-            this.render();
             const stage = this.scenegraph.stage;
             if (stage) {
                 const contentWidth = this.tableX + this.getAllColsWidth();
@@ -56824,17 +56563,20 @@
             const indicatorKeys = layout.getIndicatorKeyInChartSpec(col, row);
             const colPath = layout.getColKeysPath(col, row);
             indicatorKeys.forEach((key, index) => {
-                const { range, isZeroAlign, axisOption } = getRange(col, row, index, index === 0 ? 'bottom' : 'top', indicatorKeys, colPath, layout);
-                if (isZeroAlign) {
-                    const subAxisRange = getRange(col, row, indicatorKeys.length - 1 - index, index === 0 ? 'top' : 'bottom', indicatorKeys, colPath, layout);
-                    if (subAxisRange) {
-                        const { range: subRange } = subAxisRange;
-                        const align = getNewRangeToAlign(range, subRange);
-                        if (align) {
-                            range.min = align.range1[0];
-                            range.max = align.range1[1];
-                        }
-                    }
+                const { axisOption, isPercent, isZeroAlign, seriesIndice } = getAxisOption(col, row, index === 0 ? 'bottom' : 'top', layout);
+                const range = getAxisRange(layout.dataset.collectedValues, indicatorKeys, isZeroAlign, colPath, seriesIndice ?? index);
+                if (isPercent) {
+                    range.min = range.min < 0 ? -1 : 0;
+                    range.max = range.max > 0 ? 1 : 0;
+                }
+                if (axisOption?.zero || range.min === range.max) {
+                    range.min = Math.min(range.min, 0);
+                    range.max = Math.max(range.max, 0);
+                }
+                if (axisOption?.nice) {
+                    const { range: axisRange } = getAxisDomainRangeAndLabels(range.min, range.max, axisOption, isZeroAlign);
+                    range.min = axisRange[0];
+                    range.max = axisRange[1];
                 }
                 if (isNumber$6(axisOption?.min)) {
                     range.min = axisOption.min;
@@ -56882,17 +56624,20 @@
             const indicatorKeys = layout.getIndicatorKeyInChartSpec(col, row);
             const rowPath = layout.getRowKeysPath(col, row);
             indicatorKeys.forEach((key, index) => {
-                const { range, isZeroAlign, axisOption } = getRange(col, row, index, index === 0 ? 'left' : 'right', indicatorKeys, rowPath, layout);
-                if (isZeroAlign) {
-                    const subAxisRange = getRange(col, row, indicatorKeys.length - 1 - index, index === 0 ? 'right' : 'left', indicatorKeys, rowPath, layout);
-                    if (subAxisRange) {
-                        const { range: subRange } = subAxisRange;
-                        const align = getNewRangeToAlign(range, subRange);
-                        if (align) {
-                            range.min = align.range1[0];
-                            range.max = align.range1[1];
-                        }
-                    }
+                const { axisOption, isPercent, isZeroAlign, seriesIndice } = getAxisOption(col, row, index === 0 ? 'left' : 'right', layout);
+                const range = getAxisRange(layout.dataset.collectedValues, indicatorKeys, isZeroAlign, rowPath, seriesIndice ?? index);
+                if (isPercent) {
+                    range.min = range.min < 0 ? -1 : 0;
+                    range.max = range.max > 0 ? 1 : 0;
+                }
+                if (axisOption?.zero || range.min === range.max) {
+                    range.min = Math.min(range.min, 0);
+                    range.max = Math.max(range.max, 0);
+                }
+                if (axisOption?.nice) {
+                    const { range: axisRange } = getAxisDomainRangeAndLabels(range.min, range.max, axisOption, isZeroAlign);
+                    range.min = axisRange[0];
+                    range.max = axisRange[1];
                 }
                 if (isNumber$6(axisOption?.min)) {
                     range.min = axisOption.min;
@@ -56963,34 +56708,6 @@
         }
         return chartSpec.data.id;
     }
-    function getRange(col, row, index, position, indicatorKeys, path, layout) {
-        const { axisOption, isPercent, isZeroAlign, seriesIndice } = getAxisOption(col, row, position, layout);
-        const range = getAxisRange(layout.dataset.collectedValues, indicatorKeys, isZeroAlign, path, seriesIndice ?? index);
-        if (isPercent) {
-            range.min = range.min < 0 ? -1 : 0;
-            range.max = range.max > 0 ? 1 : 0;
-        }
-        if (axisOption?.zero || range.min === range.max) {
-            range.min = Math.min(range.min, 0);
-            range.max = Math.max(range.max, 0);
-        }
-        if (axisOption?.nice) {
-            const { range: axisRange } = getAxisDomainRangeAndLabels(range.min, range.max, axisOption, isZeroAlign, layout._table.getColWidth(col));
-            range.min = axisRange[0];
-            range.max = axisRange[1];
-        }
-        if (isNumber$6(axisOption?.min)) {
-            range.min = axisOption.min;
-        }
-        if (isNumber$6(axisOption?.max)) {
-            range.max = axisOption.max;
-        }
-        return {
-            range,
-            isZeroAlign,
-            axisOption
-        };
-    }
 
     let seqId = 0;
     class SimpleHeaderLayoutMap {
@@ -57720,9 +57437,7 @@
         constructor(titleOption, table) {
             this.table = table;
             this._titleOption = titleOption;
-            if (titleOption.visible !== false) {
-                this._titleComponent = this._createOrUpdateTitleComponent(this._getTitleAttrs());
-            }
+            this._titleComponent = this._createOrUpdateTitleComponent(this._getTitleAttrs());
         }
         _createOrUpdateTitleComponent(attrs) {
             if (this._titleComponent) {
@@ -57773,8 +57488,8 @@
             this._adjustTableSize(this._titleComponent.attribute);
         }
         _adjustTableSize(attrs) {
-            const width = isFinite(this._titleComponent?.AABBBounds.width()) ? this._titleComponent.AABBBounds.width() : 0;
-            const height = isFinite(this._titleComponent?.AABBBounds.height()) ? this._titleComponent.AABBBounds.height() : 0;
+            const width = isFinite(this._titleComponent.AABBBounds.width()) ? this._titleComponent.AABBBounds.width() : 0;
+            const height = isFinite(this._titleComponent.AABBBounds.height()) ? this._titleComponent.AABBBounds.height() : 0;
             if (this._titleOption.orient === 'left') {
                 this.table.tableNoFrameWidth = this.table.tableNoFrameWidth - Math.ceil(width);
                 this.table.tableX += Math.ceil(width);
@@ -57807,8 +57522,7 @@
             this.isReleased = true;
         }
         _getTitleAttrs() {
-            const defaultPadding = this._titleOption.text || this._titleOption.subtext ? 10 : 0;
-            const padding = getQuadProps(this._titleOption.padding ?? defaultPadding);
+            const padding = getQuadProps(this._titleOption.padding ?? 10);
             const realWidth = this._titleOption.width ??
                 Math.min(this.table.tableNoFrameWidth, this.table.getDrawRange().width) - padding[1] - padding[3];
             const realHeight = this._titleOption.height ??
@@ -61053,6 +60767,206 @@
         };
     }
 
+    function isValidAlignDomain(domain) {
+        return domain.length === 2 && isValidNumber$1(domain[0]) && isValidNumber$1(domain[1]) && domain[1] >= domain[0];
+    }
+    function getScaleInfo(domain) {
+        const total = domain[1] - domain[0];
+        const includeZero = domain[1] * domain[0] < 0;
+        let negative = domain[0] <= 0 ? 0 - domain[0] : 0;
+        let positive = domain[1] > 0 ? domain[1] - 0 : 0;
+        if (total === 0) {
+            if (domain[0] < 0) {
+                negative = 1;
+                positive = 0;
+            }
+            else if (domain[0] > 0) {
+                negative = 0;
+                positive = 1;
+            }
+        }
+        else {
+            negative = negative / total;
+            positive = positive / total;
+        }
+        return {
+            total,
+            negative,
+            positive,
+            includeZero,
+            domain,
+            extendable_min: true,
+            extendable_max: true
+        };
+    }
+    function inDifferentCrossZero(info1, info2) {
+        const { positive: positive1, negative: negative1, extendable_min: s1Extendable_min, extendable_max: s1Extendable_max, domain: domain1 } = info1;
+        const { positive: positive2, negative: negative2, extendable_min: s2Extendable_min, extendable_max: s2Extendable_max, domain: domain2 } = info2;
+        if (positive2 > 0) {
+            if (!s2Extendable_min) {
+                return false;
+            }
+            let comp = negative1 / positive1;
+            if (s1Extendable_max) {
+                comp = negative1 / Math.max(positive1, positive2);
+                domain1[1] = -domain1[0] / comp;
+            }
+            domain2[0] = -domain2[1] * comp;
+        }
+        else if (negative2 > 0) {
+            if (!s2Extendable_max) {
+                return false;
+            }
+            let comp = positive1 / negative1;
+            if (s1Extendable_min) {
+                comp = positive1 / Math.max(negative1, negative1);
+                domain1[0] = -domain1[1] / comp;
+            }
+            domain2[1] = -domain2[0] * comp;
+        }
+        return true;
+    }
+    function inOnlyZeroDomain(info1, info2) {
+        const { extendable_min: s1Extendable_min, extendable_max: s1Extendable_max, domain: domain1 } = info1;
+        const { positive: positive2, negative: negative2, domain: domain2 } = info2;
+        if (positive2 === 0 && negative2 === 0) {
+            return false;
+        }
+        if (positive2 > 0 && !s1Extendable_max) {
+            return false;
+        }
+        if (negative2 > 0 && !s1Extendable_min) {
+            return false;
+        }
+        domain1[0] = domain2[0];
+        domain1[1] = domain2[1];
+        return true;
+    }
+    function inAllCrossZero(info1, info2) {
+        const { positive: positive1, negative: negative1, extendable_max: s1Extendable_max, domain: domain1 } = info1;
+        const { positive: positive2, negative: negative2, extendable_min: s2Extendable_min, domain: domain2 } = info2;
+        if (s1Extendable_max && s2Extendable_min) {
+            const comp = Math.max(negative1, negative2) / Math.max(positive1, positive2);
+            domain1[1] = -domain1[0] / comp;
+            domain2[0] = -domain2[1] * comp;
+        }
+        else if (s2Extendable_min) {
+            const comp = negative1 / positive1;
+            domain2[0] = -domain2[1] * comp;
+        }
+        else if (s1Extendable_max) {
+            const comp = negative2 / positive2;
+            domain1[1] = -domain1[0] / comp;
+        }
+        else {
+            return false;
+        }
+        return true;
+    }
+    function inNoCrossDifferentSide(info1, info2) {
+        const { extendable_min: s1Extendable_min, domain: domain1 } = info1;
+        const { extendable_max: s2Extendable_max, domain: domain2 } = info2;
+        if (!s1Extendable_min || !s2Extendable_max) {
+            return false;
+        }
+        domain1[0] = -domain1[1];
+        domain2[1] = -domain2[0];
+        return true;
+    }
+    function getNewRangeToAlign(range1, range2) {
+        const domain1 = [range1.min, range1.max];
+        const domain2 = [range2.min, range2.max];
+        if (!isValidAlignDomain(domain1) || !isValidAlignDomain(domain2)) {
+            return undefined;
+        }
+        const info1 = getScaleInfo(domain1);
+        const info2 = getScaleInfo(domain2);
+        const { positive: positive1, negative: negative1, extendable_min: s1Extendable_min, extendable_max: s1Extendable_max, includeZero: includeZero1 } = info1;
+        const { positive: positive2, negative: negative2, extendable_min: s2Extendable_min, extendable_max: s2Extendable_max, includeZero: includeZero2 } = info2;
+        if (positive1 === 0 && negative1 === 0) {
+            if (!inOnlyZeroDomain(info1, info2)) {
+                return undefined;
+            }
+        }
+        else if (positive2 === 0 && negative2 === 0) {
+            if (!inOnlyZeroDomain(info2, info1)) {
+                return undefined;
+            }
+        }
+        else if (!includeZero1 && !includeZero2) {
+            if (negative1 === 0 && positive2 === 0) {
+                if (!inNoCrossDifferentSide(info1, info2)) {
+                    return undefined;
+                }
+            }
+            else if (negative2 === 0 && positive1 === 0) {
+                if (!inNoCrossDifferentSide(info2, info1)) {
+                    return undefined;
+                }
+            }
+            if (negative1 === 0 && negative2 === 0) {
+                if (domain1[0] === 0 && domain2[0] > 0) {
+                    if (!s2Extendable_min) {
+                        return undefined;
+                    }
+                    domain2[0] = 0;
+                }
+                else if (domain2[0] === 0 && domain1[0] > 0) {
+                    if (!s1Extendable_min) {
+                        return undefined;
+                    }
+                    domain1[0] = 0;
+                }
+                else {
+                    return undefined;
+                }
+            }
+            if (positive1 === 0 && positive2 === 0) {
+                if (domain1[1] === 0 && domain2[1] > 0) {
+                    if (!s2Extendable_max) {
+                        return undefined;
+                    }
+                    domain2[1] = 0;
+                }
+                else if (domain2[1] === 0 && domain1[1] > 0) {
+                    if (!s1Extendable_max) {
+                        return undefined;
+                    }
+                    domain1[1] = 0;
+                }
+                else {
+                    return undefined;
+                }
+            }
+        }
+        else if (includeZero1 && !includeZero2) {
+            if (!inDifferentCrossZero(info1, info2)) {
+                return undefined;
+            }
+        }
+        else if (includeZero2 && !includeZero1) {
+            if (!inDifferentCrossZero(info2, info1)) {
+                return undefined;
+            }
+        }
+        else {
+            if (negative1 === negative2) {
+                return undefined;
+            }
+            else if (negative1 > negative2) {
+                if (!inAllCrossZero(info1, info2)) {
+                    return undefined;
+                }
+            }
+            else {
+                if (!inAllCrossZero(info2, info1)) {
+                    return undefined;
+                }
+            }
+        }
+        return { range1: domain1, range2: domain2 };
+    }
+
     class Dataset {
         dataConfig;
         records;
@@ -61166,6 +61080,7 @@
                 }
                 typeof window !== 'undefined' ? window.performance.now() : 0;
                 if (this.dataConfig?.isPivotChart) {
+                    this.dealWithZeroAlign();
                     this.cacheDeminsionCollectedValues();
                 }
             }
@@ -61498,6 +61413,7 @@
             this.processCollectedValuesWithSumBy();
             this.processCollectedValuesWithSortBy();
             if (this.dataConfig?.isPivotChart) {
+                this.dealWithZeroAlign();
                 this.cacheDeminsionCollectedValues();
             }
         }
@@ -61962,6 +61878,44 @@
             tree.forEach((treeNode) => getPath(treeNode, []));
             return result;
         }
+        dealWithZeroAlign() {
+            const indicatorsToAlign = [];
+            for (let i = 0; i < this.aggregationRules.length; i++) {
+                const rule = this.aggregationRules[i];
+                if (isArray$5(rule.field) && rule.field.length === 2) {
+                    indicatorsToAlign.push(rule.field);
+                }
+            }
+            indicatorsToAlign.forEach(indicatorToAlign => {
+                const indicator1 = indicatorToAlign[0];
+                const indicator2 = indicatorToAlign[1];
+                const collectedValue1 = this.collectedValues[indicator1];
+                const collectedValue2 = this.collectedValues[indicator2];
+                this.collectedValues[indicator1 + '_align'] = {};
+                this.collectedValues[indicator2 + '_align'] = {};
+                const toAlignCollectedValue = collectedValue1 || collectedValue2;
+                for (const key in toAlignCollectedValue) {
+                    const range1 = collectedValue1?.[key] ?? { min: 0, max: 1 };
+                    const range2 = collectedValue2?.[key] ?? { min: 0, max: 1 };
+                    const newRanges = getNewRangeToAlign(range1, range2);
+                    if (!newRanges) {
+                        this.collectedValues[indicator1 + '_align'][key] = {
+                            min: range1.min,
+                            max: range1.max
+                        };
+                        this.collectedValues[indicator2 + '_align'][key] = {
+                            min: range2.min,
+                            max: range2.max
+                        };
+                    }
+                    else {
+                        const { range1: newRange1, range2: newRange2 } = newRanges;
+                        this.collectedValues[indicator1 + '_align'][key] = { min: newRange1[0], max: newRange1[1] };
+                        this.collectedValues[indicator2 + '_align'][key] = { min: newRange2[0], max: newRange2[1] };
+                    }
+                }
+            });
+        }
         cacheDeminsionCollectedValues() {
             for (const key in this.collectValuesBy) {
                 if (this.collectValuesBy[key].type === 'xField' || this.collectValuesBy[key].type === 'yField') {
@@ -64222,7 +64176,7 @@
         return new Tag(params ? params.attribute : {});
     }
 
-    const version = "0.13.4-alpha.4";
+    const version = "0.13.4";
     function getIcons() {
         return get$1();
     }