@visactor/vchart 1.1.0-beta.2 → 1.1.0-beta.3

package/build/index.js

@@ -47984,6 +47984,7 @@
         ChartEvent["viewDataStatisticsUpdate"] = "viewDataStatisticsUpdate";
         ChartEvent["markDeltaYUpdate"] = "markDeltaYUpdate";
         ChartEvent["viewDataLabelUpdate"] = "viewDataLabelUpdate";
+        ChartEvent["scaleDomainUpdate"] = "scaleDomainUpdate";
         ChartEvent["scaleUpdate"] = "scaleUpdate";
         ChartEvent["dataZoomChange"] = "dataZoomChange";
         ChartEvent["drill"] = "drill";
@@ -49987,8 +49988,8 @@
             }
             return this;
         }
-        emit(eType, params) {
-            this._eventDispatcher.dispatch(eType, params);
+        emit(eType, params, level) {
+            this._eventDispatcher.dispatch(eType, params, level);
             return this;
         }
         release() {
@@ -50104,25 +50105,31 @@
             }
             return this;
         }
-        dispatch(eType, params) {
+        dispatch(eType, params, level) {
             const bubble = this.getEventBubble(params.source || Event_Source_Type.chart).get(eType);
             if (!bubble) {
                 return this;
             }
             let stopBubble = false;
-            const handlers = bubble.getHandlers(Event_Bubble_Level.mark);
-            stopBubble = this._invoke(handlers, eType, params);
-            if (!stopBubble) {
-                const handlers = bubble.getHandlers(Event_Bubble_Level.model);
+            if (level) {
+                const handlers = bubble.getHandlers(level);
                 stopBubble = this._invoke(handlers, eType, params);
             }
-            if (!stopBubble) {
-                const handlers = bubble.getHandlers(Event_Bubble_Level.chart);
-                stopBubble = this._invoke(handlers, eType, params);
-            }
-            if (!stopBubble) {
-                const handlers = bubble.getHandlers(Event_Bubble_Level.vchart);
+            else {
+                const handlers = bubble.getHandlers(Event_Bubble_Level.mark);
                 stopBubble = this._invoke(handlers, eType, params);
+                if (!stopBubble) {
+                    const handlers = bubble.getHandlers(Event_Bubble_Level.model);
+                    stopBubble = this._invoke(handlers, eType, params);
+                }
+                if (!stopBubble) {
+                    const handlers = bubble.getHandlers(Event_Bubble_Level.chart);
+                    stopBubble = this._invoke(handlers, eType, params);
+                }
+                if (!stopBubble) {
+                    const handlers = bubble.getHandlers(Event_Bubble_Level.vchart);
+                    stopBubble = this._invoke(handlers, eType, params);
+                }
             }
             return this;
         }
@@ -50151,7 +50158,7 @@
             if (filter.nodeName && get(params, 'node.name') !== filter.nodeName) {
                 return false;
             }
-            if (filter.markName && !params?.itemMap.has(filter.markName)) {
+            if (filter.markName && params?.mark?.name !== filter.markName) {
                 return false;
             }
             let modelType = params.model?.type;
@@ -50167,8 +50174,9 @@
             return true;
         }
         _prepareParams(filter, params) {
-            if (filter.markName && params.itemMap) {
-                const item = params.itemMap.get(filter.markName);
+            if (filter.markName && params.mark && params.itemMap) {
+                const markId = params.mark.getProductId();
+                const item = params.itemMap.get(markId);
                 const datum = item?.getDatum();
                 return { ...params, item, datum };
             }
@@ -50628,6 +50636,7 @@
                 return;
             }
             chart.compile();
+            chart.afterCompile();
             this.updateDepend();
         }
         async renderAsync(morphConfig) {
@@ -54101,7 +54110,7 @@
     VChart.useMark([ComponentMark, GroupMark]);
     Factory.registerRegion('region', Region);
     Factory.registerLayout('base', Layout);
-    const version = "1.1.0-beta.2";
+    const version = "1.1.0-beta.3";
 
     var SeriesMarkNameEnum;
     (function (SeriesMarkNameEnum) {
@@ -55278,6 +55287,17 @@
             this.compileSeries();
             this.compileComponents();
         }
+        afterCompile() {
+            this.getAllRegions().forEach(r => {
+                r.afterCompile?.();
+            });
+            this.getAllSeries().forEach(s => {
+                s.afterCompile?.();
+            });
+            this.getAllComponents().forEach(c => {
+                c.afterCompile?.();
+            });
+        }
         compileLayout() {
             const { width, height } = this.getCanvasRect();
             this.getCompiler().setSize(width, height);
@@ -68714,14 +68734,10 @@
         _fillingFontPadding;
         _wordCloudConfig;
         _wordCloudShapeConfig;
-        _paddingLeft;
-        _paddingTop;
+        _padding;
         setAttrFromSpec() {
             super.setAttrFromSpec();
-            this._paddingLeft =
-                this._spec?.chartPadding?.left ?? this._spec.chartPadding ?? 0;
-            this._paddingTop =
-                this._spec?.chartPadding?.top ?? this._spec.chartPadding ?? 0;
+            this._padding = this._option.getChart().padding;
             this._nameField = this._spec.nameField;
             this._fontFamilyField = this._spec.fontFamilyField;
             this._fontWeightField = this._spec.fontWeightField;
@@ -68883,7 +68899,10 @@
                 wordCloudTransforms.push({
                     type: 'wordcloud',
                     layoutType: !isTrueBrowser(this._option.mode) ? 'fast' : this._wordCloudConfig.layoutMode,
-                    size: [srView.width() - this._paddingLeft, srView.height() - this._paddingTop],
+                    size: [
+                        srView.width() - this._padding?.left || 0 - this._padding?.right || 0,
+                        srView.height() - this._padding?.top || 0 - this._padding?.bottom || 0
+                    ],
                     shape: this._maskShape,
                     dataIndexKey: DEFAULT_DATA_KEY,
                     text: { field: textField },
@@ -69040,7 +69059,10 @@
                 wordCloudTransforms.push({
                     type: 'wordcloud',
                     layoutType: this._wordCloudConfig.layoutMode,
-                    size: [srView.width() - this._paddingLeft, srView.height() - this._paddingTop],
+                    size: [
+                        srView.width() - this._padding?.left || 0 - this._padding?.right || 0,
+                        srView.height() - this._padding?.top || 0 - this._padding?.bottom || 0
+                    ],
                     shape: this._maskShape,
                     postProjection: this._spec.postProjection ?? 'StereographicProjection',
                     dataIndexKey: DEFAULT_DATA_KEY,
@@ -69168,8 +69190,8 @@
             if (this._wordMark) {
                 this._wordMark.setAnimationConfig(animationConfig(DEFAULT_MARK_ANIMATION.wordCloud3d(() => {
                     const srView = this.getCompiler().getVGrammarView();
-                    const width = srView.width() - this._paddingLeft;
-                    const height = srView.height() - this._paddingTop;
+                    const width = srView.width() - this._padding?.left || 0 - this._padding?.right || 0;
+                    const height = srView.height() - this._padding?.top || 0 - this._padding?.bottom || 0;
                     const r = Math.max(width, height) / 2;
                     return {
                         center: { x: r, y: r, z: this._spec.depth_3d ?? r },
@@ -69180,8 +69202,8 @@
             if (this._fillingWordMark) {
                 this._fillingWordMark.setAnimationConfig(animationConfig(DEFAULT_MARK_ANIMATION.wordCloud3d(() => {
                     const srView = this.getCompiler().getVGrammarView();
-                    const width = srView.width() - this._paddingLeft;
-                    const height = srView.height() - this._paddingTop;
+                    const width = srView.width() - this._padding?.left || 0 - this._padding?.right || 0;
+                    const height = srView.height() - this._padding?.top || 0 - this._padding?.bottom || 0;
                     const r = Math.max(width, height) / 2;
                     return {
                         center: { x: r, y: r, z: this._spec.depth_3d ?? r },
@@ -70887,7 +70909,7 @@
         _drillInfo;
         _getTriggerEvent(type) {
             const { mode } = this._drillParams;
-            return defaultTriggerEvent[mode][type];
+            return defaultTriggerEvent[mode]?.[type];
         }
         _hideTooltip() {
             const tooltip = this
@@ -70913,22 +70935,24 @@
         bindDrillEvent() {
             const { event, getRawData, drillField } = this._drillParams;
             const keyField = drillField();
-            event.on(this._getTriggerEvent('start'), e => {
-                if (isNil(e.datum) || isNil(e.datum?.[keyField])) {
-                    this.drillUp();
-                    return;
-                }
-                this._hideTooltip();
-                const dataKey = e.datum[keyField];
-                const selectPath = this._drillInfo?.path ?? [];
-                const clickedPath = findHierarchyPath(getRawData().rawData, dataKey, keyField, 'children');
-                if (selectPath[selectPath.length - 1] === clickedPath[clickedPath.length - 1]) {
-                    this.drillUp();
-                }
-                else {
-                    this.drillDown(clickedPath);
-                }
-            });
+            if (this._getTriggerEvent('start')) {
+                event.on(this._getTriggerEvent('start'), e => {
+                    if (isNil(e.datum) || isNil(e.datum?.[keyField])) {
+                        this.drillUp();
+                        return;
+                    }
+                    this._hideTooltip();
+                    const dataKey = e.datum[keyField];
+                    const selectPath = this._drillInfo?.path ?? [];
+                    const clickedPath = findHierarchyPath(getRawData().rawData, dataKey, keyField, 'children');
+                    if (selectPath[selectPath.length - 1] === clickedPath[clickedPath.length - 1]) {
+                        this.drillUp();
+                    }
+                    else {
+                        this.drillDown(clickedPath);
+                    }
+                });
+            }
         }
         drillDown(drillPath = []) {
             const { getRawData, event } = this._drillParams;
@@ -72924,17 +72948,19 @@
         initZoomable(evt, mode = exports.RenderModeEnum['desktop-browser']) {
             this._eventObj = evt;
             this._renderMode = mode;
-            this._clickEnable = true;
-            this._zoomableTrigger = new (this.getTriggerEvent('trigger'))();
+            if (defaultTriggerEvent[this._renderMode]) {
+                this._clickEnable = true;
+                this._zoomableTrigger = new (this._getTriggerEvent('trigger'))();
+            }
         }
-        getTriggerEvent(type) {
+        _getTriggerEvent(type) {
             return defaultTriggerEvent[this._renderMode][type];
         }
         _bindZoomEventAsRegion(eventObj, regionOrSeries, callback) {
-            eventObj.on(this.getTriggerEvent('scrollEnd'), { level: Event_Bubble_Level.chart, consume: false }, params => {
+            eventObj.on(this._getTriggerEvent('scrollEnd'), { level: Event_Bubble_Level.chart, consume: false }, params => {
                 this._zoomableTrigger.clearZoom();
             });
-            eventObj.on(this.getTriggerEvent('scroll'), { level: Event_Bubble_Level.chart, consume: true }, params => {
+            eventObj.on(this._getTriggerEvent('scroll'), { level: Event_Bubble_Level.chart, consume: true }, params => {
                 if (!params.event) {
                     return;
                 }
@@ -72965,44 +72991,52 @@
             });
         }
         initZoomEventOfSeries(s, callback) {
-            this._bindZoomEventAsRegion(s.event, s, callback);
+            if (defaultTriggerEvent[this._renderMode]) {
+                this._bindZoomEventAsRegion(s.event, s, callback);
+            }
         }
         initZoomEventOfRegions(regions, filter, callback) {
-            regions.forEach(r => {
-                if (filter) {
-                    r.getSeries().forEach(s => {
-                        if (filter(s)) {
-                            this._bindZoomEventAsRegion(s.event, s, callback);
-                        }
-                    });
-                }
-                else {
-                    this._bindZoomEventAsRegion(this._eventObj, r, callback);
-                }
-            });
+            if (defaultTriggerEvent[this._renderMode]) {
+                regions.forEach(r => {
+                    if (filter) {
+                        r.getSeries().forEach(s => {
+                            if (filter(s)) {
+                                this._bindZoomEventAsRegion(s.event, s, callback);
+                            }
+                        });
+                    }
+                    else {
+                        this._bindZoomEventAsRegion(this._eventObj, r, callback);
+                    }
+                });
+            }
         }
         initScrollEventOfSeries(s, callback) {
-            this._bindScrollEventAsRegion(s.event, s, callback);
+            if (defaultTriggerEvent[this._renderMode]) {
+                this._bindScrollEventAsRegion(s.event, s, callback);
+            }
         }
         initScrollEventOfRegions(regions, filter, callback) {
-            regions.forEach(r => {
-                if (filter) {
-                    r.getSeries().forEach(s => {
-                        if (filter(s)) {
-                            this._bindScrollEventAsRegion(s.event, s, callback);
-                        }
-                    });
-                }
-                else {
-                    this._bindScrollEventAsRegion(this._eventObj, r, callback);
-                }
-            });
+            if (defaultTriggerEvent[this._renderMode]) {
+                regions.forEach(r => {
+                    if (filter) {
+                        r.getSeries().forEach(s => {
+                            if (filter(s)) {
+                                this._bindScrollEventAsRegion(s.event, s, callback);
+                            }
+                        });
+                    }
+                    else {
+                        this._bindScrollEventAsRegion(this._eventObj, r, callback);
+                    }
+                });
+            }
         }
         _bindScrollEventAsRegion(eventObj, regionOrSeries, callback) {
-            eventObj.on(this.getTriggerEvent('scrollEnd'), { level: Event_Bubble_Level.chart, consume: false }, params => {
+            eventObj.on(this._getTriggerEvent('scrollEnd'), { level: Event_Bubble_Level.chart, consume: false }, params => {
                 this._zoomableTrigger.clearScroll();
             });
-            eventObj.on(this.getTriggerEvent('scroll'), { level: Event_Bubble_Level.chart, consume: true }, params => {
+            eventObj.on(this._getTriggerEvent('scroll'), { level: Event_Bubble_Level.chart, consume: true }, params => {
                 if (!params.event) {
                     return;
                 }
@@ -73033,7 +73067,7 @@
             });
         }
         _bindDragEventAsRegion(eventObj, regionOrSeries, callback) {
-            eventObj.on(this.getTriggerEvent('start'), { level: Event_Bubble_Level.chart }, params => {
+            eventObj.on(this._getTriggerEvent('start'), { level: Event_Bubble_Level.chart }, params => {
                 if (!params.event) {
                     return;
                 }
@@ -73054,36 +73088,40 @@
             });
         }
         initDragEventOfSeries(s, callback) {
-            s.event.on(this.getTriggerEvent('start'), { level: Event_Bubble_Level.model, filter: ({ model }) => model?.id === s.id }, params => {
-                this._handleDrag(params, callback);
-            });
+            if (defaultTriggerEvent[this._renderMode]) {
+                s.event.on(this._getTriggerEvent('start'), { level: Event_Bubble_Level.model, filter: ({ model }) => model?.id === s.id }, params => {
+                    this._handleDrag(params, callback);
+                });
+            }
         }
         initDragEventOfRegions(regions, filter, callback) {
-            regions.forEach(r => {
-                if (filter) {
-                    r.getSeries().forEach(s => {
-                        if (filter(s)) {
-                            s.event.on(this.getTriggerEvent('start'), { level: Event_Bubble_Level.model, filter: ({ model }) => model?.id === s.id }, params => {
-                                this._handleDrag(params, callback);
-                            });
-                            s.event.on('click', { level: Event_Bubble_Level.model, filter: ({ model }) => model?.id === s.id }, () => {
-                                return !this._clickEnable;
-                            });
-                        }
-                    });
-                }
-                else {
-                    this._bindDragEventAsRegion(this._eventObj, r, callback);
-                }
-            });
+            if (defaultTriggerEvent[this._renderMode]) {
+                regions.forEach(r => {
+                    if (filter) {
+                        r.getSeries().forEach(s => {
+                            if (filter(s)) {
+                                s.event.on(this._getTriggerEvent('start'), { level: Event_Bubble_Level.model, filter: ({ model }) => model?.id === s.id }, params => {
+                                    this._handleDrag(params, callback);
+                                });
+                                s.event.on('click', { level: Event_Bubble_Level.model, filter: ({ model }) => model?.id === s.id }, () => {
+                                    return !this._clickEnable;
+                                });
+                            }
+                        });
+                    }
+                    else {
+                        this._bindDragEventAsRegion(this._eventObj, r, callback);
+                    }
+                });
+            }
         }
         _handleDrag(params, callback) {
             this._clickEnable = true;
             if (!this._zoomableTrigger.parserDragEvent(params.event)) {
                 return;
             }
-            const move = this.getTriggerEvent('move');
-            const end = this.getTriggerEvent('end');
+            const move = this._getTriggerEvent('move');
+            const end = this._getTriggerEvent('end');
             const event = params.event;
             let x = event.canvasX;
             let y = event.canvasY;
@@ -75395,8 +75433,7 @@
                 wordCloudConfig: spec.wordCloudConfig,
                 wordCloudShapeConfig: spec.wordCloudShapeConfig,
                 word: spec.word,
-                fillingWord: spec.fillingWord,
-                chartPadding: spec.padding
+                fillingWord: spec.fillingWord
             };
             const seriesType = this.seriesType;
             if (seriesType) {
@@ -75435,8 +75472,7 @@
                 wordCloudConfig: spec.wordCloudConfig,
                 wordCloudShapeConfig: spec.wordCloudShapeConfig,
                 word: spec.word,
-                fillingWord: spec.fillingWord,
-                chartPadding: spec.padding
+                fillingWord: spec.fillingWord
             };
             const seriesType = this.seriesType;
             if (seriesType) {
@@ -75630,6 +75666,8 @@
         }
         clear() {
             this._container = null;
+            this.pluginService?.disposeAll();
+            this.pluginService = null;
         }
         compile() {
             this.compileSignal();
@@ -75654,7 +75692,7 @@
                 datum: null,
                 source: Event_Source_Type.chart,
                 chart: this._option?.globalInstance?.getChart()
-            });
+            }, 'model');
         };
     }
 
@@ -77498,16 +77536,216 @@
         }
     }
 
-    var pluginMap = {
-        AxisLabelOverlapPlugin
-    };
-
-    const scaleParser = (scale) => {
-        return scale;
+    function isValidAlignDomain(domain) {
+        return domain.length === 2 && isValidNumber(domain[0]) && isValidNumber(domain[1]) && domain[1] >= domain[0];
+    }
+    function getScaleInfo(axis, 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;
+        }
+        const domainSpec = axis.getDomainSpec();
+        return {
+            total,
+            negative,
+            positive,
+            includeZero,
+            domain,
+            extendable_min: !isValidNumber(domainSpec.min),
+            extendable_max: !isValidNumber(domainSpec.max)
+        };
+    }
+    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;
+    }
+    const zeroAlign = (targetAxis, currentAxis) => {
+        const s1 = targetAxis.getScale();
+        const s2 = currentAxis.getScale();
+        if (!s1 || !s2) {
+            return;
+        }
+        if (!isContinuous(s1.type) || !isContinuous(s2.type)) {
+            return;
+        }
+        const domain1 = [...s1.domain()];
+        const domain2 = [...s2.domain()];
+        if (!isValidAlignDomain(domain1) || !isValidAlignDomain(domain2)) {
+            return;
+        }
+        const info1 = getScaleInfo(targetAxis, domain1);
+        const info2 = getScaleInfo(currentAxis, 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;
+            }
+        }
+        else if (positive2 === 0 && negative2 === 0) {
+            if (!inOnlyZeroDomain(info2, info1)) {
+                return;
+            }
+        }
+        else if (!includeZero1 && !includeZero2) {
+            if (negative1 === 0 && positive2 === 0) {
+                if (!inNoCrossDifferentSide(info1, info2)) {
+                    return;
+                }
+            }
+            else if (negative2 === 0 && positive1 === 0) {
+                if (!inNoCrossDifferentSide(info2, info1)) {
+                    return;
+                }
+            }
+            if (negative1 === 0 && negative2 === 0) {
+                if (domain1[0] === 0 && domain2[0] > 0) {
+                    if (!s2Extendable_min) {
+                        return;
+                    }
+                    domain2[0] = 0;
+                }
+                else if (domain2[0] === 0 && domain1[0] > 0) {
+                    if (!s1Extendable_min) {
+                        return;
+                    }
+                    domain1[0] = 0;
+                }
+                else {
+                    return;
+                }
+            }
+            if (positive1 === 0 && positive2 === 0) {
+                if (domain1[1] === 0 && domain2[1] > 0) {
+                    if (!s2Extendable_max) {
+                        return;
+                    }
+                    domain2[1] = 0;
+                }
+                else if (domain2[1] === 0 && domain1[1] > 0) {
+                    if (!s1Extendable_max) {
+                        return;
+                    }
+                    domain1[1] = 0;
+                }
+                else {
+                    return;
+                }
+            }
+        }
+        else if (includeZero1 && !includeZero2) {
+            if (!inDifferentCrossZero(info1, info2)) {
+                return;
+            }
+        }
+        else if (includeZero2 && !includeZero1) {
+            if (!inDifferentCrossZero(info2, info1)) {
+                return;
+            }
+        }
+        else {
+            if (negative1 === negative2) {
+                return;
+            }
+            else if (negative1 > negative2) {
+                if (!inAllCrossZero(info1, info2)) {
+                    return;
+                }
+            }
+            else {
+                if (!inAllCrossZero(info2, info1)) {
+                    return;
+                }
+            }
+        }
+        s1.domain(domain1);
+        s2.domain(domain2);
     };
 
-    const DEFAULT_CONTINUOUS_TICK_COUNT = 5;
-
     const convertDomainToTickData = (domain, op) => {
         const ticks = domain.map((t, index) => {
             return {
@@ -77639,6 +77877,124 @@
         return labelBoundsList;
     };
 
+    const tickAlign = (data, op) => {
+        if (!data) {
+            return data;
+        }
+        const targetAxis = op?.targetAxis?.();
+        if (!targetAxis) {
+            return data;
+        }
+        const currentAxis = op?.currentAxis?.();
+        if (!currentAxis) {
+            return data;
+        }
+        const currentData = currentAxis.getTickData()?.getDataView();
+        if (!currentData) {
+            return data;
+        }
+        const currentTickTransform = currentData.transformsArr.find(t => t.type === 'ticks');
+        if (!currentTickTransform) {
+            return data;
+        }
+        const currentScale = currentAxis.getScale();
+        if (!currentScale) {
+            return data;
+        }
+        const targetData = targetAxis.getTickData()?.getDataView()?.latestData;
+        if (!targetData?.length) {
+            return data;
+        }
+        const targetScale = targetAxis.getScale();
+        if (!targetScale) {
+            return data;
+        }
+        const targetDomain = targetScale.domain();
+        const targetRange = targetDomain[1] - targetDomain[0];
+        if (targetRange === 0) {
+            return data;
+        }
+        const currentDomain = currentScale.domain();
+        const currentRange = currentDomain[1] - currentDomain[0];
+        if (targetRange === 0) {
+            return data;
+        }
+        const newTicks = targetData.map((d) => {
+            const percent = (d.value - targetDomain[0]) / targetRange;
+            return currentRange * percent + currentDomain[0];
+        });
+        return convertDomainToTickData(newTicks, currentTickTransform.options);
+    };
+
+    class AxisSyncPlugin extends BasicComponentPlugin {
+        Name = 'AxisSyncPlugin';
+        constructor() {
+            super(AxisSyncPlugin.Name);
+        }
+        _checkEnableSync(axis) {
+            if (!isContinuous(axis.getScale().type)) {
+                return false;
+            }
+            const sync = axis.getSpec().sync;
+            if (!sync?.axisId) {
+                return false;
+            }
+            return sync;
+        }
+        _getTargetAxis(axis, sync) {
+            const targetAxis = axis.getOption().getChart().getComponentByUserId(sync.axisId);
+            if (!targetAxis?.type.startsWith('cartesianAxis')) {
+                return null;
+            }
+            return targetAxis;
+        }
+        onInit(service, axis) {
+            const sync = this._checkEnableSync(axis);
+            if (!sync) {
+                return;
+            }
+            if (!sync.zeroAlign) {
+                return;
+            }
+            const targetAxis = this._getTargetAxis(axis, sync);
+            if (!targetAxis) {
+                return;
+            }
+            axis.event.on(ChartEvent.scaleDomainUpdate, { filter: ({ model }) => model.id === axis.id }, () => {
+                zeroAlign(targetAxis, axis);
+            });
+        }
+        onDidCompile(service, axis) {
+            const sync = this._checkEnableSync(axis);
+            if (!sync) {
+                return;
+            }
+            const targetAxis = this._getTargetAxis(axis, sync);
+            if (!targetAxis) {
+                return;
+            }
+            if (sync.tickAlign) {
+                registerDataSetInstanceTransform(axis.getOption().dataSet, 'tickAlign', tickAlign);
+                const opt = {
+                    targetAxis: () => targetAxis,
+                    currentAxis: () => axis
+                };
+                axis.addTransformToTickData({ type: 'tickAlign', options: opt, level: Number.MAX_SAFE_INTEGER }, false);
+            }
+        }
+    }
+
+    var pluginMap = {
+        AxisLabelOverlapPlugin,
+        AxisSyncPlugin
+    };
+
+    const scaleParser = (scale) => {
+        return scale;
+    };
+
+    const DEFAULT_CONTINUOUS_TICK_COUNT = 5;
+
     const continuousTicks = (scale, op) => {
         if (!isContinuous(scale.type)) {
             return convertDomainToTickData(scale.domain(), op);
@@ -77890,6 +78246,9 @@
             return this._scales;
         }
         _tickData;
+        getTickData() {
+            return this._tickData;
+        }
         _statisticsDomain = { domain: [], index: {} };
         getStatisticsDomain() {
             return this._statisticsDomain;
@@ -78027,6 +78386,7 @@
                 this._scales[i].domain(domain);
             }
             this.transformScaleDomain();
+            this.event.emit(ChartEvent.scaleDomainUpdate, { model: this });
             this.event.emit(ChartEvent.scaleUpdate, { model: this });
         }
         computeData() {
@@ -78193,9 +78553,12 @@
                 }
             };
         }
+        addTransformToTickData(options, execute) {
+            this._tickData?.getDataView()?.transform(options, execute);
+        }
     }
 
-    const CartesianAxisPlugin = [pluginMap.AxisLabelOverlapPlugin];
+    const CartesianAxisPlugin = [pluginMap.AxisLabelOverlapPlugin, pluginMap.AxisSyncPlugin];
     class CartesianAxis extends AxisComponent {
         static type = ComponentTypeEnum.cartesianAxis;
         type = ComponentTypeEnum.cartesianAxis;
@@ -78350,6 +78713,9 @@
         init(option) {
             super.init(option);
             this.pluginService?.load(CartesianAxisPlugin.map(P => new P()));
+            this.callPlugin(plugin => {
+                this.pluginService && plugin.onInit && plugin.onInit(this.pluginService, this);
+            });
         }
         setAttrFromSpec() {
             super.setAttrFromSpec();
@@ -78414,7 +78780,7 @@
                 getAxisId: () => this.id
             };
         }
-        onLayoutStart(ctx) {
+        afterCompile() {
             const product = this.getMarks()[0]?.getProduct();
             if (product) {
                 product.addEventListener(HOOK_EVENT.AFTER_ELEMENT_ENCODE, () => {
@@ -78435,6 +78801,9 @@
                     }
                 });
             }
+            this.callPlugin(plugin => {
+                this.pluginService && plugin.onDidCompile && plugin.onDidCompile(this.pluginService, this);
+            });
         }
         onLayoutEnd(ctx) {
             const isRangeChange = this.updateScaleRange();
@@ -78899,6 +79268,9 @@
                 temp < domain[min] && (domain[min] = temp);
             }
         }
+        getDomainSpec() {
+            return this._domain;
+        }
         setDomainMinMax(domain) {
             if (!this._domain) {
                 return;
@@ -78930,6 +79302,7 @@
             this.niceDomain(domain);
             this._scale.domain(domain, this._nice);
             this.niceMinMax();
+            this.event.emit(ChartEvent.scaleDomainUpdate, { model: this });
             this.event.emit(ChartEvent.scaleUpdate, { model: this });
         }
     }
@@ -81090,12 +81463,14 @@
             return result;
         }
         _initEvent() {
-            const { in: triggerEvent, out: outTriggerEvent } = this._getTriggerEvent();
-            if (isArray(triggerEvent)) {
-                triggerEvent.forEach((eventName, index) => this._registerEvent(eventName, isArray(outTriggerEvent) ? outTriggerEvent[index] : outTriggerEvent));
-            }
-            else {
-                this._registerEvent(triggerEvent, outTriggerEvent);
+            if (this._getTriggerEvent()) {
+                const { in: triggerEvent, out: outTriggerEvent } = this._getTriggerEvent();
+                if (isArray(triggerEvent)) {
+                    triggerEvent.forEach((eventName, index) => this._registerEvent(eventName, isArray(outTriggerEvent) ? outTriggerEvent[index] : outTriggerEvent));
+                }
+                else {
+                    this._registerEvent(triggerEvent, outTriggerEvent);
+                }
             }
         }
         _registerEvent(inEventName, outEventName) {
@@ -81123,24 +81498,27 @@
         }, 10);
         _getTriggerEvent() {
             const { mode = exports.RenderModeEnum['desktop-browser'] } = this._option;
-            const trigger = this.trigger || 'hover';
-            const outTrigger = (trigger) => (trigger === 'click' ? 'clickOut' : 'hoverOut');
-            if (isArray(trigger)) {
-                let inResult = [];
-                let outResult = [];
-                trigger.forEach(item => {
-                    inResult = inResult.concat(defaultCrosshairTriggerEvent[mode][item]);
-                    outResult = outResult.concat(defaultCrosshairTriggerEvent[mode][outTrigger(item)]);
-                });
+            if (defaultCrosshairTriggerEvent[mode]) {
+                const trigger = this.trigger || 'hover';
+                const outTrigger = (trigger) => (trigger === 'click' ? 'clickOut' : 'hoverOut');
+                if (isArray(trigger)) {
+                    let inResult = [];
+                    let outResult = [];
+                    trigger.forEach(item => {
+                        inResult = inResult.concat(defaultCrosshairTriggerEvent[mode][item]);
+                        outResult = outResult.concat(defaultCrosshairTriggerEvent[mode][outTrigger(item)]);
+                    });
+                    return {
+                        in: inResult,
+                        out: outResult
+                    };
+                }
                 return {
-                    in: inResult,
-                    out: outResult
+                    in: defaultCrosshairTriggerEvent[mode][trigger],
+                    out: defaultCrosshairTriggerEvent[mode][outTrigger(trigger)]
                 };
             }
-            return {
-                in: defaultCrosshairTriggerEvent[mode][trigger],
-                out: defaultCrosshairTriggerEvent[mode][outTrigger(trigger)]
-            };
+            return null;
         }
         _getAxisInfoByField(field) {
             const axesComponents = this._option.getComponentsByKey('axes');
@@ -81192,18 +81570,20 @@
         onRender(ctx) {
         }
         _releaseEvent() {
-            const { in: triggerEvent, out: outTriggerEvent } = this._getTriggerEvent();
-            if (isArray(triggerEvent)) {
-                triggerEvent.forEach(eachTriggerEvent => this._eventOff(eachTriggerEvent));
-            }
-            else {
-                this._eventOff(triggerEvent);
-            }
-            if (isArray(outTriggerEvent)) {
-                outTriggerEvent.forEach(eachTriggerEvent => this._eventOff(eachTriggerEvent));
-            }
-            else {
-                this._eventOff(outTriggerEvent);
+            if (this._getTriggerEvent()) {
+                const { in: triggerEvent, out: outTriggerEvent } = this._getTriggerEvent();
+                if (isArray(triggerEvent)) {
+                    triggerEvent.forEach(eachTriggerEvent => this._eventOff(eachTriggerEvent));
+                }
+                else {
+                    this._eventOff(triggerEvent);
+                }
+                if (isArray(outTriggerEvent)) {
+                    outTriggerEvent.forEach(eachTriggerEvent => this._eventOff(eachTriggerEvent));
+                }
+                else {
+                    this._eventOff(outTriggerEvent);
+                }
             }
         }
         _firstSeries() {
@@ -82857,6 +83237,7 @@
             if (markerVisible) {
                 if (!this._markerComponent) {
                     this._createMarkerComponent();
+                    this._markerComponent.on('*', (event, type) => this._delegateEvent(this._markerComponent, event, type));
                 }
                 this._bindSeries();
                 this._initDataView();