@visactor/vchart-extension 2.0.1-alpha.2 → 2.0.1-alpha.3

package/build/index.js

@@ -2989,6 +2989,7 @@
 	            options: {
 	                direction: 'y',
 	                orient: 'negative',
+	                excludeChannels: ['x'],
 	                point: (datum, graphic) => {
 	                    const channelAttr = graphic.getGraphicAttribute('y');
 	                    const barSpace = spec.height / (spec.pageSize + 1);
@@ -3009,7 +3010,7 @@
 	            options: {
 	                direction: 'y',
 	                orient: 'negative',
-	                excludeChannels: ['y'],
+	                excludeChannels: ['x'],
 	                point: (datum, graphic) => {
 	                    const channelAttr = graphic.getGraphicAttribute('y');
 	                    return { y: channelAttr + (spec.height / (spec.pageSize + 1)) * Math.min(spec.scrollSize, spec.pageSize) };
@@ -10776,7 +10777,7 @@
 	  }
 	  removeChild(child) {
 	    const data = super.removeChild(child);
-	    return child.stage = null, this.getGraphicService().onRemove(child), this.addUpdateBoundTag(), data;
+	    return this.getGraphicService().onRemove(child), child.stage = null, this.addUpdateBoundTag(), data;
 	  }
 	  removeAllChild(deep = !1) {
 	    this.forEachChildren(child => {
@@ -18733,6 +18734,11 @@
 	      state.executor.stop();
 	    }), this.stateList = null;
 	  }
+	  reApplyState(state) {
+	    var _a;
+	    const stateInfo = null === (_a = this.stateList) || void 0 === _a ? void 0 : _a.find(stateInfo => stateInfo.state === state);
+	    stateInfo && (stateInfo.executor.stop(), stateInfo.executor.execute(stateInfo.animationConfig));
+	  }
 	}
 
 	class GraphicStateExtension {
@@ -18763,12 +18769,19 @@
 	  applyUnhighlightState(animationConfig, callback) {
 	    return this._getAnimationStateManager(this).applyUnhighlightState(animationConfig, callback), this;
 	  }
-	  stopAnimationState(state, type) {
-	    return this._getAnimationStateManager(this).stopState(state, type), this;
+	  stopAnimationState(state, type, deep = !1) {
+	    return this._getAnimationStateManager(this).stopState(state, type), deep && this.isContainer && this.forEachChildren(child => {
+	      child.stopAnimationState(state, type, deep);
+	    }), this;
 	  }
 	  clearAnimationStates() {
 	    return this._getAnimationStateManager(this).clearState(), this;
 	  }
+	  reApplyAnimationState(state, deep = !1) {
+	    return this._getAnimationStateManager(this).reApplyState(state), deep && this.isContainer && this.forEachChildren(child => {
+	      child.reApplyAnimationState(state, deep);
+	    }), this;
+	  }
 	  static extend(graphic) {
 	    return new GraphicStateExtension()._getAnimationStateManager(graphic), graphic;
 	  }
@@ -18820,6 +18833,21 @@
 	  getGraphicAttribute(key, prev = !1) {
 	    return !prev && this.finalAttribute ? this.finalAttribute[key] : this.attribute[key];
 	  }
+	  pauseAnimation(deep = !1) {
+	    this.animates && this.animates.forEach(animate => animate.pause()), deep && this.isContainer && this.forEachChildren(child => {
+	      child.pauseAnimation(deep);
+	    });
+	  }
+	  resumeAnimation(deep = !1) {
+	    this.animates && this.animates.forEach(animate => animate.resume()), deep && this.isContainer && this.forEachChildren(child => {
+	      child.resumeAnimation(deep);
+	    });
+	  }
+	  stopAnimation(deep = !1) {
+	    this.animates && this.animates.forEach(animate => animate.stop()), deep && this.isContainer && this.forEachChildren(child => {
+	      child.stopAnimation(deep);
+	    });
+	  }
 	}
 
 	function registerAnimate() {
@@ -19021,17 +19049,6 @@
 	        items,
 	        scale: axis._scale.clone()
 	    };
-	    if (!ignoreGrid) {
-	        attrs.grid = {
-	            type: 'line',
-	            start: { x: 0, y: 0 },
-	            end,
-	            items: items[0],
-	            verticalFactor: axis._axisStyle.verticalFactor,
-	            depth: depthZ,
-	            length: !ignoreGrid ? regionSize.height : 0
-	        };
-	    }
 	    const directionStr = (_a = axis.directionStr) !== null && _a !== void 0 ? _a : 'r2l';
 	    let anchor3d = [0, 0];
 	    let alpha = -Math.PI / 2;
@@ -19044,6 +19061,20 @@
 	    attrs.z = z;
 	    attrs.alpha = alpha;
 	    attrs.anchor3d = anchor3d;
+	    if (!ignoreGrid) {
+	        attrs.grid = {
+	            type: 'line',
+	            start: { x: 0, y: 0 },
+	            end,
+	            items: items[0],
+	            verticalFactor: axis._axisStyle.verticalFactor,
+	            depth: depthZ,
+	            length: !ignoreGrid ? regionSize.height : 0,
+	            alpha,
+	            z,
+	            anchor3d
+	        };
+	    }
 	    return attrs;
 	};
 
@@ -19053,7 +19084,59 @@
 	    }
 	    _afterUpdateAttribute(attrs, ignoreGrid) {
 	        const isZ = vchart.isZAxis(this._orient);
+	        const isX = vchart.isXAxis(this._orient);
+	        const isY = vchart.isYAxis(this._orient);
+	        let regionHeight = 0;
+	        let regionWidth = 0;
+	        if (!ignoreGrid) {
+	            const regions = this.getRegions();
+	            let { x: minX, y: minY } = regions[0].getLayoutStartPoint();
+	            let maxX = minX + regions[0].getLayoutRect().width;
+	            let maxY = minY + regions[0].getLayoutRect().height;
+	            for (let index = 1; index < regions.length; index++) {
+	                const region = regions[index];
+	                const { x, y } = region.getLayoutStartPoint();
+	                const { width, height } = region.getLayoutRect();
+	                minX = Math.min(minX, x);
+	                maxX = Math.max(maxX, width + x);
+	                minY = Math.min(minY, y);
+	                maxY = Math.max(maxY, height + y);
+	            }
+	            regionHeight = Math.abs(maxY - minY);
+	            regionWidth = Math.abs(maxX - minX);
+	        }
+	        let gridLength = 0;
+	        let axisLength = 0;
+	        const { width, height } = this.getLayoutRect();
+	        let end = { x: 0, y: 0 };
+	        if (isX) {
+	            end = { x: width, y: 0 };
+	            gridLength = regionHeight;
+	            axisLength = width;
+	        }
+	        else if (isY) {
+	            end = { x: 0, y: height };
+	            gridLength = regionWidth;
+	            axisLength = height;
+	        }
+	        const depth = this.layout3dBox ? this.layout3dBox.length : 0;
 	        if (!isZ) {
+	            const items = this.getLabelItems(axisLength);
+	            attrs.grid = {
+	                length: gridLength
+	            };
+	            attrs.start = { x: 0, y: 0 };
+	            attrs.text = this._spec.title.text || this._dataFieldText;
+	            attrs.maxWidth = this._getTitleLimit(isX);
+	            attrs.items = items;
+	            attrs.grid = {
+	                type: 'line',
+	                start: { x: 0, y: 0 },
+	                end,
+	                items: items[0],
+	                depth,
+	                length: gridLength
+	            };
 	            return attrs;
 	        }
 	        return getUpdateAttributeOfZAxis(this, ignoreGrid);