@visactor/vrender-components 0.22.5-alpha.1 → 0.22.5-alpha.3

package/dist/index.es.js

@@ -1,4 +1,4 @@
-import { tau, halfPi as halfPi$1, AABBBounds, degreeToRadian, Point, PointService, abs, max, min, atan2, epsilon, Matrix, pi2, Logger, pi, isArray, isNumberClose, TextMeasure, EventEmitter, isBoolean, isObject, isFunction, cos, sin, isString, pointAt, isNumber, getDecimalPlaces, isNil, Color, sqrt, OBBBounds, has, normalTransform, isValidUrl, isBase64, acos, transformBoundsWithMatrix, getContextFont, rotatePoint, clampAngleByRadian, asin, arrayEqual, Bounds, getRectIntersect, isRectIntersect, isPlainObject, merge, clamp, clampRange, normalizePadding, debounce, throttle, hexToRgb, crossProduct, isValid, isEmpty, array, rectInsideAnotherRect, radianToDegree, getAngleByPoint, polarToCartesian, normalizeAngle, isValidNumber, flattenArray, isRotateAABBIntersect, isLess, isGreater, cloneDeep, get, last, mixin, isEqual, interpolateString, minInArray, maxInArray, binaryFuzzySearchInNumberRange, calculateAnchorOfBounds, computeQuadrant, polygonContainPoint } from '@visactor/vutils';
+import { tau, halfPi as halfPi$1, AABBBounds, degreeToRadian, Point, PointService, abs, max, min, atan2, epsilon, Matrix, pi2, Logger, pi, isArray, isNumberClose, TextMeasure, EventEmitter, isBoolean, isObject, isFunction, cos, sin, isString, pointAt, isNumber, getDecimalPlaces, isNil, Color, sqrt, OBBBounds, has, normalTransform, isValidUrl, isBase64, acos, transformBoundsWithMatrix, getContextFont, rotatePoint, clampAngleByRadian, asin, arrayEqual, Bounds, getRectIntersect, isRectIntersect, isPlainObject, merge, clamp, clampRange, normalizePadding, debounce, throttle, hexToRgb, crossProduct, isValid, isEmpty, rectInsideAnotherRect, radianToDegree, getAngleByPoint, polarToCartesian, normalizeAngle, isValidNumber, flattenArray, array, isRotateAABBIntersect, isLess, isGreater, cloneDeep, get, last, mixin, isEqual, interpolateString, minInArray, maxInArray, binaryFuzzySearchInNumberRange, calculateAnchorOfBounds, computeQuadrant, polygonContainPoint } from '@visactor/vutils';
 import { isContinuous, isDiscrete, LinearScale } from '@visactor/vscale';
 
 class Generator {
@@ -15941,17 +15941,14 @@ class Tag extends AbstractComponent {
         tagWidth += symbolPlaceWidth;
         textX += symbolPlaceWidth;
         let textShape;
-        let textWidth;
-        let textHeight;
         const isRich = isRichText({ text }) || type === 'rich';
         if (isRich) {
             const richTextAttrs = Object.assign(Object.assign(Object.assign({}, richTextAttributeTransform(Object.assign({ type, text }, textStyle))), textStyle), { visible: isValid(text) && visible !== false, x: textX, y: 0 });
-            if (isNil(richTextAttrs.lineHeight)) {
-                richTextAttrs.lineHeight = textStyle.fontSize;
-            }
             textShape = group.createOrUpdateChild('tag-text', richTextAttrs, 'richtext');
-            textWidth = textShape.AABBBounds.width();
-            textHeight = textShape.AABBBounds.height();
+            tagWidth += textShape.AABBBounds.width();
+            tagHeight += textShape.AABBBounds.height();
+            tagX += textShape.AABBBounds.x1;
+            tagY += textShape.AABBBounds.y1;
         }
         else {
             const textAttrs = Object.assign(Object.assign({ text: isObject(text) && 'type' in text && text.type === 'text' ? text.text : text, visible: isValid(text) && visible !== false, lineHeight: textStyle === null || textStyle === void 0 ? void 0 : textStyle.fontSize }, textStyle), { x: textX, y: 0 });
@@ -15959,134 +15956,126 @@ class Tag extends AbstractComponent {
                 textAttrs.lineHeight = textStyle.fontSize;
             }
             textShape = group.createOrUpdateChild('tag-text', textAttrs, 'text');
+            if (!isEmpty(state === null || state === void 0 ? void 0 : state.text)) {
+                textShape.states = state.text;
+            }
             const textBounds = measureTextSize(textAttrs.text, textStyle, (_b = (_a = this.stage) === null || _a === void 0 ? void 0 : _a.getTheme()) === null || _b === void 0 ? void 0 : _b.text);
-            textWidth = textBounds.width;
-            textHeight = textBounds.height;
-        }
-        tagWidth += textWidth;
-        const size = (_c = shape.size) !== null && _c !== void 0 ? _c : 10;
-        const maxSize = (isNumber(size) ? size : Math.max(size[0], size[1]));
-        tagHeight += Math.max(textHeight, shape.visible ? maxSize : 0);
-        const { textAlign, textBaseline } = textStyle;
-        if (isValid(minWidth) || isValid(maxWidth)) {
-            if (isValid(minWidth) && tagWidth < minWidth) {
-                tagWidth = minWidth;
+            const textWidth = textBounds.width;
+            const textHeight = textBounds.height;
+            tagWidth += textWidth;
+            const size = (_c = shape.size) !== null && _c !== void 0 ? _c : 10;
+            const maxSize = (isNumber(size) ? size : Math.max(size[0], size[1]));
+            tagHeight += Math.max(textHeight, shape.visible ? maxSize : 0);
+            const { textAlign, textBaseline } = textStyle;
+            if (isValid(minWidth) || isValid(maxWidth)) {
+                if (isValid(minWidth) && tagWidth < minWidth) {
+                    tagWidth = minWidth;
+                }
+                if (isValid(maxWidth) && tagWidth > maxWidth) {
+                    tagWidth = maxWidth;
+                    textShape.setAttribute('maxLineWidth', maxWidth - parsedPadding[1] - parsedPadding[2]);
+                }
             }
-            if (isValid(maxWidth) && tagWidth > maxWidth) {
-                tagWidth = maxWidth;
-                textShape.setAttribute('maxLineWidth', maxWidth - parsedPadding[1] - parsedPadding[2]);
+            tagX = 0;
+            tagY = 0;
+            let flag = 0;
+            if (textAlign === 'left' || textAlign === 'start') {
+                flag = 1;
             }
-        }
-        tagX = 0;
-        tagY = 0;
-        let flag = 0;
-        if (textAlign === 'left' || textAlign === 'start') {
-            flag = 1;
-        }
-        else if (textAlign === 'right' || textAlign === 'end') {
-            flag = -1;
-        }
-        else if (textAlign === 'center') {
-            flag = 0;
-        }
-        if (!flag) {
-            tagX -= tagWidth / 2;
-            if (symbol) {
-                symbol.setAttribute('x', (symbol.attribute.x || 0) - textWidth / 2);
+            else if (textAlign === 'right' || textAlign === 'end') {
+                flag = -1;
             }
-            group.setAttribute('x', -symbolPlaceWidth / 2);
-        }
-        else if (flag < 0) {
-            tagX -= tagWidth;
-            if (symbol) {
-                symbol.setAttribute('x', (symbol.attribute.x || 0) - textWidth);
+            else if (textAlign === 'center') {
+                flag = 0;
             }
-            group.setAttribute('x', -parsedPadding[1] - symbolPlaceWidth);
-        }
-        else if (flag > 0) {
-            group.setAttribute('x', parsedPadding[3]);
-        }
-        const shouldCenter = containerTextAlign ? containerTextAlign === 'center' : textAlwaysCenter;
-        const shouldRight = containerTextAlign === 'right' || containerTextAlign === 'end';
-        const shouldLeft = containerTextAlign === 'left' || containerTextAlign === 'start';
-        const updateTextAttrs = (textX, textAlign) => {
-            if (textShape.type === 'richtext') {
+            if (!flag) {
+                tagX -= tagWidth / 2;
+                if (symbol) {
+                    symbol.setAttribute('x', (symbol.attribute.x || 0) - textWidth / 2);
+                }
+                group.setAttribute('x', -symbolPlaceWidth / 2);
+            }
+            else if (flag < 0) {
+                tagX -= tagWidth;
+                if (symbol) {
+                    symbol.setAttribute('x', (symbol.attribute.x || 0) - textWidth);
+                }
+                group.setAttribute('x', -parsedPadding[1] - symbolPlaceWidth);
+            }
+            else if (flag > 0) {
+                group.setAttribute('x', parsedPadding[3]);
+            }
+            const shouldCenter = containerTextAlign ? containerTextAlign === 'center' : textAlwaysCenter;
+            const shouldRight = containerTextAlign === 'right' || containerTextAlign === 'end';
+            const shouldLeft = containerTextAlign === 'left' || containerTextAlign === 'start';
+            if (shouldCenter && flag) {
+                const containerWidth = tagWidth - parsedPadding[1] - parsedPadding[3];
+                const tsWidth = textWidth + symbolPlaceWidth;
+                const textX = flag === 1
+                    ? (containerWidth - tsWidth) / 2 + symbolPlaceWidth + textWidth / 2
+                    : parsedPadding[0] + symbolPlaceWidth - (tagWidth / 2 + tsWidth / 2 - symbolPlaceWidth) + textWidth / 2;
                 textShape.setAttributes({
                     x: textX,
-                    textAlign,
-                    textConfig: array(textShape.attribute.textConfig).map(t => {
-                        return Object.assign(Object.assign({}, t), { textAlign });
-                    })
+                    textAlign: 'center'
                 });
+                if (symbol) {
+                    const symbolX = textX - textWidth / 2 - symbolPlaceWidth + maxSize / 2;
+                    symbol.setAttributes({
+                        x: symbolX
+                    });
+                }
             }
-            else {
+            if (shouldLeft && flag !== 1) {
+                const containerWidth = tagWidth - parsedPadding[1] - parsedPadding[3];
+                const offset = flag === 0
+                    ? -containerWidth / 2 + symbolPlaceWidth / 2
+                    : -tagWidth + parsedPadding[3] + parsedPadding[1] + symbolPlaceWidth;
+                const textX = offset + symbolPlaceWidth;
                 textShape.setAttributes({
                     x: textX,
-                    textAlign
-                });
-            }
-        };
-        if (shouldCenter && flag) {
-            const containerWidth = tagWidth - parsedPadding[1] - parsedPadding[3];
-            const tsWidth = textWidth + symbolPlaceWidth;
-            const textX = flag === 1
-                ? (containerWidth - tsWidth) / 2 + symbolPlaceWidth + textWidth / 2
-                : parsedPadding[0] + symbolPlaceWidth - (tagWidth / 2 + tsWidth / 2 - symbolPlaceWidth) + textWidth / 2;
-            updateTextAttrs(textX, 'center');
-            if (symbol) {
-                const symbolX = textX - textWidth / 2 - symbolPlaceWidth + maxSize / 2;
-                symbol.setAttributes({
-                    x: symbolX
-                });
-            }
-        }
-        if (shouldLeft && flag !== 1) {
-            const containerWidth = tagWidth - parsedPadding[1] - parsedPadding[3];
-            const offset = flag === 0
-                ? -containerWidth / 2 + symbolPlaceWidth / 2
-                : -tagWidth + parsedPadding[3] + parsedPadding[1] + symbolPlaceWidth;
-            const textX = offset + symbolPlaceWidth;
-            updateTextAttrs(textX, 'left');
-            if (symbol) {
-                const symbolX = offset + maxSize / 2;
-                symbol.setAttributes({
-                    x: symbolX
+                    textAlign: 'left'
                 });
+                if (symbol) {
+                    const symbolX = offset + maxSize / 2;
+                    symbol.setAttributes({
+                        x: symbolX
+                    });
+                }
             }
-        }
-        if (shouldRight && flag !== -1) {
-            const containerWidth = tagWidth - parsedPadding[1] - parsedPadding[3];
-            const textX = flag === 0 ? containerWidth / 2 + symbolPlaceWidth / 2 : containerWidth;
-            updateTextAttrs(textX, 'right');
-            if (symbol) {
-                const symbolX = textX - textWidth - symbolPlaceWidth + maxSize / 2;
-                symbol.setAttributes({
-                    x: symbolX
+            if (shouldRight && flag !== -1) {
+                const containerWidth = tagWidth - parsedPadding[1] - parsedPadding[3];
+                const textX = flag === 0 ? containerWidth / 2 + symbolPlaceWidth / 2 : containerWidth;
+                textShape.setAttributes({
+                    x: textX,
+                    textAlign: 'right'
                 });
+                if (symbol) {
+                    const symbolX = textX - textWidth - symbolPlaceWidth + maxSize / 2;
+                    symbol.setAttributes({
+                        x: symbolX
+                    });
+                }
             }
-        }
-        if (textBaseline === 'middle') {
-            tagY -= tagHeight / 2;
-            if (symbol) {
-                symbol.setAttribute('y', 0);
+            if (textBaseline === 'middle') {
+                tagY -= tagHeight / 2;
+                if (symbol) {
+                    symbol.setAttribute('y', 0);
+                }
             }
-        }
-        else if (textBaseline === 'bottom') {
-            tagY -= tagHeight;
-            if (symbol) {
-                symbol.setAttribute('y', -textHeight / 2);
+            else if (textBaseline === 'bottom') {
+                tagY -= tagHeight;
+                if (symbol) {
+                    symbol.setAttribute('y', -textHeight / 2);
+                }
+                group.setAttribute('y', -parsedPadding[2]);
             }
-            group.setAttribute('y', -parsedPadding[2]);
-        }
-        else if (textBaseline === 'top') {
-            group.setAttribute('y', parsedPadding[0]);
-            if (symbol) {
-                symbol.setAttribute('y', textHeight / 2);
+            else if (textBaseline === 'top') {
+                group.setAttribute('y', parsedPadding[0]);
+                if (symbol) {
+                    symbol.setAttribute('y', textHeight / 2);
+                }
             }
         }
-        if (!isEmpty(state === null || state === void 0 ? void 0 : state.text)) {
-            textShape.states = state.text;
-        }
         const { visible: bgVisible } = panel, backgroundStyle = __rest(panel, ["visible"]);
         if (visible && isBoolean(bgVisible)) {
             const bgRect = this.createOrUpdateChild('tag-panel', Object.assign(Object.assign({}, backgroundStyle), { visible: bgVisible && !!text, width: tagWidth, height: tagHeight, x: tagX, y: tagY }), 'rect');
@@ -29577,7 +29566,7 @@ var IOperateType;
 const DEFAULT_BRUSH_ATTRIBUTES = {
     trigger: 'pointerdown',
     updateTrigger: 'pointermove',
-    endTrigger: 'pointerup',
+    endTrigger: ['pointerup', 'pointerleave'],
     resetTrigger: 'pointerupoutside',
     hasMask: true,
     brushMode: 'single',
@@ -29631,6 +29620,7 @@ class Brush extends AbstractComponent {
                 this._isDownBeforeUpOutside = true;
                 return;
             }
+            this._isDownBeforeUpOutside = false;
             e.stopPropagation();
             const brushMoved = (_a = this.attribute.brushMoved) !== null && _a !== void 0 ? _a : true;
             this._activeMoveState = brushMoved && this._isPosInBrushMask(e);
@@ -29653,6 +29643,14 @@ class Brush extends AbstractComponent {
             : delayMap[this.attribute.delayType](this._onBrushing, this.attribute.delayTime);
         this._onBrushEnd = (e) => {
             var _a;
+            if (this._isDownBeforeUpOutside) {
+                if (!this._isEmptyMask()) {
+                    this._clearMask();
+                    this._dispatchBrushEvent(IOperateType.brushClear, e);
+                }
+                this._isDownBeforeUpOutside = false;
+                return;
+            }
             if (!this._activeDrawState && !this._activeMoveState) {
                 return;
             }
@@ -29660,29 +29658,29 @@ class Brush extends AbstractComponent {
             const { removeOnClick = true } = this.attribute;
             if (this._activeDrawState && !this._isDrawedBeforeEnd && removeOnClick) {
                 if ((_a = this._operatingMask) === null || _a === void 0 ? void 0 : _a._AABBBounds.empty()) {
-                    this._dispatchEvent(IOperateType.brushClear, {
-                        operateMask: this._operatingMask,
-                        operatedMaskAABBBounds: this._brushMaskAABBBoundsDict,
-                        event: e
-                    });
+                    if (!this._isEmptyMask()) {
+                        this._clearMask();
+                        this._dispatchBrushEvent(IOperateType.brushClear, e);
+                    }
+                }
+                else {
+                    delete this._brushMaskAABBBoundsDict[this._operatingMask.name];
+                    this._container.setAttributes({});
+                    this._container.removeChild(this._operatingMask);
+                    if (!this._isEmptyMask()) {
+                        this._dispatchBrushEvent(IOperateType.brushClear, e);
+                    }
+                    else {
+                        this._dispatchBrushEvent(IOperateType.drawEnd, e);
+                    }
                 }
-                this._container.incrementalClearChild();
-                this._brushMaskAABBBoundsDict = {};
             }
             else {
                 if (this._activeDrawState) {
-                    this._dispatchEvent(IOperateType.drawEnd, {
-                        operateMask: this._operatingMask,
-                        operatedMaskAABBBounds: this._brushMaskAABBBoundsDict,
-                        event: e
-                    });
+                    this._dispatchBrushEvent(IOperateType.drawEnd, e);
                 }
                 if (this._activeMoveState) {
-                    this._dispatchEvent(IOperateType.moveEnd, {
-                        operateMask: this._operatingMask,
-                        operatedMaskAABBBounds: this._brushMaskAABBBoundsDict,
-                        event: e
-                    });
+                    this._dispatchBrushEvent(IOperateType.moveEnd, e);
                 }
             }
             this._activeDrawState = false;
@@ -29694,23 +29692,14 @@ class Brush extends AbstractComponent {
         };
         this._onBrushClear = (e) => {
             e.preventDefault();
-            const { removeOnClick = true } = this.attribute;
-            if (this._isDownBeforeUpOutside && removeOnClick) {
-                this._dispatchEvent(IOperateType.brushClear, {
-                    operateMask: this._operatingMask,
-                    operatedMaskAABBBounds: this._brushMaskAABBBoundsDict,
-                    event: e
-                });
-                this._container.incrementalClearChild();
-                this._brushMaskAABBBoundsDict = {};
+            if (!this._isEmptyMask()) {
+                this._clearMask();
+                this._dispatchBrushEvent(IOperateType.brushClear, e);
             }
             this._activeDrawState = false;
             this._activeMoveState = false;
             this._isDrawedBeforeEnd = false;
             this._isDownBeforeUpOutside = false;
-            if (this._operatingMask) {
-                this._operatingMask.setAttribute('pickable', false);
-            }
         };
     }
     _bindBrushEvents() {
@@ -29718,44 +29707,19 @@ class Brush extends AbstractComponent {
             return;
         }
         const { trigger = DEFAULT_BRUSH_ATTRIBUTES.trigger, updateTrigger = DEFAULT_BRUSH_ATTRIBUTES.updateTrigger, endTrigger = DEFAULT_BRUSH_ATTRIBUTES.endTrigger, resetTrigger = DEFAULT_BRUSH_ATTRIBUTES.resetTrigger } = this.attribute;
-        array(trigger).forEach(t => vglobal.addEventListener(t, this._onBrushStart));
+        array(trigger).forEach(t => this.stage.addEventListener(t, this._onBrushStart));
         array(updateTrigger).forEach(t => this.stage.addEventListener(t, this._onBrushingWithDelay));
         array(endTrigger).forEach(t => this.stage.addEventListener(t, this._onBrushEnd));
         array(resetTrigger).forEach(t => this.stage.addEventListener(t, this._onBrushClear));
     }
-    _isPosInBrushMask(e) {
-        const pos = this.eventPosToStagePos(e);
-        const brushMasks = this._container.getChildren();
-        for (let i = 0; i < brushMasks.length; i++) {
-            const { points = [], dx = 0, dy = 0 } = brushMasks[i].attribute;
-            const pointsConsiderOffset = points.map((point) => {
-                return {
-                    x: point.x + dx,
-                    y: point.y + dy
-                };
-            });
-            if (polygonContainPoint(pointsConsiderOffset, pos.x, pos.y)) {
-                this._operatingMask = brushMasks[i];
-                return true;
-            }
-        }
-        return false;
-    }
     _initDraw(e) {
         const { brushMode } = this.attribute;
         const pos = this.eventPosToStagePos(e);
         this._cacheDrawPoints = [pos];
         this._isDrawedBeforeEnd = false;
-        if (brushMode === 'single') {
-            this._brushMaskAABBBoundsDict = {};
-            this._container.incrementalClearChild();
-        }
+        brushMode === 'single' && this._clearMask();
         this._addBrushMask();
-        this._dispatchEvent(IOperateType.drawStart, {
-            operateMask: this._operatingMask,
-            operatedMaskAABBBounds: this._brushMaskAABBBoundsDict,
-            event: e
-        });
+        this._dispatchBrushEvent(IOperateType.drawStart, e);
     }
     _initMove(e) {
         var _a, _b;
@@ -29772,11 +29736,7 @@ class Brush extends AbstractComponent {
         this._operatingMaskMoveRangeX = [minMoveStepX, maxMoveStepX];
         this._operatingMaskMoveRangeY = [minMoveStepY, maxMoveStepY];
         this._operatingMask.setAttribute('pickable', true);
-        this._dispatchEvent(IOperateType.moveStart, {
-            operateMask: this._operatingMask,
-            operatedMaskAABBBounds: this._brushMaskAABBBoundsDict,
-            event: e
-        });
+        this._dispatchBrushEvent(IOperateType.moveStart, e);
     }
     _drawing(e) {
         var _a, _b;
@@ -29803,12 +29763,8 @@ class Brush extends AbstractComponent {
                 !!(Math.abs(x2 - x1) > sizeThreshold || Math.abs(y1 - y2) > sizeThreshold);
         if (this._isDrawedBeforeEnd) {
             this._brushMaskAABBBoundsDict[this._operatingMask.name] = this._operatingMask.AABBBounds;
-            this._dispatchEvent(IOperateType.drawing, {
-                operateMask: this._operatingMask,
-                operatedMaskAABBBounds: this._brushMaskAABBBoundsDict,
-                event: e
-            });
         }
+        this._dispatchBrushEvent(IOperateType.drawing, e);
     }
     _moving(e) {
         const startPos = this._cacheMovePoint;
@@ -29827,11 +29783,20 @@ class Brush extends AbstractComponent {
             dy: moveY
         });
         this._brushMaskAABBBoundsDict[this._operatingMask.name] = this._operatingMask.AABBBounds;
-        this._dispatchEvent(IOperateType.moving, {
-            operateMask: this._operatingMask,
-            operatedMaskAABBBounds: this._brushMaskAABBBoundsDict,
-            event: e
-        });
+        this._dispatchBrushEvent(IOperateType.moving, e);
+    }
+    render() {
+        this.releaseBrushEvents();
+        this._bindBrushEvents();
+        const group = this.createOrUpdateChild('brush-container', {}, 'group');
+        this._container = group;
+    }
+    releaseBrushEvents() {
+        const { trigger = DEFAULT_BRUSH_ATTRIBUTES.trigger, updateTrigger = DEFAULT_BRUSH_ATTRIBUTES.updateTrigger, endTrigger = DEFAULT_BRUSH_ATTRIBUTES.endTrigger, resetTrigger = DEFAULT_BRUSH_ATTRIBUTES.resetTrigger } = this.attribute;
+        array(trigger).forEach(t => this.stage.removeEventListener(t, this._onBrushStart));
+        array(updateTrigger).forEach(t => this.stage.removeEventListener(t, this._onBrushingWithDelay));
+        array(endTrigger).forEach(t => this.stage.removeEventListener(t, this._onBrushEnd));
+        array(resetTrigger).forEach(t => this.stage.removeEventListener(t, this._onBrushClear));
     }
     _computeMaskPoints() {
         const { brushType, xRange = [0, 0], yRange = [0, 0] } = this.attribute;
@@ -29900,12 +29865,30 @@ class Brush extends AbstractComponent {
     _addBrushMask() {
         var _a;
         const { brushStyle, hasMask } = this.attribute;
-        const brushMask = graphicCreator.polygon(Object.assign(Object.assign({ points: cloneDeep(this._cacheDrawPoints), cursor: 'move', pickable: false }, brushStyle), { opacity: hasMask ? (_a = brushStyle.opacity) !== null && _a !== void 0 ? _a : 1 : 0 }));
+        const brushMask = graphicCreator.polygon(Object.assign(Object.assign({ points: cloneDeep(this._cacheDrawPoints), cursor: 'move', pickable: false }, brushStyle), { opacity: hasMask ? ((_a = brushStyle.opacity) !== null && _a !== void 0 ? _a : 1) : 0 }));
         brushMask.name = `brush-${Date.now()}`;
         this._operatingMask = brushMask;
         this._container.add(brushMask);
         this._brushMaskAABBBoundsDict[brushMask.name] = brushMask.AABBBounds;
     }
+    _isPosInBrushMask(e) {
+        const pos = this.eventPosToStagePos(e);
+        const brushMasks = this._container.getChildren();
+        for (let i = 0; i < brushMasks.length; i++) {
+            const { points = [], dx = 0, dy = 0 } = brushMasks[i].attribute;
+            const pointsConsiderOffset = points.map((point) => {
+                return {
+                    x: point.x + dx,
+                    y: point.y + dy
+                };
+            });
+            if (polygonContainPoint(pointsConsiderOffset, pos.x, pos.y)) {
+                this._operatingMask = brushMasks[i];
+                return true;
+            }
+        }
+        return false;
+    }
     _outOfInteractiveRange(e) {
         const { interactiveRange } = this.attribute;
         const { minY = -Infinity, maxY = Infinity, minX = -Infinity, maxX = Infinity } = interactiveRange;
@@ -29918,17 +29901,21 @@ class Brush extends AbstractComponent {
     eventPosToStagePos(e) {
         return this.stage.eventPointTransform(e);
     }
-    render() {
-        this._bindBrushEvents();
-        const group = this.createOrUpdateChild('brush-container', {}, 'group');
-        this._container = group;
+    _dispatchBrushEvent(operateType, e) {
+        this._dispatchEvent(operateType, {
+            operateMask: this._operatingMask,
+            operatedMaskAABBBounds: this._brushMaskAABBBoundsDict,
+            event: e
+        });
     }
-    releaseBrushEvents() {
-        const { delayType = 'throttle', delayTime = 0, trigger = DEFAULT_BRUSH_ATTRIBUTES.trigger, updateTrigger = DEFAULT_BRUSH_ATTRIBUTES.updateTrigger, endTrigger = DEFAULT_BRUSH_ATTRIBUTES.endTrigger, resetTrigger = DEFAULT_BRUSH_ATTRIBUTES.resetTrigger } = this.attribute;
-        array(trigger).forEach(t => vglobal.removeEventListener(t, this._onBrushStart));
-        array(updateTrigger).forEach(t => this.stage.removeEventListener(t, this._onBrushingWithDelay));
-        array(endTrigger).forEach(t => this.stage.removeEventListener(t, this._onBrushEnd));
-        array(resetTrigger).forEach(t => this.stage.removeEventListener(t, this._onBrushClear));
+    _clearMask() {
+        this._brushMaskAABBBoundsDict = {};
+        this._container.incrementalClearChild();
+        this._operatingMask = null;
+    }
+    _isEmptyMask() {
+        return (isEmpty(this._brushMaskAABBBoundsDict) ||
+            Object.keys(this._brushMaskAABBBoundsDict).every(key => this._brushMaskAABBBoundsDict[key].empty()));
     }
 }
 Brush.defaultAttributes = DEFAULT_BRUSH_ATTRIBUTES;
@@ -31471,6 +31458,6 @@ StoryLabelItem.defaultAttributes = {
     theme: 'default'
 };
 
-const version = "0.22.5-alpha.1";
+const version = "0.22.5-alpha.3";
 
 export { AXIS_ELEMENT_NAME, AbstractComponent, ArcInfo, ArcLabel, ArcSegment, AxisStateValue, BasePlayer, Brush, CheckBox, CircleAxis, CircleAxisGrid, CircleCrosshair, ColorContinuousLegend, ContinuousPlayer, DEFAULT_ITEM_SPACE_COL, DEFAULT_ITEM_SPACE_ROW, DEFAULT_LABEL_SPACE, DEFAULT_PAGER_SPACE, DEFAULT_SHAPE_SIZE, DEFAULT_SHAPE_SPACE, DEFAULT_STATES$1 as DEFAULT_STATES, DEFAULT_TITLE_SPACE, DEFAULT_VALUE_SPACE, DataLabel, DataZoom, DataZoomActiveTag, DirectionEnum, DiscreteLegend, DiscretePlayer, EmptyTip, GroupTransition, IMarkAreaLabelPosition, IMarkCommonArcLabelPosition, IMarkLineLabelPosition, IMarkPointItemPosition, IOperateType, Indicator, LEGEND_ELEMENT_NAME, LabelBase, LegendEvent, LegendStateValue, LineAxis, LineAxisGrid, LineCrosshair, LineLabel, LinkPath, MarkArcArea, MarkArcLine, MarkArea, MarkLine, MarkPoint, Pager, PlayerEventEnum, PolygonCrosshair, PolygonSectorCrosshair, PopTip, Radio, RectCrosshair, RectLabel, SLIDER_ELEMENT_NAME, ScrollBar, SectorCrosshair, Segment, SizeContinuousLegend, Slider, StoryLabelItem, Switch, SymbolLabel, Tag, Timeline, Title, Tooltip, TopZIndex, VTag, WeatherBox, alignTextInLine, angle, angleLabelOrientAttribute, angleTo, cartesianTicks, clampRadian, computeOffsetForlimit, continuousTicks, contrastAccessibilityChecker, convertDomainToTickData, createTextGraphicByType, deltaXYToAngle, fuzzyEqualNumber, getAxisBreakSymbolAttrs, getCircleLabelPosition, getCirclePoints, getCircleVerticalVector, getElMap, getHorizontalPath, getMarksByName, getNoneGroupMarksByName, getPolarAngleLabelPosition, getPolygonPath, getSizeHandlerPath, getTextAlignAttrOfVerticalDir, getTextType, getVerticalCoord, getVerticalPath, hasOverlap, htmlAttributeTransform, initTextMeasure, isInRange, isPostiveXAxis, isRichText, isVisible, labelSmartInvert, length, limitShapeInBounds, linearDiscreteTicks, loadPoptip, loadScrollbar, measureTextSize, normalize, polarAngleAxisDiscreteTicks, polarTicks, reactAttributeTransform, registerArcDataLabel, registerLineDataLabel, registerMarkArcAreaAnimate, registerMarkArcLineAnimate, registerMarkAreaAnimate, registerMarkLineAnimate, registerMarkPointAnimate, registerRectDataLabel, registerSymbolDataLabel, removeRepeatPoint, richTextAttributeTransform, scale, scrollbarModule, setPoptipTheme, smartInvertStrategy, tan2AngleToAngle, textIntersect, ticks, traverseGroup, version };

package/es/brush/brush.d.ts

@@ -7,7 +7,7 @@ export declare class Brush extends AbstractComponent<Required<BrushAttributes>>
     static defaultAttributes: {
         trigger: string;
         updateTrigger: string;
-        endTrigger: string;
+        endTrigger: string[];
         resetTrigger: string;
         hasMask: boolean;
         brushMode: string;
@@ -44,7 +44,6 @@ export declare class Brush extends AbstractComponent<Required<BrushAttributes>>
     private _brushMaskAABBBoundsDict;
     constructor(attributes: BrushAttributes, options?: ComponentOptions);
     private _bindBrushEvents;
-    private _isPosInBrushMask;
     private _onBrushStart;
     private _onBrushing;
     private _onBrushingWithDelay;
@@ -54,13 +53,17 @@ export declare class Brush extends AbstractComponent<Required<BrushAttributes>>
     private _initMove;
     private _drawing;
     private _moving;
+    protected render(): void;
+    releaseBrushEvents(): void;
     private _computeMaskPoints;
     private _addBrushMask;
+    private _isPosInBrushMask;
     private _outOfInteractiveRange;
     protected eventPosToStagePos(e: FederatedPointerEvent): {
         x: number;
         y: number;
     };
-    protected render(): void;
-    releaseBrushEvents(): void;
+    private _dispatchBrushEvent;
+    private _clearMask;
+    private _isEmptyMask;
 }