@visactor/vrender-core 1.1.11 → 1.1.13

package/es/event/event-manager.d.ts

@@ -3,6 +3,16 @@ import type { IEventTarget } from '../interface/event';
 import type { FederatedEvent } from './federated-event/base-event';
 import type { Cursor } from '../interface';
 type TrackingData = {
+    generation: number;
+    inside: boolean;
+    previousInside: boolean;
+    ending?: IEventTarget[];
+    pointerType: string;
+    button: number;
+    canvasX: number;
+    canvasY: number;
+    viewX: number;
+    viewY: number;
     pressTargetsByButton: {
         [id: number]: IEventTarget[];
     };
@@ -34,9 +44,27 @@ export declare class EventManager {
     private _prePointTargetCache;
     private _config;
     constructor(root: IEventTarget, config: EventManagerConfig);
+    private readonly canvasInput;
+    private readonly windowInput;
+    readonly input: {
+        canvas: import("../interface").InputEventSource;
+        window: import("../interface").InputEventSource;
+    };
+    private currentTracking?;
+    private currentGeneration;
+    private terminalDepth;
+    private dispatchingEvent?;
+    private inputValid;
+    hasPointer(id: number): boolean;
+    cancelAllPointers(): void;
+    cancelPointer(id: number): void;
+    private emitBoundary;
+    private emitInput;
+    private emitPointerInput;
+    protected onPointerCancel: (from: FederatedEvent) => void;
     addEventMapping(type: string, fn: (e: FederatedEvent, target: IEventTarget) => void): void;
     dispatchEvent(e: FederatedEvent, type?: string): void;
-    mapEvent(e: FederatedEvent): void;
+    mapEvent(e: FederatedEvent, inViewport?: boolean): void;
     propagate(e: FederatedEvent, type?: string): void;
     propagationPath(target: IEventTarget): IEventTarget[];
     protected notifyTarget(e: FederatedEvent, type?: string): void;

package/es/event/event-manager.js

@@ -1,3 +1,5 @@
+import { InputSource } from "./input-source";
+
 import { EventEmitter, Logger } from "@visactor/vutils";
 
 import { FederatedMouseEvent, FederatedPointerEvent, FederatedWheelEvent } from "./federated-event";
@@ -12,21 +14,36 @@ function isMouseLike(pointerType) {
     return "mouse" === pointerType || "pen" === pointerType;
 }
 
-const DEFAULT_CLICK_INTERVAL = 200;
+const DEFAULT_CLICK_INTERVAL = 200, TOUCH_INPUT_TYPES = {
+    pointerdown: "touchstart",
+    pointermove: "touchmove",
+    pointerup: "touchend"
+}, MOUSE_INPUT_TYPES = {
+    pointerdown: "mousedown",
+    pointermove: "mousemove",
+    pointerup: "mouseup"
+};
 
 export class EventManager {
     constructor(root, config) {
         this.dispatch = new EventEmitter, this.cursorTarget = null, this.pauseNotify = !1, 
         this.mappingState = {
             trackingData: {}
-        }, this.eventPool = new Map, this.onPointerDown = (from, target) => {
+        }, this.eventPool = new Map, this.canvasInput = new InputSource, this.windowInput = new InputSource, 
+        this.input = {
+            canvas: this.canvasInput.source,
+            window: this.windowInput.source
+        }, this.currentGeneration = 0, this.terminalDepth = 0, this.inputValid = () => !!this.rootTarget && (this.terminalDepth > 0 || !this.currentTracking || this.currentTracking.generation === this.currentGeneration), 
+        this.onPointerCancel = from => {
+            from instanceof FederatedPointerEvent && this.cancelPointer(from.pointerId);
+        }, this.onPointerDown = (from, target) => {
             if (!(from instanceof FederatedPointerEvent)) return void Logger.getInstance().warn("EventManager cannot map a non-pointer event as a pointer event");
             const e = this.createPointerEvent(from, from.type, target);
-            if (this.dispatchEvent(e, "pointerdown"), "touch" === e.pointerType) this.dispatchEvent(e, "touchstart"); else if (isMouseLike(e.pointerType)) {
+            if (this.trackingData(from.pointerId).pressTargetsByButton[from.button] = e.composedPath(), 
+            this.dispatchEvent(e, "pointerdown"), "touch" === e.pointerType) this.dispatchEvent(e, "touchstart"); else if (isMouseLike(e.pointerType)) {
                 const isRightButton = 2 === e.button;
                 this.dispatchEvent(e, isRightButton ? "rightdown" : "mousedown");
             }
-            this.trackingData(from.pointerId).pressTargetsByButton[from.button] = e.composedPath(), 
             this.freeEvent(e);
         }, this.onPointerMove = (from, target) => {
             var _a, _b;
@@ -48,8 +65,8 @@ export class EventManager {
                 const overType = "mousemove" === from.type ? "mouseover" : "pointerover", overEvent = this.clonePointerEvent(e, overType);
                 this.dispatchEvent(overEvent, "pointerover"), isMouse && this.dispatchEvent(overEvent, "mouseover");
                 let overTargetAncestor = null == outTarget ? void 0 : outTarget.parent;
-                for (;overTargetAncestor && overTargetAncestor !== this.rootTarget.parent && overTargetAncestor !== e.target; ) overTargetAncestor = overTargetAncestor.parent;
-                if (!overTargetAncestor || overTargetAncestor === this.rootTarget.parent) {
+                for (;this.inputValid() && overTargetAncestor && overTargetAncestor !== this.rootTarget.parent && overTargetAncestor !== e.target; ) overTargetAncestor = overTargetAncestor.parent;
+                if (this.inputValid() && (!overTargetAncestor || overTargetAncestor === this.rootTarget.parent)) {
                     const enterEvent = this.clonePointerEvent(e, "pointerenter");
                     enterEvent.eventPhase = enterEvent.AT_TARGET;
                     let currentTarget = enterEvent.target;
@@ -57,7 +74,7 @@ export class EventManager {
                     let ancestor = outTarget;
                     for (;ancestor && ancestor !== this.rootTarget; ) outTargetAncestors.add(ancestor), 
                     ancestor = ancestor.parent;
-                    for (;currentTarget && currentTarget !== outTarget && currentTarget !== this.rootTarget.parent; ) outTargetAncestors.has(currentTarget) || (enterEvent.currentTarget = currentTarget, 
+                    for (;this.inputValid() && currentTarget && currentTarget !== outTarget && currentTarget !== this.rootTarget.parent; ) outTargetAncestors.has(currentTarget) || (enterEvent.currentTarget = currentTarget, 
                     this.notifyTarget(enterEvent), isMouse && this.notifyTarget(enterEvent, "mouseenter")), 
                     currentTarget = currentTarget.parent;
                     this.freeEvent(enterEvent);
@@ -65,19 +82,22 @@ export class EventManager {
                 this.freeEvent(overEvent);
             }
             this.dispatchEvent(e, "pointermove"), "touch" === e.pointerType && this.dispatchEvent(e, "touchmove"), 
-            isMouse && (this.dispatchEvent(e, "mousemove"), this.cursorTarget = e.target, this.cursor = (null === (_b = null === (_a = e.target) || void 0 === _a ? void 0 : _a.attribute) || void 0 === _b ? void 0 : _b.cursor) || this.rootTarget.getCursor()), 
-            trackingData.overTargets = e.composedPath(), this.freeEvent(e);
+            isMouse && this.inputValid() && (this.dispatchEvent(e, "mousemove"), this.cursorTarget = e.target, 
+            this.cursor = (null === (_b = null === (_a = e.target) || void 0 === _a ? void 0 : _a.attribute) || void 0 === _b ? void 0 : _b.cursor) || this.rootTarget.getCursor()), 
+            this.inputValid() && (trackingData.overTargets = e.composedPath()), this.freeEvent(e);
         }, this.onPointerOver = (from, target) => {
             var _a, _b;
             if (!(from instanceof FederatedPointerEvent)) return void Logger.getInstance().warn("EventManager cannot map a non-pointer event as a pointer event");
             const trackingData = this.trackingData(from.pointerId), e = this.createPointerEvent(from, from.type, target), isMouse = isMouseLike(e.pointerType);
             this.dispatchEvent(e, "pointerover"), isMouse && this.dispatchEvent(e, "mouseover"), 
-            "mouse" === e.pointerType && (this.cursorTarget = e.target, this.cursor = (null === (_b = null === (_a = e.target) || void 0 === _a ? void 0 : _a.attribute) || void 0 === _b ? void 0 : _b.cursor) || this.rootTarget.getCursor());
+            "mouse" === e.pointerType && this.inputValid() && (this.cursorTarget = e.target, 
+            this.cursor = (null === (_b = null === (_a = e.target) || void 0 === _a ? void 0 : _a.attribute) || void 0 === _b ? void 0 : _b.cursor) || this.rootTarget.getCursor());
             const enterEvent = this.clonePointerEvent(e, "pointerenter");
-            for (enterEvent.eventPhase = enterEvent.AT_TARGET; enterEvent.target && enterEvent.target !== this.rootTarget.parent; ) enterEvent.currentTarget = enterEvent.target, 
+            for (enterEvent.eventPhase = enterEvent.AT_TARGET; this.inputValid() && enterEvent.target && enterEvent.target !== this.rootTarget.parent; ) enterEvent.currentTarget = enterEvent.target, 
             this.notifyTarget(enterEvent), isMouse && this.notifyTarget(enterEvent, "mouseenter"), 
             enterEvent.target = enterEvent.target.parent;
-            trackingData.overTargets = e.composedPath(), this.freeEvent(e), this.freeEvent(enterEvent);
+            this.inputValid() && (trackingData.overTargets = e.composedPath()), this.freeEvent(e), 
+            this.freeEvent(enterEvent);
         }, this.onPointerOut = (from, target) => {
             if (!(from instanceof FederatedPointerEvent)) return void Logger.getInstance().warn("EventManager cannot map a non-pointer event as a pointer event");
             const trackingData = this.trackingData(from.pointerId);
@@ -85,7 +105,7 @@ export class EventManager {
                 const isMouse = isMouseLike(from.pointerType), outTarget = this.findMountedTarget(trackingData.overTargets), outEvent = this.createPointerEvent(from, "pointerout", outTarget || void 0);
                 this.dispatchEvent(outEvent), isMouse && this.dispatchEvent(outEvent, "mouseout");
                 const leaveEvent = this.createPointerEvent(from, "pointerleave", outTarget || void 0);
-                for (leaveEvent.eventPhase = leaveEvent.AT_TARGET; leaveEvent.target && leaveEvent.target !== this.rootTarget.parent; ) leaveEvent.currentTarget = leaveEvent.target, 
+                for (leaveEvent.eventPhase = leaveEvent.AT_TARGET; this.inputValid() && leaveEvent.target && leaveEvent.target !== this.rootTarget.parent; ) leaveEvent.currentTarget = leaveEvent.target, 
                 this.notifyTarget(leaveEvent), isMouse && this.notifyTarget(leaveEvent, "mouseleave"), 
                 leaveEvent.target = leaveEvent.target.parent;
                 trackingData.overTargets = [], this.freeEvent(outEvent), this.freeEvent(leaveEvent);
@@ -94,12 +114,13 @@ export class EventManager {
         }, this.onPointerUp = (from, target) => {
             var _a;
             if (!(from instanceof FederatedPointerEvent)) return void Logger.getInstance().warn("EventManager cannot map a non-pointer event as a pointer event");
-            const now = clock.now(), e = this.createPointerEvent(from, from.type, target);
-            if (this.dispatchEvent(e, "pointerup"), "touch" === e.pointerType) this.dispatchEvent(e, "touchend"); else if (isMouseLike(e.pointerType)) {
+            const now = clock.now(), e = this.createPointerEvent(from, from.type, target), trackingData = this.trackingData(from.pointerId);
+            if (trackingData.ending = trackingData.pressTargetsByButton[from.button], delete trackingData.pressTargetsByButton[from.button], 
+            this.dispatchEvent(e, "pointerup"), "touch" === e.pointerType) this.dispatchEvent(e, "touchend"); else if (isMouseLike(e.pointerType)) {
                 const isRightButton = 2 === e.button;
                 this.dispatchEvent(e, isRightButton ? "rightup" : "mouseup");
             }
-            const trackingData = this.trackingData(from.pointerId), pressTarget = this.findMountedTarget(trackingData.pressTargetsByButton[from.button]);
+            const pressTarget = this.findMountedTarget(trackingData.ending);
             let clickTarget = pressTarget;
             if (pressTarget && !e.composedPath().includes(pressTarget)) {
                 let currentTarget = pressTarget;
@@ -112,7 +133,7 @@ export class EventManager {
                 }
                 delete trackingData.pressTargetsByButton[from.button], clickTarget = currentTarget;
             }
-            if (clickTarget) {
+            if (this.emitPointerInput(e, "pointerup"), clickTarget && this.inputValid()) {
                 const clickEvent = this.clonePointerEvent(e, "click");
                 clickEvent.target = clickTarget, clickEvent.path = [], clickEvent.detailPath = [], 
                 trackingData.clicksByButton[from.button] || (trackingData.clicksByButton[from.button] = {
@@ -124,14 +145,18 @@ export class EventManager {
                 clickHistory.target === clickEvent.target && now - clickHistory.timeStamp < (null !== (_a = this._config.clickInterval) && void 0 !== _a ? _a : 200) ? ++clickHistory.clickCount : clickHistory.clickCount = 1, 
                 clickHistory.target = clickEvent.target, clickHistory.timeStamp = now, clickEvent.detail = clickHistory.clickCount, 
                 isMouseLike(clickEvent.pointerType) ? (this.dispatchEvent(clickEvent, "click"), 
-                2 === clickHistory.clickCount && this.dispatchEvent(clickEvent, "dblclick")) : "touch" === clickEvent.pointerType && this._config.supportsTouchEvents && (this.dispatchEvent(clickEvent, "tap"), 
-                2 === clickHistory.clickCount && this.dispatchEvent(clickEvent, "dbltap")), this.dispatchEvent(clickEvent, "pointertap"), 
-                this.freeEvent(clickEvent);
+                this.emitInput(clickEvent, "click"), 2 === clickHistory.clickCount && (this.dispatchEvent(clickEvent, "dblclick"), 
+                this.emitInput(clickEvent, "dblclick"))) : "touch" === clickEvent.pointerType && this._config.supportsTouchEvents && (this.dispatchEvent(clickEvent, "tap"), 
+                this.emitInput(clickEvent, "tap"), 2 === clickHistory.clickCount && (this.dispatchEvent(clickEvent, "dbltap"), 
+                this.emitInput(clickEvent, "dbltap"))), this.dispatchEvent(clickEvent, "pointertap"), 
+                this.emitInput(clickEvent, "pointertap"), this.freeEvent(clickEvent);
             }
             this.freeEvent(e);
         }, this.onPointerUpOutside = (from, target) => {
             if (!(from instanceof FederatedPointerEvent)) return void Logger.getInstance().warn("EventManager cannot map a non-pointer event as a pointer event");
-            const trackingData = this.trackingData(from.pointerId), pressTarget = this.findMountedTarget(trackingData.pressTargetsByButton[from.button]), e = this.createPointerEvent(from, from.type, target);
+            const trackingData = this.trackingData(from.pointerId);
+            trackingData.ending = trackingData.pressTargetsByButton[from.button], delete trackingData.pressTargetsByButton[from.button];
+            const pressTarget = this.findMountedTarget(trackingData.ending), e = this.createPointerEvent(from, from.type, target);
             if (pressTarget) {
                 let currentTarget = pressTarget;
                 for (;currentTarget; ) e.currentTarget = currentTarget, this.notifyTarget(e, "pointerupoutside"), 
@@ -139,7 +164,7 @@ export class EventManager {
                 currentTarget = currentTarget.parent;
                 delete trackingData.pressTargetsByButton[from.button];
             }
-            this.freeEvent(e);
+            this.emitPointerInput(e, "pointerup"), this.freeEvent(e);
         }, this.onWheel = (from, target) => {
             if (!(from instanceof FederatedWheelEvent)) return void Logger.getInstance().warn("EventManager cannot map a non-wheel event as a wheel event");
             const wheelEvent = this.createWheelEvent(from, target);
@@ -149,7 +174,76 @@ export class EventManager {
         }, config), this.addEventMapping("pointerdown", this.onPointerDown), this.addEventMapping("pointermove", this.onPointerMove), 
         this.addEventMapping("pointerout", this.onPointerOut), this.addEventMapping("pointerleave", this.onPointerOut), 
         this.addEventMapping("pointerover", this.onPointerOver), this.addEventMapping("pointerup", this.onPointerUp), 
-        this.addEventMapping("pointerupoutside", this.onPointerUpOutside), this.addEventMapping("wheel", this.onWheel);
+        this.addEventMapping("pointerupoutside", this.onPointerUpOutside), this.addEventMapping("pointercancel", this.onPointerCancel), 
+        this.addEventMapping("wheel", this.onWheel);
+    }
+    hasPointer(id) {
+        const data = this.mappingState.trackingData[id];
+        if (!data) return !1;
+        if (data.inside || data.ending) return !0;
+        for (const button in data.pressTargetsByButton) if (data.pressTargetsByButton[button]) return !0;
+        return !1;
+    }
+    cancelAllPointers() {
+        for (const id in this.mappingState.trackingData) this.cancelPointer(Number(id));
+    }
+    cancelPointer(id) {
+        var _a;
+        if (!this.rootTarget || !this.hasPointer(id)) return;
+        const data = this.trackingData(id);
+        let press = data.ending;
+        for (const button in data.pressTargetsByButton) {
+            press = data.pressTargetsByButton[button];
+            break;
+        }
+        const over = data.overTargets, inside = data.inside;
+        data.generation++, data.pressTargetsByButton = {}, data.clicksByButton = {}, data.ending = void 0, 
+        data.inside = !1, data.overTargets = [], this.dispatchingEvent instanceof FederatedPointerEvent && this.dispatchingEvent.pointerId === id && this.dispatchingEvent.stopImmediatePropagation();
+        const event = this.allocateEvent(FederatedPointerEvent);
+        event.type = "pointercancel", event.pointerId = id, event.pointerType = data.pointerType, 
+        event.button = data.button, event.nativeEvent = null, event.canvas.x = data.canvasX, 
+        event.canvas.y = data.canvasY, event.viewport.x = data.viewX, event.viewport.y = data.viewY, 
+        event.target = null !== (_a = this.findMountedTarget(press)) && void 0 !== _a ? _a : this.findMountedTarget(over), 
+        this.terminalDepth++;
+        try {
+            if (this.dispatchEvent(event), "touch" === event.pointerType && this.dispatchEvent(event, "touchcancel"), 
+            this.windowInput.emit("pointercancel", event, this.inputValid), "touch" === event.pointerType && this.windowInput.emit("touchcancel", event, this.inputValid), 
+            inside && (this.canvasInput.emit("pointercancel", event, this.inputValid), "touch" === event.pointerType && this.canvasInput.emit("touchcancel", event, this.inputValid), 
+            this.emitBoundary(event, !1)), (null == over ? void 0 : over.length) && this.rootTarget) for (event.target = this.findMountedTarget(over), 
+            event.path = [], this.dispatchEvent(event, "pointerout"), isMouseLike(event.pointerType) && this.dispatchEvent(event, "mouseout"), 
+            event.eventPhase = event.AT_TARGET; event.target && this.rootTarget; ) event.currentTarget = event.target, 
+            this.notifyTarget(event, "pointerleave"), isMouseLike(event.pointerType) && this.notifyTarget(event, "mouseleave"), 
+            event.target = event.target.parent;
+        } finally {
+            this.terminalDepth--, this.freeEvent(event), this.cursorTarget = null, this.cursor = "";
+        }
+    }
+    emitBoundary(event, inside) {
+        this.canvasInput.emit(inside ? "pointerover" : "pointerout", event, this.inputValid), 
+        this.canvasInput.emit(inside ? "pointerenter" : "pointerleave", event, this.inputValid), 
+        isMouseLike(event.pointerType) && (this.canvasInput.emit(inside ? "mouseover" : "mouseout", event, this.inputValid), 
+        this.canvasInput.emit(inside ? "mouseenter" : "mouseleave", event, this.inputValid));
+    }
+    emitInput(event, type = event.type) {
+        if (!this.inputValid()) return;
+        if (this.windowInput.emit(type, event, this.inputValid), !this.inputValid()) return;
+        const data = event instanceof FederatedPointerEvent ? this.trackingData(event.pointerId) : void 0;
+        data && data.previousInside !== data.inside && (data.previousInside = data.inside, 
+        this.emitBoundary(event, data.inside)), data && !data.inside || this.canvasInput.emit(type, event, this.inputValid);
+    }
+    emitPointerInput(event, type = event.type) {
+        if (this.inputValid()) if ("pointerover" !== type && "pointerout" !== type && "pointerleave" !== type) {
+            if (this.emitInput(event, type), "touch" === event.pointerType) {
+                const alias = TOUCH_INPUT_TYPES[type];
+                alias && this.emitInput(event, alias);
+            } else if (isMouseLike(event.pointerType)) {
+                const alias = 2 === event.button && "pointerdown" === type ? "rightdown" : 2 === event.button && "pointerup" === type ? "rightup" : MOUSE_INPUT_TYPES[type];
+                alias && this.emitInput(event, alias);
+            }
+        } else {
+            const data = this.trackingData(event.pointerId);
+            data.previousInside !== data.inside && (data.previousInside = data.inside, this.emitBoundary(event, data.inside));
+        }
     }
     addEventMapping(type, fn) {
         this.mappingTable[type] || (this.mappingTable[type] = []), this.mappingTable[type].push({
@@ -158,20 +252,36 @@ export class EventManager {
         }), this.mappingTable[type].sort(((a, b) => a.priority - b.priority));
     }
     dispatchEvent(e, type) {
-        e.propagationStopped = !1, e.propagationImmediatelyStopped = !1, this.propagate(e, type), 
-        this.dispatch.emit(type || e.type, e);
+        if (!this.inputValid()) return;
+        const previous = this.dispatchingEvent;
+        this.dispatchingEvent = e, e.propagationStopped = !1, e.propagationImmediatelyStopped = !1;
+        try {
+            this.propagate(e, type), this.inputValid() && this.dispatch.emit(type || e.type, e);
+        } finally {
+            this.dispatchingEvent = previous;
+        }
     }
-    mapEvent(e) {
-        var _a, _b, _c, _d, _e, _f, _g;
+    mapEvent(e, inViewport = !0) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
         if (!this.rootTarget) return;
-        const mappers = this.mappingTable[e.type];
-        let target;
-        const cacheKey = `${e.canvasX}-${e.canvasY}`;
-        if ((null === (_a = this._prePointTargetCache) || void 0 === _a ? void 0 : _a[cacheKey]) && (null === (_c = null === (_b = this._prePointTargetCache) || void 0 === _b ? void 0 : _b[cacheKey]) || void 0 === _c ? void 0 : _c.stage) && (null === (_e = null === (_d = this._prePointTargetCache) || void 0 === _d ? void 0 : _d[cacheKey]) || void 0 === _e ? void 0 : _e.stage.renderCount) === (null === (_f = this._prePointTargetCache) || void 0 === _f ? void 0 : _f.stageRenderCount) ? target = this._prePointTargetCache[cacheKey] : (target = this.pickTarget(e.viewX, e.viewY, e), 
-        e.pickParams || (this._prePointTargetCache = {
-            [cacheKey]: target,
-            stageRenderCount: null !== (_g = null == target ? void 0 : target.stage.renderCount) && void 0 !== _g ? _g : -1
-        })), mappers) for (let i = 0, j = mappers.length; i < j; i++) mappers[i].fn(e, target); else Logger.getInstance().warn(`[EventManager]: Event mapping not defined for ${e.type}`);
+        const previous = this.currentTracking, generation = this.currentGeneration, tracking = e instanceof FederatedPointerEvent ? this.trackingData(e.pointerId) : void 0;
+        this.currentTracking = tracking, this.currentGeneration = null !== (_a = null == tracking ? void 0 : tracking.generation) && void 0 !== _a ? _a : 0, 
+        tracking && (tracking.previousInside = tracking.inside, tracking.inside = inViewport, 
+        tracking.pointerType = e.pointerType, tracking.button = e.button, tracking.canvasX = e.canvasX, 
+        tracking.canvasY = e.canvasY, tracking.viewX = e.viewX, tracking.viewY = e.viewY);
+        const type = "pointerup" !== e.type || inViewport ? e.type : "pointerupoutside", mappers = this.mappingTable[type];
+        try {
+            let target;
+            const cacheKey = `${e.canvasX}-${e.canvasY}`;
+            if (inViewport ? (null === (_b = this._prePointTargetCache) || void 0 === _b ? void 0 : _b[cacheKey]) && (null === (_d = null === (_c = this._prePointTargetCache) || void 0 === _c ? void 0 : _c[cacheKey]) || void 0 === _d ? void 0 : _d.stage) && (null === (_f = null === (_e = this._prePointTargetCache) || void 0 === _e ? void 0 : _e[cacheKey]) || void 0 === _f ? void 0 : _f.stage.renderCount) === (null === (_g = this._prePointTargetCache) || void 0 === _g ? void 0 : _g.stageRenderCount) ? target = this._prePointTargetCache[cacheKey] : (target = this.pickTarget(e.viewX, e.viewY, e), 
+            e.pickParams || (this._prePointTargetCache = {
+                [cacheKey]: target,
+                stageRenderCount: null !== (_h = null == target ? void 0 : target.stage.renderCount) && void 0 !== _h ? _h : -1
+            })) : target = null, mappers) for (let i = 0, j = mappers.length; i < j && this.inputValid(); i++) mappers[i].fn(e, target); else Logger.getInstance().warn(`[EventManager]: Event mapping not defined for ${e.type}`);
+            e instanceof FederatedPointerEvent && "pointerup" !== type && "pointerupoutside" !== type && "pointercancel" !== type ? this.emitPointerInput(e) : e instanceof FederatedWheelEvent && this.emitInput(e);
+        } finally {
+            tracking && (tracking.ending = void 0), this.currentTracking = previous, this.currentGeneration = generation;
+        }
     }
     propagate(e, type) {
         if (!e.target) return;
@@ -195,10 +305,11 @@ export class EventManager {
         return propagationPath.reverse(), propagationPath;
     }
     notifyTarget(e, type) {
+        if (!this.inputValid()) return void e.stopImmediatePropagation();
         if (this.pauseNotify) return;
         type = null != type ? type : e.type;
         const key = e.eventPhase === e.CAPTURING_PHASE || e.eventPhase === e.AT_TARGET ? `${type}capture` : type;
-        this.notifyListeners(e, key), e.eventPhase === e.AT_TARGET && this.notifyListeners(e, type);
+        this.notifyListeners(e, key), e.eventPhase === e.AT_TARGET && this.inputValid() && !e.propagationImmediatelyStopped && this.notifyListeners(e, type);
     }
     findMountedTarget(propagationPath) {
         if (!propagationPath) return null;
@@ -210,7 +321,7 @@ export class EventManager {
         var _a, _b;
         const event = this.allocateEvent(FederatedPointerEvent);
         return this.copyPointerData(from, event), this.copyMouseData(from, event), this.copyData(from, event), 
-        event.nativeEvent = from.nativeEvent, event.originalEvent = from, event.target = target || this.pickTarget(null !== (_a = event.viewX) && void 0 !== _a ? _a : event.global.x, null !== (_b = event.viewY) && void 0 !== _b ? _b : event.global.y, event), 
+        event.nativeEvent = from.nativeEvent, event.originalEvent = from, event.target = void 0 !== target ? target : this.pickTarget(null !== (_a = event.viewX) && void 0 !== _a ? _a : event.global.x, null !== (_b = event.viewY) && void 0 !== _b ? _b : event.global.y, event), 
         "string" == typeof type && (event.type = type), event;
     }
     createWheelEvent(from, target) {
@@ -254,6 +365,9 @@ export class EventManager {
     }
     trackingData(id) {
         return this.mappingState.trackingData[id] || (this.mappingState.trackingData[id] = {
+            generation: 0,
+            inside: !1,
+            previousInside: !1,
             pressTargetsByButton: {},
             clicksByButton: {},
             overTarget: null
@@ -268,6 +382,7 @@ export class EventManager {
     }
     freeEvent(event) {
         var _a;
+        if (event.nativeEvent = null, event.originalEvent = null, !this.rootTarget) return;
         if (event.manager !== this) throw new Error("It is illegal to free an event not managed by this EventManager!");
         const constructor = event.constructor;
         this.eventPool.has(constructor) || (this.eventPool.get(constructor).forEach((e => {
@@ -276,17 +391,19 @@ export class EventManager {
         })), this.eventPool.set(constructor, [])), null === (_a = this.eventPool.get(constructor)) || void 0 === _a || _a.push(event);
     }
     notifyListeners(e, type) {
+        if (!this.inputValid() || !e.currentTarget) return;
         const listeners = e.currentTarget._events[type];
         if (listeners) if ("fn" in listeners) listeners.once && e.currentTarget.removeEventListener(type, listeners.fn, {
             once: !0
-        }), listeners.fn.call(listeners.context, e); else for (let i = 0, j = listeners.length; i < j && !e.propagationImmediatelyStopped; i++) listeners[i].once && e.currentTarget.removeEventListener(type, listeners[i].fn, {
+        }), listeners.fn.call(listeners.context, e); else for (let i = 0, j = listeners.length; i < j && this.inputValid() && !e.propagationImmediatelyStopped; i++) listeners[i].once && e.currentTarget.removeEventListener(type, listeners[i].fn, {
             once: !0
         }), listeners[i].fn.call(listeners[i].context, e);
-        this.emitDelegation(e, type);
+        this.inputValid() && this.emitDelegation(e, type);
     }
     emitDelegation(e, type) {
+        if (!this.inputValid() || !e.currentTarget) return;
         const listeners = e.currentTarget._events[WILDCARD];
-        if (listeners) if ("fn" in listeners) listeners.fn.call(listeners.context, e, type); else for (let i = 0, j = listeners.length; i < j && !e.propagationImmediatelyStopped; i++) listeners[i].fn.call(listeners[i].context, e, type);
+        if (listeners) if ("fn" in listeners) listeners.fn.call(listeners.context, e, type); else for (let i = 0, j = listeners.length; i < j && this.inputValid() && !e.propagationImmediatelyStopped; i++) listeners[i].fn.call(listeners[i].context, e, type);
     }
     pickTarget(x, y, e) {
         let target;
@@ -295,8 +412,12 @@ export class EventManager {
         e && (e.pickParams = pickResult.params), target;
     }
     release() {
+        var _a;
         this.dispatch.removeAllListeners(), this.eventPool.clear(), this.rootTarget = null, 
-        this.mappingTable = null, this.mappingState = null, this.cursorTarget = null;
+        this.mappingTable = null, this.mappingState = {
+            trackingData: {}
+        }, this.canvasInput.clear(), this.windowInput.clear(), null === (_a = this.dispatchingEvent) || void 0 === _a || _a.stopImmediatePropagation(), 
+        this.cursorTarget = null;
     }
 }
 //# sourceMappingURL=event-manager.js.map