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

package/build/index.js

@@ -7392,6 +7392,7 @@
     };
 
     const isBrowser = typeof window !== 'undefined' && typeof window.document !== 'undefined';
+    const domDocument = isBrowser && globalThis.document;
     function isTrueBrowser(mode) {
         return (mode === 'desktop-browser' || mode === 'mobile-browser') && isBrowser;
     }
@@ -15570,7 +15571,7 @@
         return referenceNode.parent !== this ? null : (newNode.parent && newNode.parent.removeChild(newNode), newNode.parent = this, referenceNode._next ? (referenceNode._next._prev = newNode, newNode._next = referenceNode._next) : this._lastChild = newNode, referenceNode._next = newNode, newNode._prev = referenceNode, this._idMap || (this._idMap = new Map()), this._idMap.set(newNode._uid, newNode), this._structEdit = !0, this.setCount(newNode.count), newNode);
       }
       insertInto(newNode, idx) {
-        if (this._nodeList && console.warn("insertIntoKeepIdx和insertInto混用可能会存在错误"), idx >= this.childrenCount) return this.appendChild(newNode);
+        if (!this._ignoreWarn && this._nodeList && console.warn("insertIntoKeepIdx和insertInto混用可能会存在错误"), idx >= this.childrenCount) return this.appendChild(newNode);
         if (this._uid === newNode._uid) return null;
         if (newNode.isAncestorsOf(this)) throw new Error("【Node::insertBefore】不能将父辈元素insert为子元素");
         if (newNode.parent && newNode.parent.removeChild(newNode), newNode.parent = this, 0 === idx) newNode._next = this._firstChild, this._firstChild && (this._firstChild._prev = newNode), newNode._prev = null, this._firstChild = newNode;else {
@@ -15592,7 +15593,10 @@
         let node;
         this._nodeList[idx] = newNode;
         for (let i = idx - 1; i >= 0 && (node = this._nodeList[i], !node); i--);
-        return node ? node._next ? this.insertBefore(newNode, node._next) : this.appendChild(newNode) : this.insertInto(newNode, 0);
+        if (node) return node._next ? this.insertBefore(newNode, node._next) : this.appendChild(newNode);
+        this._ignoreWarn = !0;
+        const data = this.insertInto(newNode, 0);
+        return this._ignoreWarn = !1, data;
       }
       removeChild(child) {
         if (!this._idMap) return null;
@@ -23609,6 +23613,7 @@
     function getTextBounds(params) {
       return text.setAttributes(params), text.AABBBounds;
     }
+    createRichText({});
 
     class DefaultCanvasAllocate {
       constructor() {
@@ -23995,7 +24000,7 @@
             isFullStroke: isFullStroke,
             stroke: arrayStroke
           } = parseStroke(stroke);
-        if ((doFill || isFullStroke) && (context.beginPath(), drawArcPath$1(arc, context, x, y, outerRadius, innerRadius), this._arcRenderContribitions || (this._arcRenderContribitions = this.arcRenderContribitions.getContributions() || [], this._arcRenderContribitions.sort((a, b) => b.order - a.order)), this._arcRenderContribitions.forEach(c => {
+        if ((doFill || isFullStroke || background) && (context.beginPath(), drawArcPath$1(arc, context, x, y, outerRadius, innerRadius), this._arcRenderContribitions || (this._arcRenderContribitions = this.arcRenderContribitions.getContributions() || [], this._arcRenderContribitions.sort((a, b) => b.order - a.order)), this._arcRenderContribitions.forEach(c => {
           c.time === BaseRenderContributionTime.beforeFillStroke && c.drawShape(arc, context, x, y, doFill, doStroke, fVisible, sVisible, arcAttribute, fillCb, strokeCb);
         }), context.setShadowStyle && context.setShadowStyle(arc, arc.attribute, arcAttribute), doFill && (fillCb ? fillCb(context, arc.attribute, arcAttribute) : fVisible && (context.setCommonStyle(arc, arc.attribute, originX - x, originY - y, arcAttribute), context.fill())), doStroke && isFullStroke && (strokeCb ? strokeCb(context, arc.attribute, arcAttribute) : sVisible && (context.setStrokeStyle(arc, arc.attribute, originX - x, originY - y, arcAttribute), context.stroke()))), !isFullStroke && doStroke) {
           context.beginPath();
@@ -28590,6 +28595,25 @@
           _context.setLineDash(lineDash);
         }
       }
+      _setStrokeStyle(params, attribute, offsetX, offsetY, defaultParams) {
+        const _context = this.nativeContext;
+        defaultParams || (defaultParams = this.strokeAttributes);
+        const {
+          strokeOpacity = defaultParams.strokeOpacity,
+          opacity = defaultParams.opacity
+        } = attribute;
+        if (strokeOpacity > 1e-12 && opacity > 1e-12) {
+          const {
+            lineWidth = defaultParams.lineWidth,
+            stroke = defaultParams.stroke,
+            lineJoin = defaultParams.lineJoin,
+            lineDash = defaultParams.lineDash,
+            lineCap = defaultParams.lineCap,
+            miterLimit = defaultParams.miterLimit
+          } = attribute;
+          _context.globalAlpha = strokeOpacity * opacity, _context.lineWidth = getScaledStroke(this, lineWidth, this.dpr), _context.strokeStyle = createColor(this, stroke, params, offsetX, offsetY), _context.lineJoin = lineJoin, 0 === lineDash[0] && 0 === lineDash[1] || _context.setLineDash(lineDash), _context.lineCap = lineCap, _context.miterLimit = miterLimit;
+        }
+      }
       draw() {
         const _context = this.nativeContext;
         this.drawPromise = new Promise(resolve => {
@@ -33752,7 +33776,7 @@
       encodeGraphic() {
         this.coordinateTransformEncode(this.items);
         const graphicAttributes = this.transformElementItems(this.items, this.mark.markType);
-        this.graphicItem ? this.applyGraphicAttributes(graphicAttributes) : this.initGraphicItem(graphicAttributes), this.diffState !== DiffState.enter && this.diffState !== DiffState.update || !this.states.length || (this.graphicItem.clearStates(), this.graphicItem.states = {}, this.useStates(this.states)), this.mark.markType === GrammarMarkType.shape && (this.graphicItem.datum = this.items[0].datum), this.items.forEach(item => {
+        this.graphicItem ? (this.graphicItem.clearStates(), this.graphicItem.states = {}, this.graphicItem.stateProxy = null, this.applyGraphicAttributes(graphicAttributes)) : this.initGraphicItem(graphicAttributes), this.diffState !== DiffState.enter && this.diffState !== DiffState.update || !this.states.length || this.useStates(this.states), this.mark.markType === GrammarMarkType.shape && (this.graphicItem.datum = this.items[0].datum), this.items.forEach(item => {
           item.nextAttrs = {};
         }), this._setCutomizedShape();
       }
@@ -33823,7 +33847,7 @@
         const item = items[0];
         if (!item.nextAttrs || 0 === Object.keys(item.nextAttrs).length) return {};
         let nextAttrs = null == item ? void 0 : item.nextAttrs;
-        if (items && items.length && isNil(null === (_a = item.nextAttrs) || void 0 === _a ? void 0 : _a.points) && !1 !== computePoints && isPointsMarkType(markType)) {
+        if (items && items.length && isNil(null === (_a = item.nextAttrs) || void 0 === _a ? void 0 : _a.points) && (!0 === computePoints || isValidPointsChannel(Object.keys(item.nextAttrs), this.mark.markType)) && isPointsMarkType(markType)) {
           const lastPoints = this.getGraphicAttribute("points", !1),
             lastSegments = this.getGraphicAttribute("segments", !1),
             enableSegments = null !== (_b = item.nextAttrs.enableSegments) && void 0 !== _b ? _b : this.getGraphicAttribute("enableSegments", !1),
@@ -36730,7 +36754,7 @@
       constructor(view, markType, group) {
         super(view), this.grammarType = "mark", this.elements = [], this.elementMap = new Map(), this.isUpdated = !0, this.animate = new Animate(this, {}), this.differ = new Differ([]), this.evaluateSync = (data, parameters) => {
           var _a;
-          return this.evaluateMainTasks(data, parameters), (null === (_a = this.renderContext) || void 0 === _a ? void 0 : _a.progressive) || this.evaluateTransformSync(this.transforms, this.elements, parameters), this;
+          return this.evaluateMainTasks(data, parameters), (null === (_a = this.renderContext) || void 0 === _a ? void 0 : _a.progressive) || this.evaluateTransformSync(this._getTransformsAfterEncode(), this.elements, parameters), this;
         }, this.markType = markType, this.spec.type = markType, this.spec.encode = {
           update: {}
         }, this.spec.group = group, group && (this.group = group, this.attach(group), group.appendChild(this));
@@ -36791,7 +36815,7 @@
       evaluate(data, parameters) {
         var _a;
         return __awaiter$7(this, void 0, void 0, function* () {
-          return this.evaluateMainTasks(data, parameters), (null === (_a = this.renderContext) || void 0 === _a ? void 0 : _a.progressive) || (yield this.evaluateTransform(this.transforms, this.elements, parameters)), this;
+          return this.evaluateMainTasks(data, parameters), (null === (_a = this.renderContext) || void 0 === _a ? void 0 : _a.progressive) || (yield this.evaluateTransform(this._getTransformsAfterEncode(), this.elements, parameters)), this;
         });
       }
       output() {
@@ -37509,143 +37533,25 @@
       return "#" + rgbToHex(r, g, b);
     }
 
-    /**
-     * Common utilities
-     * @module glMatrix
-     */
-    var ARRAY_TYPE = typeof Float32Array !== 'undefined' ? Float32Array : Array;
-    if (!Math.hypot) Math.hypot = function () {
-      var y = 0,
-        i = arguments.length;
-      while (i--) {
-        y += arguments[i] * arguments[i];
-      }
-      return Math.sqrt(y);
-    };
-
-    /**
-     * 2 Dimensional Vector
-     * @module vec2
-     */
-
-    /**
-     * Creates a new, empty vec2
-     *
-     * @returns {vec2} a new 2D vector
-     */
-
-    function create$2() {
-      var out = new ARRAY_TYPE(2);
-      if (ARRAY_TYPE != Float32Array) {
-        out[0] = 0;
-        out[1] = 0;
-      }
-      return out;
-    }
-    /**
-     * Scales a vec2 by a scalar number
-     *
-     * @param {vec2} out the receiving vector
-     * @param {ReadonlyVec2} a the vector to scale
-     * @param {Number} b amount to scale the vector by
-     * @returns {vec2} out
-     */
-
-    function scale(out, a, b) {
-      out[0] = a[0] * b;
-      out[1] = a[1] * b;
-      return out;
+    function scale(vector, scale) {
+      return [vector[0] * scale, vector[1] * scale];
     }
-    /**
-     * Calculates the length of a vec2
-     *
-     * @param {ReadonlyVec2} a vector to calculate length of
-     * @returns {Number} length of a
-     */
-
-    function length(a) {
-      var x = a[0],
-        y = a[1];
-      return Math.hypot(x, y);
+    function length(vector) {
+      const [x, y] = vector;
+      return Math.sqrt(x * x + y * y);
     }
-    /**
-     * Normalize a vec2
-     *
-     * @param {vec2} out the receiving vector
-     * @param {ReadonlyVec2} a vector to normalize
-     * @returns {vec2} out
-     */
-
-    function normalize(out, a) {
-      var x = a[0],
-        y = a[1];
-      var len = x * x + y * y;
-      if (len > 0) {
-        //TODO: evaluate use of glm_invsqrt here?
-        len = 1 / Math.sqrt(len);
-      }
-      out[0] = a[0] * len;
-      out[1] = a[1] * len;
-      return out;
+    function normalize(vector) {
+      const [x, y] = vector;
+      let len = x * x + y * y;
+      return len > 0 && (len = 1 / Math.sqrt(len)), [vector[0] * len, vector[1] * len];
     }
-    /**
-     * Get the angle between two 2D vectors
-     * @param {ReadonlyVec2} a The first operand
-     * @param {ReadonlyVec2} b The second operand
-     * @returns {Number} The angle in radians
-     */
-
-    function angle(a, b) {
-      var x1 = a[0],
-        y1 = a[1],
-        x2 = b[0],
-        y2 = b[1],
-        // mag is the product of the magnitudes of a and b
-        mag = Math.sqrt(x1 * x1 + y1 * y1) * Math.sqrt(x2 * x2 + y2 * y2),
-        // mag &&.. short circuits if mag == 0
-        cosine = mag && (x1 * x2 + y1 * y2) / mag; // Math.min(Math.max(cosine, -1), 1) clamps the cosine between -1 and 1
-
+    function angle(vector1, vector2) {
+      const [x1, y1] = vector1,
+        [x2, y2] = vector2,
+        mag = Math.sqrt((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2)),
+        cosine = mag && (x1 * x2 + y1 * y2) / mag;
       return Math.acos(Math.min(Math.max(cosine, -1), 1));
     }
-    /**
-     * Perform some operation over an array of vec2s.
-     *
-     * @param {Array} a the array of vectors to iterate over
-     * @param {Number} stride Number of elements between the start of each vec2. If 0 assumes tightly packed
-     * @param {Number} offset Number of elements to skip at the beginning of the array
-     * @param {Number} count Number of vec2s to iterate over. If 0 iterates over entire array
-     * @param {Function} fn Function to call for each vector in the array
-     * @param {Object} [arg] additional argument to pass to fn
-     * @returns {Array} a
-     * @function
-     */
-
-    (function () {
-      var vec = create$2();
-      return function (a, stride, offset, count, fn, arg) {
-        var i, l;
-        if (!stride) {
-          stride = 2;
-        }
-        if (!offset) {
-          offset = 0;
-        }
-        if (count) {
-          l = Math.min(count * stride + offset, a.length);
-        } else {
-          l = a.length;
-        }
-        for (i = offset; i < l; i += stride) {
-          vec[0] = a[i];
-          vec[1] = a[i + 1];
-          fn(vec, vec, arg);
-          a[i] = vec[0];
-          a[i + 1] = vec[1];
-        }
-        return a;
-      };
-    })();
-
     function direction(v1, v2) {
       return v1[0] * v2[1] - v2[0] * v1[1];
     }
@@ -39190,11 +39096,10 @@
         axisTitle.name = AXIS_ELEMENT_NAME.title, axisTitle.id = this._getNodeId("title"), container.add(axisTitle);
       }
       renderGrid(container) {
-        this._renderGridByType("grid", container);
         const {
           visible: visible
         } = this.attribute.subGrid || {};
-        visible && this._renderGridByType("subGrid", container);
+        visible && this._renderGridByType("subGrid", container), this._renderGridByType("grid", container);
       }
       getVerticalCoord(point, offset, inside) {
         const vector = this.getVerticalVector(offset, inside, point);
@@ -39429,9 +39334,9 @@
             verticalFactor = 1
           } = this.attribute,
           axisVector = this.getRelativeVector(),
-          normalize$1 = normalize([0, 0], axisVector),
-          verticalVector = [normalize$1[1], -1 * normalize$1[0]];
-        return scale([0, 0], verticalVector, offset * (inside ? 1 : -1) * verticalFactor);
+          normalizedAxisVector = normalize(axisVector),
+          verticalVector = [normalizedAxisVector[1], -1 * normalizedAxisVector[0]];
+        return scale(verticalVector, offset * (inside ? 1 : -1) * verticalFactor);
       }
       getTitleAttribute() {
         var _a, _b, _c, _d, _e, _f, _g, _h;
@@ -39673,7 +39578,7 @@
             center: center
           } = this.attribute,
           vector = [point.x - center.x, point.y - center.y];
-        return scale(vector, vector, (inside ? -1 : 1) * (axisInside ? -1 : 1) * offset / length(vector)), vector;
+        return scale(vector, (inside ? -1 : 1) * (axisInside ? -1 : 1) * offset / length(vector));
       }
       getRelativeVector(point) {
         const {
@@ -41143,7 +41048,8 @@
         } = handler;
         preShape || (preShape = isHorizontal ? "triangleLeft" : "triangleUp"), nextShape || (nextShape = isHorizontal ? "triangleRight" : "triangleDown");
         const preHandler = createSymbol(Object.assign(Object.assign({
-          strokeBoundsBuffer: 0
+          strokeBoundsBuffer: 0,
+          pickMode: "imprecise"
         }, handlerStyle), {
           x: 0,
           y: 0,
@@ -41170,7 +41076,8 @@
           }, textStyle));
         this.text = text, container.add(text);
         const nextHandler = createSymbol(Object.assign(Object.assign({
-          strokeBoundsBuffer: 0
+          strokeBoundsBuffer: 0,
+          pickMode: "imprecise"
         }, handlerStyle), {
           x: isHorizontal ? handlerSizeX + 2 * handlerSpace + maxTextWidth : 0,
           y: isHorizontal ? 0 : handlerSizeY + 2 * handlerSpace + maxTextHeight,
@@ -41400,14 +41307,16 @@
           const itemGroup = this._renderEachItem(item, !!isEmpty(defaultSelected) || (null == defaultSelected ? void 0 : defaultSelected.includes(item.label)), index),
             itemWidth = itemGroup.attribute.width,
             itemHeight = itemGroup.attribute.height;
-          this._itemHeight = Math.max(this._itemHeight, itemHeight), maxWidthInCol = Math.max(itemWidth, maxWidthInCol), this._itemMaxWidth = Math.max(itemWidth, this._itemMaxWidth), isHorizontal ? (maxPages = maxRow, isValid(maxWidth) && maxWidth < startX + itemWidth && (doWrap = !0, startX = 0, startY += itemHeight + spaceRow, pages += 1), index > 0 && itemGroup.setAttributes({
+          this._itemHeight = Math.max(this._itemHeight, itemHeight), maxWidthInCol = Math.max(itemWidth, maxWidthInCol), this._itemMaxWidth = Math.max(itemWidth, this._itemMaxWidth), isHorizontal ? (maxPages = maxRow, isValid(maxWidth) && (itemWidth >= maxWidth ? (doWrap = !0, index > 0 && (startX = 0, startY += itemHeight + spaceRow, pages += 1)) : maxWidth < startX + itemWidth && (doWrap = !0, startX = 0, startY += itemHeight + spaceRow, pages += 1)), index > 0 && itemGroup.setAttributes({
             x: startX,
             y: startY
           }), startX += spaceCol + itemWidth) : (maxPages = maxCol, isValid(maxHeight) && maxHeight < startY + itemHeight && (doWrap = !0, startY = 0, startX += maxWidthInCol + spaceCol, maxWidthInCol = 0, pages += 1), index > 0 && itemGroup.setAttributes({
             x: startX,
             y: startY
           }), startY += spaceRow + itemHeight), itemsContainer.add(itemGroup);
-        }), doWrap && autoPage && pages > maxPages ? this._renderPager(isHorizontal) : (itemsContainer.setAttribute("y", this._title ? this._title.AABBBounds.height() + get(this.attribute, "title.space", 8) : 0), this._innerView.add(itemsContainer));
+        });
+        let pagerRendered = !1;
+        doWrap && autoPage && pages > maxPages && (pagerRendered = this._renderPager(isHorizontal)), pagerRendered || (itemsContainer.setAttribute("y", this._title ? this._title.AABBBounds.height() + get(this.attribute, "title.space", 8) : 0), this._innerView.add(itemsContainer));
       }
       _bindEvents() {
         if (!this._itemsContainer) return;
@@ -41539,43 +41448,50 @@
           startX = 0,
           startY = 0,
           pages = 1;
-        isHorizontal ? (pagerComp = new Pager(Object.assign({
-          layout: 1 === maxRow ? "horizontal" : "vertical",
-          total: 99
-        }, merge$1({
-          handler: {
-            preShape: "triangleUp",
-            nextShape: "triangleDown"
-          }
-        }, pageStyle))), this._pager = pagerComp, this._innerView.add(pagerComp), pageHeight = (maxRow - 1) * spaceRow + this._itemHeight * maxRow, pageWidth = maxWidth - pagerComp.AABBBounds.width() - pagerSpace, itemsContainer.getChildren().forEach((item, index) => {
-          const {
-            width: width,
-            height: height
-          } = item.attribute;
-          pageWidth < startX + width && (startX = 0, startY += height + spaceRow, pages += 1), index > 0 && item.setAttributes({
-            x: startX,
-            y: startY
-          }), startX += spaceCol + width;
-        }), pagerComp.setAttributes({
-          total: Math.ceil(pages / maxRow),
-          x: pageWidth,
-          y: renderStartY + pageHeight / 2 - pagerComp.AABBBounds.height() / 2
-        })) : (pagerComp = new Pager(Object.assign({
-          layout: "horizontal",
-          total: 99
-        }, pageStyle)), this._pager = pagerComp, this._innerView.add(pagerComp), pageWidth = this._itemMaxWidth * maxCol + (maxCol - 1) * spaceCol, pageHeight = maxHeight - pagerComp.AABBBounds.height() - pagerSpace - renderStartY, itemsContainer.getChildren().forEach((item, index) => {
-          const {
-            height: height
-          } = item.attribute;
-          pageHeight < startY + height && (startY = 0, startX += this._itemMaxWidth + spaceCol, pages += 1), index > 0 && item.setAttributes({
-            x: startX,
-            y: startY
-          }), startY += spaceRow + height;
-        }), pagerComp.setAttributes({
-          total: Math.ceil(pages / maxCol),
-          x: (pageWidth - pagerComp.AABBBounds.width()) / 2,
-          y: maxHeight - pagerComp.AABBBounds.height()
-        })), pager.defaultCurrent > 1 && (isHorizontal ? itemsContainer.setAttribute("y", -(pager.defaultCurrent - 1) * (pageHeight + spaceRow)) : itemsContainer.setAttribute("x", -(pager.defaultCurrent - 1) * (pageWidth + spaceCol)));
+        if (isHorizontal) {
+          if (pagerComp = new Pager(Object.assign({
+            layout: 1 === maxRow ? "horizontal" : "vertical",
+            total: 99
+          }, merge$1({
+            handler: {
+              preShape: "triangleUp",
+              nextShape: "triangleDown"
+            }
+          }, pageStyle))), this._pager = pagerComp, this._innerView.add(pagerComp), pageHeight = (maxRow - 1) * spaceRow + this._itemHeight * maxRow, pageWidth = maxWidth - pagerComp.AABBBounds.width() - pagerSpace, pageWidth <= 0) return this._innerView.removeChild(pagerComp), !1;
+          itemsContainer.getChildren().forEach((item, index) => {
+            const {
+              width: width,
+              height: height
+            } = item.attribute;
+            pageWidth < startX + width && (startX = 0, startY += height + spaceRow, pages += 1), index > 0 && item.setAttributes({
+              x: startX,
+              y: startY
+            }), startX += spaceCol + width;
+          }), pagerComp.setAttributes({
+            total: Math.ceil(pages / maxRow),
+            x: pageWidth,
+            y: renderStartY + pageHeight / 2 - pagerComp.AABBBounds.height() / 2
+          });
+        } else {
+          if (pagerComp = new Pager(Object.assign({
+            layout: "horizontal",
+            total: 99
+          }, pageStyle)), this._pager = pagerComp, this._innerView.add(pagerComp), pageWidth = this._itemMaxWidth * maxCol + (maxCol - 1) * spaceCol, pageHeight = maxHeight - pagerComp.AABBBounds.height() - pagerSpace - renderStartY, pageHeight <= 0) return this._innerView.removeChild(pagerComp), !1;
+          itemsContainer.getChildren().forEach((item, index) => {
+            const {
+              height: height
+            } = item.attribute;
+            pageHeight < startY + height && (startY = 0, startX += this._itemMaxWidth + spaceCol, pages += 1), index > 0 && item.setAttributes({
+              x: startX,
+              y: startY
+            }), startY += spaceRow + height;
+          }), pagerComp.setAttributes({
+            total: Math.ceil(pages / maxCol),
+            x: (pageWidth - pagerComp.AABBBounds.width()) / 2,
+            y: maxHeight - pagerComp.AABBBounds.height()
+          });
+        }
+        pager.defaultCurrent > 1 && (isHorizontal ? itemsContainer.setAttribute("y", -(pager.defaultCurrent - 1) * (pageHeight + spaceRow)) : itemsContainer.setAttribute("x", -(pager.defaultCurrent - 1) * (pageWidth + spaceCol)));
         const clipGroup = createGroup({
           x: 0,
           y: renderStartY,
@@ -41595,7 +41511,7 @@
             x: -(current - 1) * (pageWidth + spaceCol)
           }, animationDuration, animationEasing) : isHorizontal ? itemsContainer.setAttribute("y", -(current - 1) * (pageHeight + spaceRow)) : itemsContainer.setAttribute("x", -(current - 1) * (pageWidth + spaceCol));
         };
-        this._pager.addEventListener("toPrev", onPaging), this._pager.addEventListener("toNext", onPaging);
+        return this._pager.addEventListener("toPrev", onPaging), this._pager.addEventListener("toNext", onPaging), !0;
       }
       _setLegendItemState(legendItem, stateName) {
         let keepCurrentStates = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : !0;
@@ -47984,6 +47900,7 @@
         ChartEvent["viewDataStatisticsUpdate"] = "viewDataStatisticsUpdate";
         ChartEvent["markDeltaYUpdate"] = "markDeltaYUpdate";
         ChartEvent["viewDataLabelUpdate"] = "viewDataLabelUpdate";
+        ChartEvent["scaleDomainUpdate"] = "scaleDomainUpdate";
         ChartEvent["scaleUpdate"] = "scaleUpdate";
         ChartEvent["dataZoomChange"] = "dataZoomChange";
         ChartEvent["drill"] = "drill";
@@ -49564,6 +49481,64 @@
         return data;
     };
 
+    const DEFAULT_SMOOTH_INTERPOLATE = 'monotone';
+    const DEFAULT_LINEAR_CLOSED_INTERPOLATE = 'linearClosed';
+
+    var ShapeTypeEnum;
+    (function (ShapeTypeEnum) {
+        ShapeTypeEnum["circle"] = "circle";
+        ShapeTypeEnum["triangle"] = "triangle";
+        ShapeTypeEnum["triangleUp"] = "triangleUp";
+        ShapeTypeEnum["triangleLeft"] = "triangleLeft";
+        ShapeTypeEnum["triangleRight"] = "triangleRight";
+        ShapeTypeEnum["triangleDown"] = "triangleDown";
+        ShapeTypeEnum["thinTriangle"] = "thinTriangle";
+        ShapeTypeEnum["rect"] = "rect";
+        ShapeTypeEnum["diamond"] = "diamond";
+        ShapeTypeEnum["square"] = "square";
+        ShapeTypeEnum["arrowLeft"] = "arrowLeft";
+        ShapeTypeEnum["arrow2Left"] = "arrow2Left";
+        ShapeTypeEnum["arrowRight"] = "arrowRight";
+        ShapeTypeEnum["arrow2Right"] = "arrow2Right";
+        ShapeTypeEnum["cross"] = "cross";
+        ShapeTypeEnum["wedge"] = "wedge";
+        ShapeTypeEnum["star"] = "star";
+        ShapeTypeEnum["wye"] = "wye";
+    })(ShapeTypeEnum || (ShapeTypeEnum = {}));
+
+    const DEFAULT_CLOSE_STROKE_JOIN = 'bevel';
+
+    var TooltipFixedPosition;
+    (function (TooltipFixedPosition) {
+        TooltipFixedPosition["top"] = "top";
+        TooltipFixedPosition["left"] = "left";
+        TooltipFixedPosition["right"] = "right";
+        TooltipFixedPosition["bottom"] = "bottom";
+        TooltipFixedPosition["inside"] = "inside";
+    })(TooltipFixedPosition || (TooltipFixedPosition = {}));
+
+    function isXAxis(orient) {
+        return orient === 'bottom' || orient === 'top';
+    }
+    function isYAxis(orient) {
+        return orient === 'left' || orient === 'right';
+    }
+    function isZAxis(orient) {
+        return orient === 'z';
+    }
+    function autoAxisType(orient, isHorizontal) {
+        if (isHorizontal) {
+            return isXAxis(orient) ? 'linear' : 'band';
+        }
+        return isXAxis(orient) ? 'band' : 'linear';
+    }
+    function getOrient(spec, whiteList) {
+        return isValidOrient(spec.orient) || (whiteList && whiteList.includes(spec.orient)) ? spec.orient : 'left';
+    }
+    function getDirectionByOrient(orient) {
+        return orient === 'top' || orient === 'bottom' ? Direction$2.horizontal : Direction$2.vertical;
+    }
+
     const getAxis$1 = (chart, type, pos) => {
         const axesComponents = chart
             .getAllComponents()
@@ -49591,6 +49566,8 @@
         }
         return null;
     };
+    const XAxisGetDimensionField = (series) => series.fieldX[0];
+    const YAxisGetDimensionField = (series) => series.fieldY[0];
     const getCartesianDimensionInfo = (chart, pos) => {
         if (!chart) {
             return null;
@@ -49604,49 +49581,15 @@
         const yAxisList = getAxis$1(chart, 'y', pos);
         const targetAxisInfo = [];
         if (xAxisList) {
-            const getDimensionField = (series) => series.fieldX[0];
             xAxisList.forEach(axis => {
-                const xScale = axis.getScale();
-                if (xScale && isDiscrete(xScale.type)) {
-                    const xValue = x - axis.getLayoutStartPoint().x;
-                    if ((xValue - xScale.range()[0]) * (xValue - xScale.range()[1]) > 0) {
-                        return;
-                    }
-                    const value = xScale.invert(xValue);
-                    if (isNil(value)) {
-                        return;
-                    }
-                    const domain = xScale.domain();
-                    let index = domain.findIndex((v) => v?.toString() === value.toString());
-                    if (index < 0) {
-                        index = undefined;
-                    }
-                    const data = getDimensionData(value, axis, 'cartesian', getDimensionField);
-                    targetAxisInfo.push({ index, value, axis, data });
-                }
+                const info = getDiscreteAxisDimensionInfo(axis, x, 'x', XAxisGetDimensionField);
+                info && targetAxisInfo.push(info);
             });
         }
         if (yAxisList) {
-            const getDimensionField = (series) => series.fieldY[0];
             yAxisList.forEach(axis => {
-                const yScale = axis.getScale();
-                if (yScale && isDiscrete(yScale.type)) {
-                    const yValue = y - axis.getLayoutStartPoint().y;
-                    if ((yValue - yScale.range()[0]) * (yValue - yScale.range()[1]) > 0) {
-                        return;
-                    }
-                    const value = yScale.invert(yValue);
-                    if (isNil(value)) {
-                        return;
-                    }
-                    const domain = yScale.domain();
-                    let index = domain.findIndex((v) => v?.toString() === value.toString());
-                    if (index < 0) {
-                        index = undefined;
-                    }
-                    const data = getDimensionData(value, axis, 'cartesian', getDimensionField);
-                    targetAxisInfo.push({ index, value, axis, data });
-                }
+                const info = getDiscreteAxisDimensionInfo(axis, y, 'y', YAxisGetDimensionField);
+                info && targetAxisInfo.push(info);
             });
         }
         if (!targetAxisInfo.length) {
@@ -49654,6 +49597,31 @@
         }
         return targetAxisInfo;
     };
+    const getDiscreteAxisDimensionInfo = (axis, posValue, posKey, getDimensionField) => {
+        const scale = axis.getScale();
+        const scalePos = posValue - axis.getLayoutStartPoint()[posKey];
+        if ((scalePos - scale.range()[0]) * (scalePos - scale.range()[1]) > 0) {
+            return null;
+        }
+        const value = scale.invert(scalePos);
+        return getDimensionInfoInAxis(axis, value, getDimensionField);
+    };
+    const getDimensionInfoInAxis = (axis, value, getDimensionField) => {
+        const scale = axis.getScale();
+        if (!scale || !isDiscrete(scale.type)) {
+            return null;
+        }
+        if (isNil(value)) {
+            return null;
+        }
+        const domain = scale.domain();
+        let index = domain.findIndex((v) => v?.toString() === value.toString());
+        if (index < 0) {
+            index = undefined;
+        }
+        const data = getDimensionData(value, axis, 'cartesian', getDimensionField ?? (isXAxis(axis.orient) ? XAxisGetDimensionField : YAxisGetDimensionField));
+        return { index, value, axis, data };
+    };
 
     const getAxis = (chart, type, pos) => {
         const axesComponents = chart
@@ -49804,6 +49772,33 @@
             }
             return result;
         }
+        dispatch(v, opt) {
+            const axis = this._chart?.getAllComponents().filter(c => {
+                if (c.specKey !== 'axes') {
+                    return false;
+                }
+                const scale = c.getScale();
+                if (!isDiscrete(scale.type)) {
+                    return false;
+                }
+                if (opt?.filter) {
+                    return opt.filter(c);
+                }
+                return true;
+            });
+            const dimensionInfo = [];
+            axis.forEach(a => {
+                const info = getDimensionInfoInAxis(a, v);
+                if (info) {
+                    dimensionInfo.push(info);
+                }
+            });
+            this._callback.call(null, {
+                action: 'enter',
+                dimensionInfo
+            });
+            return dimensionInfo;
+        }
     }
 
     class DimensionClickEvent extends DimensionEvent {
@@ -49924,6 +49919,9 @@
         _eventDispatcher;
         _mode;
         _composedEventMap = new Map();
+        getComposedEventMap() {
+            return this._composedEventMap;
+        }
         constructor(eventDispatcher, mode) {
             this._eventDispatcher = eventDispatcher;
             this._mode = mode;
@@ -49987,8 +49985,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 +50102,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);
-                stopBubble = this._invoke(handlers, eType, params);
-            }
-            if (!stopBubble) {
-                const handlers = bubble.getHandlers(Event_Bubble_Level.chart);
+            if (level) {
+                const handlers = bubble.getHandlers(level);
                 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 +50155,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 +50171,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 +50633,7 @@
                 return;
             }
             chart.compile();
+            chart.afterCompile();
             this.updateDepend();
         }
         async renderAsync(morphConfig) {
@@ -51474,6 +51480,9 @@
         getComponents() {
             return this._chart.getAllComponents();
         }
+        setDimensionIndex(value, opt = {}) {
+            return this._chart?.setDimensionIndex(value, opt);
+        }
     }
 
     var STATE_VALUE_ENUM;
@@ -51578,7 +51587,7 @@
         }
         constructor(option) {
             this._option = option;
-            this.event = new Event$1(option.eventDispatcher, option.mode);
+            this.event = this._option.model.getOption().getChart().getEvent();
             this.interaction = option.interaction;
             this.initConfig(option.mode);
         }
@@ -51611,7 +51620,9 @@
             const items = [];
             params.dimensionInfo.forEach(df => {
                 df.data.forEach(dd => {
-                    const seriesMark = (reverse ? this._markReverse : this._marks).getMarks().filter(m => m.model === dd.series);
+                    const seriesMark = (reverse ? this._markReverse : this._marks)
+                        .getMarks()
+                        .filter(m => m.model === dd.series && m.getVisible());
                     seriesMark.forEach(m => {
                         const elements = m
                             .getProduct()
@@ -54101,7 +54112,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.4";
 
     var SeriesMarkNameEnum;
     (function (SeriesMarkNameEnum) {
@@ -54589,6 +54600,9 @@
         _globalScale;
         _idMap = new Map();
         _event;
+        getEvent() {
+            return this._event;
+        }
         _dataSet;
         _layoutTag = true;
         getLayoutTag() {
@@ -55278,6 +55292,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);
@@ -55459,6 +55484,51 @@
                 }
             });
         }
+        setDimensionIndex(value, opt) {
+            let dimensionInfo = null;
+            Array.from(this._event.getComposedEventMap().values()).forEach(e => {
+                const { eventType, event } = e;
+                if (eventType === DimensionEventEnum.dimensionHover || eventType === DimensionEventEnum.dimensionClick) {
+                    const info = event.dispatch(value, opt);
+                    if (info?.length) {
+                        dimensionInfo = info;
+                    }
+                }
+            });
+            if (!dimensionInfo) {
+                return;
+            }
+            if (opt.tooltip) {
+                const tooltip = this._components.find(c => c.type === ComponentTypeEnum.tooltip);
+                if (tooltip.getVisible()) {
+                    const dataFilter = {};
+                    dimensionInfo.forEach((d) => {
+                        const { axis, value, data } = d;
+                        const isY = axis.orient === 'left' || axis.orient === 'right';
+                        data.forEach(d => {
+                            if (isY) {
+                                dataFilter[d.series.fieldY[0]] = value;
+                            }
+                            else {
+                                dataFilter[d.series.fieldX[0]] = value;
+                            }
+                        });
+                    });
+                    tooltip.showTooltip(dataFilter, opt.showTooltipOption);
+                }
+            }
+            if (opt.crosshair) {
+                const crosshair = this._components.find(c => c.type === ComponentTypeEnum.cartesianCrosshair);
+                if (crosshair && crosshair.clearAxisValue && crosshair.setAxisValue) {
+                    dimensionInfo.forEach((d) => {
+                        const { axis, value } = d;
+                        crosshair.clearAxisValue();
+                        crosshair.setAxisValue(value, axis);
+                        crosshair.layoutByValue();
+                    });
+                }
+            }
+        }
     }
 
     class CartesianChart extends BaseChart {
@@ -55580,42 +55650,6 @@
         ChartTypeEnum["heatmap"] = "heatmap";
     })(ChartTypeEnum || (ChartTypeEnum = {}));
 
-    const DEFAULT_SMOOTH_INTERPOLATE = 'monotone';
-    const DEFAULT_LINEAR_CLOSED_INTERPOLATE = 'linearClosed';
-
-    var ShapeTypeEnum;
-    (function (ShapeTypeEnum) {
-        ShapeTypeEnum["circle"] = "circle";
-        ShapeTypeEnum["triangle"] = "triangle";
-        ShapeTypeEnum["triangleUp"] = "triangleUp";
-        ShapeTypeEnum["triangleLeft"] = "triangleLeft";
-        ShapeTypeEnum["triangleRight"] = "triangleRight";
-        ShapeTypeEnum["triangleDown"] = "triangleDown";
-        ShapeTypeEnum["thinTriangle"] = "thinTriangle";
-        ShapeTypeEnum["rect"] = "rect";
-        ShapeTypeEnum["diamond"] = "diamond";
-        ShapeTypeEnum["square"] = "square";
-        ShapeTypeEnum["arrowLeft"] = "arrowLeft";
-        ShapeTypeEnum["arrow2Left"] = "arrow2Left";
-        ShapeTypeEnum["arrowRight"] = "arrowRight";
-        ShapeTypeEnum["arrow2Right"] = "arrow2Right";
-        ShapeTypeEnum["cross"] = "cross";
-        ShapeTypeEnum["wedge"] = "wedge";
-        ShapeTypeEnum["star"] = "star";
-        ShapeTypeEnum["wye"] = "wye";
-    })(ShapeTypeEnum || (ShapeTypeEnum = {}));
-
-    const DEFAULT_CLOSE_STROKE_JOIN = 'bevel';
-
-    var TooltipFixedPosition;
-    (function (TooltipFixedPosition) {
-        TooltipFixedPosition["top"] = "top";
-        TooltipFixedPosition["left"] = "left";
-        TooltipFixedPosition["right"] = "right";
-        TooltipFixedPosition["bottom"] = "bottom";
-        TooltipFixedPosition["inside"] = "inside";
-    })(TooltipFixedPosition || (TooltipFixedPosition = {}));
-
     function setDefaultCrosshairForCartesianChart(spec) {
         spec.crosshair = array(spec.crosshair || {}).map(crosshairCfg => {
             return merge$1({
@@ -65513,28 +65547,6 @@
     }
     mixin(RadarSeries, LineLikeSeriesMixin);
 
-    function isXAxis(orient) {
-        return orient === 'bottom' || orient === 'top';
-    }
-    function isYAxis(orient) {
-        return orient === 'left' || orient === 'right';
-    }
-    function isZAxis(orient) {
-        return orient === 'z';
-    }
-    function autoAxisType(orient, isHorizontal) {
-        if (isHorizontal) {
-            return isXAxis(orient) ? 'linear' : 'band';
-        }
-        return isXAxis(orient) ? 'band' : 'linear';
-    }
-    function getOrient(spec, whiteList) {
-        return isValidOrient(spec.orient) || (whiteList && whiteList.includes(spec.orient)) ? spec.orient : 'left';
-    }
-    function getDirectionByOrient(orient) {
-        return orient === 'top' || orient === 'bottom' ? Direction$2.horizontal : Direction$2.vertical;
-    }
-
     class DotSeriesTooltipHelper extends BaseSeriesTooltipHelper {
         updateTooltipSpec() {
             super.updateTooltipSpec();
@@ -68714,14 +68726,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 +68891,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 +69051,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 +69182,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 +69194,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 +70901,7 @@
         _drillInfo;
         _getTriggerEvent(type) {
             const { mode } = this._drillParams;
-            return defaultTriggerEvent[mode][type];
+            return defaultTriggerEvent[mode]?.[type];
         }
         _hideTooltip() {
             const tooltip = this
@@ -70913,22 +70927,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 +72940,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 +72983,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 +73059,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 +73080,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 +75425,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 +75464,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 +75658,8 @@
         }
         clear() {
             this._container = null;
+            this.pluginService?.disposeAll();
+            this.pluginService = null;
         }
         compile() {
             this.compileSignal();
@@ -75654,7 +75684,7 @@
                 datum: null,
                 source: Event_Source_Type.chart,
                 chart: this._option?.globalInstance?.getChart()
-            });
+            }, 'model');
         };
     }
 
@@ -77498,16 +77528,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 +77869,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 +78238,9 @@
             return this._scales;
         }
         _tickData;
+        getTickData() {
+            return this._tickData;
+        }
         _statisticsDomain = { domain: [], index: {} };
         getStatisticsDomain() {
             return this._statisticsDomain;
@@ -78017,17 +78368,6 @@
             });
         }
         updateScaleDomain() {
-            if (!this.isSeriesDataEnable()) {
-                return;
-            }
-            this.computeStatisticsDomain();
-            for (let i = 0; i < this._scales.length; i++) {
-                const data = this.collectData(i);
-                const domain = this.computeDomain(data);
-                this._scales[i].domain(domain);
-            }
-            this.transformScaleDomain();
-            this.event.emit(ChartEvent.scaleUpdate, { model: this });
         }
         computeData() {
             this._tickData.getDataView().reRunAllTransform();
@@ -78193,9 +78533,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 +78693,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 +78760,7 @@
                 getAxisId: () => this.id
             };
         }
-        onLayoutStart(ctx) {
+        afterCompile() {
             const product = this.getMarks()[0]?.getProduct();
             if (product) {
                 product.addEventListener(HOOK_EVENT.AFTER_ELEMENT_ENCODE, () => {
@@ -78435,6 +78781,9 @@
                     }
                 });
             }
+            this.callPlugin(plugin => {
+                this.pluginService && plugin.onDidCompile && plugin.onDidCompile(this.pluginService, this);
+            });
         }
         onLayoutEnd(ctx) {
             const isRangeChange = this.updateScaleRange();
@@ -78899,6 +79248,9 @@
                 temp < domain[min] && (domain[min] = temp);
             }
         }
+        getDomainSpec() {
+            return this._domain;
+        }
         setDomainMinMax(domain) {
             if (!this._domain) {
                 return;
@@ -78930,6 +79282,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 });
         }
     }
@@ -79024,6 +79377,26 @@
             }
             return Array.from(tempSet);
         }
+        updateScaleDomain() {
+            if (!this.isSeriesDataEnable()) {
+                return;
+            }
+            this.computeStatisticsDomain();
+            const userDomain = this._spec.domain;
+            for (let i = 0; i < this._scales.length; i++) {
+                if (userDomain && userDomain.length && i === 0) {
+                    this._scales[i].domain(userDomain);
+                }
+                else {
+                    const data = this.collectData(i);
+                    const domain = this.computeDomain(data);
+                    this._scales[i].domain(domain);
+                }
+            }
+            this.transformScaleDomain();
+            this.event.emit(ChartEvent.scaleDomainUpdate, { model: this });
+            this.event.emit(ChartEvent.scaleUpdate, { model: this });
+        }
     }
 
     class CartesianBandAxis extends CartesianAxis {
@@ -79707,7 +80080,8 @@
     }
 
     const discreteLegendDataMake = (data, op) => {
-        const result = {};
+        const result = [];
+        const tempKey = {};
         const { series, seriesField } = op;
         series().forEach(s => {
             const field = seriesField(s);
@@ -79719,13 +80093,14 @@
                 infoList = s.getSeriesInfoInField(field);
             }
             infoList.forEach(info => {
-                if (result[info.key]) {
+                if (tempKey[info.key]) {
                     return;
                 }
-                result[info.key] = info;
+                tempKey[info.key] = true;
+                result.push(info);
             });
         });
-        return Object.values(result);
+        return result;
     };
     const discreteLegendFilter = (data, op) => {
         const { selected, field, data: legendData } = op;
@@ -81090,12 +81465,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 +81500,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 +81572,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() {
@@ -81459,6 +81841,24 @@
             }
             return value;
         }
+        clearAxisValue() {
+            this.currValueX.clear();
+            this.currValueY.clear();
+        }
+        setAxisValue(v, axis) {
+            if (isXAxis(axis.orient)) {
+                this.currValueX.set(axis.getSpecIndex(), {
+                    v,
+                    axis
+                });
+            }
+            else {
+                this.currValueX.set(axis.getSpecIndex(), {
+                    v,
+                    axis
+                });
+            }
+        }
         getAllAxisValues(axisMap, p, currValue, vertical) {
             let discrete = false;
             axisMap.forEach(item => {
@@ -81509,7 +81909,7 @@
             this._yLeftLabel && this._yLeftLabel.hideAll();
             this._yRightLabel && this._yRightLabel.hideAll();
         }
-        layoutByValue(tag) {
+        layoutByValue(tag = LayoutType$1.ALL) {
             if (!this.enable) {
                 return;
             }
@@ -82857,6 +83257,7 @@
             if (markerVisible) {
                 if (!this._markerComponent) {
                     this._createMarkerComponent();
+                    this._markerComponent.on('*', (event, type) => this._delegateEvent(this._markerComponent, event, type));
                 }
                 this._bindSeries();
                 this._initDataView();
@@ -84308,7 +84709,6 @@
         return styleObj;
     }
 
-    const domDocument = globalThis.document;
     class BaseTooltipModel {
         static type = 'tooltipModel';
         static isInstance(obj) {
@@ -84942,7 +85342,7 @@
 
     class DomTooltipHandler extends BaseTooltipHandler {
         type = TooltipHandlerType.dom;
-        _tooltipContainer = globalThis.document?.body;
+        _tooltipContainer = domDocument?.body;
         _domStyle;
         _tooltipActual;
         model;
@@ -85478,7 +85878,7 @@
                 this._spec.parentElement = userSpec.parentElement;
             }
             else if (isTrueBrowser(this._option.mode)) {
-                this._spec.parentElement = globalThis.document?.body;
+                this._spec.parentElement = domDocument?.body;
             }
             if (isValid(userSpec.confine)) {
                 this._spec.confine = userSpec.confine;
@@ -85572,6 +85972,9 @@
             }
             return false;
         }
+        getVisible() {
+            return this._spec.visible === true;
+        }
     }
 
     function barLabel(labelInfo) {