@visactor/vrender-components 0.22.7-alpha.9 → 0.22.8-alpha.0

package/dist/index.es.js

@@ -29720,13 +29720,14 @@ var IOperateType;
     IOperateType["moving"] = "moving";
     IOperateType["moveStart"] = "moveStart";
     IOperateType["moveEnd"] = "moveEnd";
+    IOperateType["brushActive"] = "brushActive";
     IOperateType["brushClear"] = "brushClear";
 })(IOperateType || (IOperateType = {}));
 
 const DEFAULT_BRUSH_ATTRIBUTES = {
     trigger: 'pointerdown',
     updateTrigger: 'pointermove',
-    endTrigger: 'pointerup',
+    endTrigger: ['pointerup', 'pointerleave'],
     resetTrigger: 'pointerupoutside',
     hasMask: true,
     brushMode: 'single',
@@ -29742,10 +29743,10 @@ const DEFAULT_BRUSH_ATTRIBUTES = {
     delayType: 'throttle',
     delayTime: 10,
     interactiveRange: {
-        y1: -Infinity,
-        y2: Infinity,
-        x1: -Infinity,
-        x2: Infinity
+        minY: -Infinity,
+        maxY: Infinity,
+        minX: -Infinity,
+        maxX: Infinity
     }
 };
 const DEFAULT_SIZE_THRESHOLD = 5;
@@ -29766,145 +29767,86 @@ class Brush extends AbstractComponent {
         this.name = 'brush';
         this._activeDrawState = false;
         this._cacheDrawPoints = [];
-        this._isDrawedBeforeEnd = false;
-        this._isDownBeforeUpOutside = false;
         this._activeMoveState = false;
         this._operatingMaskMoveDx = 0;
         this._operatingMaskMoveDy = 0;
         this._operatingMaskMoveRangeX = [-Infinity, Infinity];
         this._operatingMaskMoveRangeY = [-Infinity, Infinity];
         this._brushMaskAABBBoundsDict = {};
+        this._firstUpdate = true;
         this._onBrushStart = (e) => {
-            var _a;
             if (this._outOfInteractiveRange(e)) {
-                this._isDownBeforeUpOutside = true;
+                if (!this._isEmptyMask()) {
+                    this._clearMask();
+                    this._dispatchBrushEvent(IOperateType.brushClear, e);
+                }
                 return;
             }
+            const { updateTrigger = DEFAULT_BRUSH_ATTRIBUTES.updateTrigger, endTrigger = DEFAULT_BRUSH_ATTRIBUTES.endTrigger, brushMoved = true } = this.attribute;
+            array(updateTrigger).forEach(t => this.stage.addEventListener(t, this._onBrushingWithDelay));
+            array(endTrigger).forEach(t => this.stage.addEventListener(t, this._onBrushEnd));
             e.stopPropagation();
-            const brushMoved = (_a = this.attribute.brushMoved) !== null && _a !== void 0 ? _a : true;
+            this._firstUpdate = true;
             this._activeMoveState = brushMoved && this._isPosInBrushMask(e);
             this._activeDrawState = !this._activeMoveState;
-            this._activeDrawState && this._initDraw(e);
-            this._activeMoveState && this._initMove(e);
+            this._startPos = this.eventPosToStagePos(e);
         };
         this._onBrushing = (e) => {
             if (this._outOfInteractiveRange(e)) {
                 return;
             }
-            if (this._activeDrawState || this._activeMoveState) {
-                e.stopPropagation();
+            e.stopPropagation();
+            if (this._firstUpdate) {
+                this._activeDrawState && this._initDraw(e);
+                this._activeMoveState && this._initMove(e);
+                this._firstUpdate = false;
+            }
+            else {
+                this._activeDrawState && this._drawing(e);
+                this._activeMoveState && this._moving(e);
             }
-            this._activeDrawState && this._drawing(e);
-            this._activeMoveState && this._moving(e);
         };
         this._onBrushingWithDelay = this.attribute.delayTime === 0
             ? this._onBrushing
             : delayMap[this.attribute.delayType](this._onBrushing, this.attribute.delayTime);
         this._onBrushEnd = (e) => {
-            var _a;
-            if (!this._activeDrawState && !this._activeMoveState) {
-                return;
-            }
+            this._releaseBrushUpdateEvents();
             e.preventDefault();
-            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
-                    });
-                }
-                this._container.incrementalClearChild();
-                this._brushMaskAABBBoundsDict = {};
-            }
-            else {
-                if (this._activeDrawState) {
-                    this._dispatchEvent(IOperateType.drawEnd, {
-                        operateMask: this._operatingMask,
-                        operatedMaskAABBBounds: this._brushMaskAABBBoundsDict,
-                        event: e
-                    });
-                }
-                if (this._activeMoveState) {
-                    this._dispatchEvent(IOperateType.moveEnd, {
-                        operateMask: this._operatingMask,
-                        operatedMaskAABBBounds: this._brushMaskAABBBoundsDict,
-                        event: e
-                    });
-                }
-            }
+            this._activeDrawState && this._drawEnd(e);
+            this._activeMoveState && this._moveEnd(e);
             this._activeDrawState = false;
             this._activeMoveState = false;
-            this._isDrawedBeforeEnd = false;
-            if (this._operatingMask) {
-                this._operatingMask.setAttribute('pickable', false);
-            }
         };
         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() {
+        this.releaseBrushEvents();
         if (this.attribute.disableTriggerEvent) {
             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(updateTrigger).forEach(t => this.stage.addEventListener(t, this._onBrushingWithDelay));
-        array(endTrigger).forEach(t => this.stage.addEventListener(t, this._onBrushEnd));
+        const { trigger = DEFAULT_BRUSH_ATTRIBUTES.trigger, resetTrigger = DEFAULT_BRUSH_ATTRIBUTES.resetTrigger } = this
+            .attribute;
+        array(trigger).forEach(t => this.stage.addEventListener(t, this._onBrushStart));
         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);
+        if (Object.keys(this._brushMaskAABBBoundsDict).length === 1) {
+            this._dispatchBrushEvent(IOperateType.brushActive, e);
+        }
     }
     _initMove(e) {
         var _a, _b;
@@ -29921,16 +29863,12 @@ 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;
+        var _a;
         const pos = this.eventPosToStagePos(e);
-        const { sizeThreshold = DEFAULT_SIZE_THRESHOLD, brushType } = this.attribute;
+        const { brushType } = this.attribute;
         const cacheLength = this._cacheDrawPoints.length;
         if (cacheLength > 0) {
             const lastPos = (_a = this._cacheDrawPoints[this._cacheDrawPoints.length - 1]) !== null && _a !== void 0 ? _a : {};
@@ -29946,18 +29884,7 @@ class Brush extends AbstractComponent {
         }
         const maskPoints = this._computeMaskPoints();
         this._operatingMask.setAttribute('points', maskPoints);
-        const { x1 = 0, x2 = 0, y1 = 0, y2 = 0 } = (_b = this._operatingMask) === null || _b === void 0 ? void 0 : _b._AABBBounds;
-        this._isDrawedBeforeEnd =
-            !this._operatingMask._AABBBounds.empty() &&
-                !!(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;
@@ -29976,11 +29903,61 @@ 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);
+    }
+    _drawEnd(e) {
+        const { removeOnClick = true, sizeThreshold = DEFAULT_SIZE_THRESHOLD } = this.attribute;
+        if (this._outOfInteractiveRange(e)) {
+            if (!this._isEmptyMask()) {
+                this._clearMask();
+                this._dispatchBrushEvent(IOperateType.brushClear, e);
+            }
+        }
+        else {
+            const { x: x1, y: y1 } = this._startPos;
+            const { x: x2, y: y2 } = this.eventPosToStagePos(e);
+            if (Math.abs(x2 - x1) <= 1 && Math.abs(y2 - y1) <= 1 && removeOnClick) {
+                if (!this._isEmptyMask()) {
+                    this._clearMask();
+                    this._dispatchBrushEvent(IOperateType.brushClear, e);
+                }
+            }
+            else if (Math.abs(x2 - x1) < sizeThreshold && Math.abs(y1 - y2) < sizeThreshold) {
+                delete this._brushMaskAABBBoundsDict[this._operatingMask.name];
+                this._container.setAttributes({});
+                this._container.removeChild(this._operatingMask);
+                if (this._isEmptyMask()) {
+                    this._dispatchBrushEvent(IOperateType.brushClear, e);
+                }
+            }
+            else {
+                this._brushMaskAABBBoundsDict[this._operatingMask.name] = this._operatingMask.AABBBounds;
+                this._dispatchBrushEvent(IOperateType.drawEnd, e);
+            }
+        }
+    }
+    _moveEnd(e) {
+        if (this._operatingMask) {
+            this._operatingMask.setAttribute('pickable', false);
+        }
+        this._dispatchBrushEvent(IOperateType.moveEnd, e);
+    }
+    render() {
+        this._bindBrushEvents();
+        const group = this.createOrUpdateChild('brush-container', {}, 'group');
+        this._container = group;
+    }
+    releaseBrushEvents() {
+        const { trigger = DEFAULT_BRUSH_ATTRIBUTES.trigger, resetTrigger = DEFAULT_BRUSH_ATTRIBUTES.resetTrigger } = this
+            .attribute;
+        array(trigger).forEach(t => this.stage.removeEventListener(t, this._onBrushStart));
+        array(resetTrigger).forEach(t => this.stage.removeEventListener(t, this._onBrushClear));
+        this._releaseBrushUpdateEvents();
+    }
+    _releaseBrushUpdateEvents() {
+        const { updateTrigger = DEFAULT_BRUSH_ATTRIBUTES.updateTrigger, endTrigger = DEFAULT_BRUSH_ATTRIBUTES.endTrigger } = this.attribute;
+        array(updateTrigger).forEach(t => this.stage.removeEventListener(t, this._onBrushingWithDelay));
+        array(endTrigger).forEach(t => this.stage.removeEventListener(t, this._onBrushEnd));
     }
     _computeMaskPoints() {
         const { brushType, xRange = [0, 0], yRange = [0, 0] } = this.attribute;
@@ -30049,12 +30026,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;
@@ -30067,17 +30062,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;
@@ -31620,6 +31619,6 @@ StoryLabelItem.defaultAttributes = {
     theme: 'default'
 };
 
-const version = "0.22.7-alpha.9";
+const version = "0.22.8-alpha.0";
 
 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/axis/util.js

@@ -98,5 +98,4 @@ export function hasOverlap(items, pad) {
     for (let b, i = 1, n = items.length, a = items[0]; i < n; a = b, ++i) if (b = items[i], 
     textIntersect(a, b, pad)) return !0;
     return !1;
-}
-//# sourceMappingURL=util.js.map
+}

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;
@@ -23,17 +23,15 @@ export declare class Brush extends AbstractComponent<Required<BrushAttributes>>
         delayType: string;
         delayTime: number;
         interactiveRange: {
-            y1: number;
-            y2: number;
-            x1: number;
-            x2: number;
+            minY: number;
+            maxY: number;
+            minX: number;
+            maxX: number;
         };
     };
     private _container;
     private _activeDrawState;
     private _cacheDrawPoints;
-    private _isDrawedBeforeEnd;
-    private _isDownBeforeUpOutside;
     private _activeMoveState;
     private _operatingMaskMoveDx;
     private _operatingMaskMoveDy;
@@ -42,9 +40,10 @@ export declare class Brush extends AbstractComponent<Required<BrushAttributes>>
     private _cacheMovePoint;
     private _operatingMask;
     private _brushMaskAABBBoundsDict;
+    private _firstUpdate;
+    private _startPos;
     constructor(attributes: BrushAttributes, options?: ComponentOptions);
     private _bindBrushEvents;
-    private _isPosInBrushMask;
     private _onBrushStart;
     private _onBrushing;
     private _onBrushingWithDelay;
@@ -54,13 +53,20 @@ export declare class Brush extends AbstractComponent<Required<BrushAttributes>>
     private _initMove;
     private _drawing;
     private _moving;
+    private _drawEnd;
+    private _moveEnd;
+    protected render(): void;
+    releaseBrushEvents(): void;
+    private _releaseBrushUpdateEvents;
     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;
 }