@react-native-oh-tpl/react-native-gesture-handler 2.12.1-0.0.1

package/lib/module/web/tools/EventManager.js

@@ -0,0 +1,118 @@
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+/* eslint-disable @typescript-eslint/no-empty-function */
+export default class EventManager {
+  constructor(view) {
+    _defineProperty(this, "view", void 0);
+
+    _defineProperty(this, "pointersInBounds", []);
+
+    _defineProperty(this, "activePointersCounter", void 0);
+
+    this.view = view;
+    this.activePointersCounter = 0;
+  }
+
+  onPointerDown(_event) {}
+
+  onPointerAdd(_event) {}
+
+  onPointerUp(_event) {}
+
+  onPointerRemove(_event) {}
+
+  onPointerMove(_event) {}
+
+  onPointerLeave(_event) {} // called only when pointer is pressed (or touching)
+
+
+  onPointerEnter(_event) {} // called only when pointer is pressed (or touching)
+
+
+  onPointerCancel(_event) {// When pointer cancel is triggered and there are more pointers on the view, only one pointer is cancelled
+    // Because we want all pointers to be cancelled by that event, we are doing it manually by reseting handler and changing activePointersCounter to 0
+    // Events that correspond to removing the pointer (pointerup, touchend) have condition, that they don't perform any action when activePointersCounter
+    // is equal to 0. This prevents counter from going to negative values, when pointers are removed from view after one of them has been cancelled
+  }
+
+  onPointerOutOfBounds(_event) {}
+
+  onPointerMoveOver(_event) {}
+
+  onPointerMoveOut(_event) {}
+
+  setOnPointerDown(callback) {
+    this.onPointerDown = callback;
+  }
+
+  setOnPointerAdd(callback) {
+    this.onPointerAdd = callback;
+  }
+
+  setOnPointerUp(callback) {
+    this.onPointerUp = callback;
+  }
+
+  setOnPointerRemove(callback) {
+    this.onPointerRemove = callback;
+  }
+
+  setOnPointerMove(callback) {
+    this.onPointerMove = callback;
+  }
+
+  setOnPointerLeave(callback) {
+    this.onPointerLeave = callback;
+  }
+
+  setOnPointerEnter(callback) {
+    this.onPointerEnter = callback;
+  }
+
+  setOnPointerCancel(callback) {
+    this.onPointerCancel = callback;
+  }
+
+  setOnPointerOutOfBounds(callback) {
+    this.onPointerOutOfBounds = callback;
+  }
+
+  setOnPointerMoveOver(callback) {
+    this.onPointerMoveOver = callback;
+  }
+
+  setOnPointerMoveOut(callback) {
+    this.onPointerMoveOut = callback;
+  }
+
+  markAsInBounds(pointerId) {
+    if (this.pointersInBounds.indexOf(pointerId) >= 0) {
+      return;
+    }
+
+    this.pointersInBounds.push(pointerId);
+  }
+
+  markAsOutOfBounds(pointerId) {
+    const index = this.pointersInBounds.indexOf(pointerId);
+
+    if (index < 0) {
+      return;
+    }
+
+    this.pointersInBounds.splice(index, 1);
+  }
+
+  resetManager() {
+    // Reseting activePointersCounter is necessary to make gestures such as pinch work properly
+    // There are gestures that end when there is still one active pointer (like pinch/rotation)
+    // When these gestures end, they are reset, but they still receive events from pointer that is active
+    // This causes trouble, since only onPointerDown registers gesture in orchestrator, and while gestures receive
+    // Events from active pointer after they finished, next pointerdown event will be registered as additional pointer, not the first one
+    // This casues trouble like gestures getting stuck in END state, even though they should have gone to UNDETERMINED
+    this.activePointersCounter = 0;
+    this.pointersInBounds = [];
+  }
+
+}
+//# sourceMappingURL=EventManager.js.map

package/lib/module/web/tools/EventManager.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["EventManager.ts"],"names":["EventManager","constructor","view","activePointersCounter","onPointerDown","_event","onPointerAdd","onPointerUp","onPointerRemove","onPointerMove","onPointerLeave","onPointerEnter","onPointerCancel","onPointerOutOfBounds","onPointerMoveOver","onPointerMoveOut","setOnPointerDown","callback","setOnPointerAdd","setOnPointerUp","setOnPointerRemove","setOnPointerMove","setOnPointerLeave","setOnPointerEnter","setOnPointerCancel","setOnPointerOutOfBounds","setOnPointerMoveOver","setOnPointerMoveOut","markAsInBounds","pointerId","pointersInBounds","indexOf","push","markAsOutOfBounds","index","splice","resetManager"],"mappings":";;AAAA;AAGA,eAAe,MAAeA,YAAf,CAA+B;AAK5CC,EAAAA,WAAW,CAACC,IAAD,EAAU;AAAA;;AAAA,8CAHkB,EAGlB;;AAAA;;AACnB,SAAKA,IAAL,GAAYA,IAAZ;AACA,SAAKC,qBAAL,GAA6B,CAA7B;AACD;;AAUSC,EAAAA,aAAa,CAACC,MAAD,EAA6B,CAAE;;AAC5CC,EAAAA,YAAY,CAACD,MAAD,EAA6B,CAAE;;AAC3CE,EAAAA,WAAW,CAACF,MAAD,EAA6B,CAAE;;AAC1CG,EAAAA,eAAe,CAACH,MAAD,EAA6B,CAAE;;AAC9CI,EAAAA,aAAa,CAACJ,MAAD,EAA6B,CAAE;;AAC5CK,EAAAA,cAAc,CAACL,MAAD,EAA6B,CAAE,CAvBX,CAuBY;;;AAC9CM,EAAAA,cAAc,CAACN,MAAD,EAA6B,CAAE,CAxBX,CAwBY;;;AAC9CO,EAAAA,eAAe,CAACP,MAAD,EAA6B,CACpD;AACA;AACA;AACA;AACD;;AACSQ,EAAAA,oBAAoB,CAACR,MAAD,EAA6B,CAAE;;AACnDS,EAAAA,iBAAiB,CAACT,MAAD,EAA6B,CAAE;;AAChDU,EAAAA,gBAAgB,CAACV,MAAD,EAA6B,CAAE;;AAElDW,EAAAA,gBAAgB,CAACC,QAAD,EAAgD;AACrE,SAAKb,aAAL,GAAqBa,QAArB;AACD;;AACMC,EAAAA,eAAe,CAACD,QAAD,EAAgD;AACpE,SAAKX,YAAL,GAAoBW,QAApB;AACD;;AACME,EAAAA,cAAc,CAACF,QAAD,EAAgD;AACnE,SAAKV,WAAL,GAAmBU,QAAnB;AACD;;AACMG,EAAAA,kBAAkB,CAACH,QAAD,EAAgD;AACvE,SAAKT,eAAL,GAAuBS,QAAvB;AACD;;AACMI,EAAAA,gBAAgB,CAACJ,QAAD,EAAgD;AACrE,SAAKR,aAAL,GAAqBQ,QAArB;AACD;;AACMK,EAAAA,iBAAiB,CAACL,QAAD,EAAgD;AACtE,SAAKP,cAAL,GAAsBO,QAAtB;AACD;;AACMM,EAAAA,iBAAiB,CAACN,QAAD,EAAgD;AACtE,SAAKN,cAAL,GAAsBM,QAAtB;AACD;;AACMO,EAAAA,kBAAkB,CAACP,QAAD,EAAgD;AACvE,SAAKL,eAAL,GAAuBK,QAAvB;AACD;;AACMQ,EAAAA,uBAAuB,CAC5BR,QAD4B,EAEtB;AACN,SAAKJ,oBAAL,GAA4BI,QAA5B;AACD;;AACMS,EAAAA,oBAAoB,CAACT,QAAD,EAAgD;AACzE,SAAKH,iBAAL,GAAyBG,QAAzB;AACD;;AACMU,EAAAA,mBAAmB,CAACV,QAAD,EAAgD;AACxE,SAAKF,gBAAL,GAAwBE,QAAxB;AACD;;AAESW,EAAAA,cAAc,CAACC,SAAD,EAA0B;AAChD,QAAI,KAAKC,gBAAL,CAAsBC,OAAtB,CAA8BF,SAA9B,KAA4C,CAAhD,EAAmD;AACjD;AACD;;AAED,SAAKC,gBAAL,CAAsBE,IAAtB,CAA2BH,SAA3B;AACD;;AAESI,EAAAA,iBAAiB,CAACJ,SAAD,EAA0B;AACnD,UAAMK,KAAa,GAAG,KAAKJ,gBAAL,CAAsBC,OAAtB,CAA8BF,SAA9B,CAAtB;;AAEA,QAAIK,KAAK,GAAG,CAAZ,EAAe;AACb;AACD;;AAED,SAAKJ,gBAAL,CAAsBK,MAAtB,CAA6BD,KAA7B,EAAoC,CAApC;AACD;;AAEME,EAAAA,YAAY,GAAS;AAC1B;AACA;AACA;AACA;AACA;AACA;AAEA,SAAKjC,qBAAL,GAA6B,CAA7B;AACA,SAAK2B,gBAAL,GAAwB,EAAxB;AACD;;AAnG2C","sourcesContent":["/* eslint-disable @typescript-eslint/no-empty-function */\r\nimport { AdaptedEvent, EventTypes, TouchEventType } from '../interfaces';\r\n\r\nexport default abstract class EventManager<T> {\r\n  protected readonly view: T;\r\n  protected pointersInBounds: number[] = [];\r\n  protected activePointersCounter: number;\r\n\r\n  constructor(view: T) {\r\n    this.view = view;\r\n    this.activePointersCounter = 0;\r\n  }\r\n\r\n  public abstract setListeners(): void;\r\n  protected abstract mapEvent(\r\n    event: Event,\r\n    eventType: EventTypes,\r\n    index?: number,\r\n    touchEventType?: TouchEventType\r\n  ): AdaptedEvent;\r\n\r\n  protected onPointerDown(_event: AdaptedEvent): void {}\r\n  protected onPointerAdd(_event: AdaptedEvent): void {}\r\n  protected onPointerUp(_event: AdaptedEvent): void {}\r\n  protected onPointerRemove(_event: AdaptedEvent): void {}\r\n  protected onPointerMove(_event: AdaptedEvent): void {}\r\n  protected onPointerLeave(_event: AdaptedEvent): void {} // called only when pointer is pressed (or touching)\r\n  protected onPointerEnter(_event: AdaptedEvent): void {} // called only when pointer is pressed (or touching)\r\n  protected onPointerCancel(_event: AdaptedEvent): void {\r\n    // When pointer cancel is triggered and there are more pointers on the view, only one pointer is cancelled\r\n    // Because we want all pointers to be cancelled by that event, we are doing it manually by reseting handler and changing activePointersCounter to 0\r\n    // Events that correspond to removing the pointer (pointerup, touchend) have condition, that they don't perform any action when activePointersCounter\r\n    // is equal to 0. This prevents counter from going to negative values, when pointers are removed from view after one of them has been cancelled\r\n  }\r\n  protected onPointerOutOfBounds(_event: AdaptedEvent): void {}\r\n  protected onPointerMoveOver(_event: AdaptedEvent): void {}\r\n  protected onPointerMoveOut(_event: AdaptedEvent): void {}\r\n\r\n  public setOnPointerDown(callback: (event: AdaptedEvent) => void): void {\r\n    this.onPointerDown = callback;\r\n  }\r\n  public setOnPointerAdd(callback: (event: AdaptedEvent) => void): void {\r\n    this.onPointerAdd = callback;\r\n  }\r\n  public setOnPointerUp(callback: (event: AdaptedEvent) => void): void {\r\n    this.onPointerUp = callback;\r\n  }\r\n  public setOnPointerRemove(callback: (event: AdaptedEvent) => void): void {\r\n    this.onPointerRemove = callback;\r\n  }\r\n  public setOnPointerMove(callback: (event: AdaptedEvent) => void): void {\r\n    this.onPointerMove = callback;\r\n  }\r\n  public setOnPointerLeave(callback: (event: AdaptedEvent) => void): void {\r\n    this.onPointerLeave = callback;\r\n  }\r\n  public setOnPointerEnter(callback: (event: AdaptedEvent) => void): void {\r\n    this.onPointerEnter = callback;\r\n  }\r\n  public setOnPointerCancel(callback: (event: AdaptedEvent) => void): void {\r\n    this.onPointerCancel = callback;\r\n  }\r\n  public setOnPointerOutOfBounds(\r\n    callback: (event: AdaptedEvent) => void\r\n  ): void {\r\n    this.onPointerOutOfBounds = callback;\r\n  }\r\n  public setOnPointerMoveOver(callback: (event: AdaptedEvent) => void): void {\r\n    this.onPointerMoveOver = callback;\r\n  }\r\n  public setOnPointerMoveOut(callback: (event: AdaptedEvent) => void): void {\r\n    this.onPointerMoveOut = callback;\r\n  }\r\n\r\n  protected markAsInBounds(pointerId: number): void {\r\n    if (this.pointersInBounds.indexOf(pointerId) >= 0) {\r\n      return;\r\n    }\r\n\r\n    this.pointersInBounds.push(pointerId);\r\n  }\r\n\r\n  protected markAsOutOfBounds(pointerId: number): void {\r\n    const index: number = this.pointersInBounds.indexOf(pointerId);\r\n\r\n    if (index < 0) {\r\n      return;\r\n    }\r\n\r\n    this.pointersInBounds.splice(index, 1);\r\n  }\r\n\r\n  public resetManager(): void {\r\n    // Reseting activePointersCounter is necessary to make gestures such as pinch work properly\r\n    // There are gestures that end when there is still one active pointer (like pinch/rotation)\r\n    // When these gestures end, they are reset, but they still receive events from pointer that is active\r\n    // This causes trouble, since only onPointerDown registers gesture in orchestrator, and while gestures receive\r\n    // Events from active pointer after they finished, next pointerdown event will be registered as additional pointer, not the first one\r\n    // This casues trouble like gestures getting stuck in END state, even though they should have gone to UNDETERMINED\r\n\r\n    this.activePointersCounter = 0;\r\n    this.pointersInBounds = [];\r\n  }\r\n}\r\n"]}

package/lib/module/web/tools/GestureHandlerDelegate.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=GestureHandlerDelegate.js.map

package/lib/module/web/tools/GestureHandlerDelegate.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","sourcesContent":[]}

package/lib/module/web/tools/GestureHandlerOrchestrator.js

@@ -0,0 +1,335 @@
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+import { State } from '../../State';
+import { PointerType } from '../interfaces';
+import PointerTracker from './PointerTracker';
+export default class GestureHandlerOrchestrator {
+  // Private beacuse of Singleton
+  // eslint-disable-next-line no-useless-constructor, @typescript-eslint/no-empty-function
+  constructor() {
+    _defineProperty(this, "gestureHandlers", []);
+
+    _defineProperty(this, "awaitingHandlers", []);
+
+    _defineProperty(this, "handlingChangeSemaphore", 0);
+
+    _defineProperty(this, "activationIndex", 0);
+  }
+
+  scheduleFinishedHandlersCleanup() {
+    if (this.handlingChangeSemaphore === 0) {
+      this.cleanupFinishedHandlers();
+    }
+  }
+
+  cleanHandler(handler) {
+    handler.reset();
+    handler.setActive(false);
+    handler.setAwaiting(false);
+    handler.setActivationIndex(Number.MAX_VALUE);
+  }
+
+  removeHandlerFromOrchestrator(handler) {
+    this.gestureHandlers.splice(this.gestureHandlers.indexOf(handler), 1);
+    this.awaitingHandlers.splice(this.awaitingHandlers.indexOf(handler), 1);
+  }
+
+  cleanupFinishedHandlers() {
+    for (let i = this.gestureHandlers.length - 1; i >= 0; --i) {
+      const handler = this.gestureHandlers[i];
+
+      if (!handler) {
+        continue;
+      }
+
+      if (this.isFinished(handler.getState()) && !handler.isAwaiting()) {
+        this.gestureHandlers.splice(i, 1);
+        this.cleanHandler(handler);
+      }
+    }
+  }
+
+  hasOtherHandlerToWaitFor(handler) {
+    let hasToWait = false;
+    this.gestureHandlers.forEach(otherHandler => {
+      if (otherHandler && !this.isFinished(otherHandler.getState()) && this.shouldHandlerWaitForOther(handler, otherHandler)) {
+        hasToWait = true;
+        return;
+      }
+    });
+    return hasToWait;
+  }
+
+  tryActivate(handler) {
+    if (this.hasOtherHandlerToWaitFor(handler)) {
+      this.addAwaitingHandler(handler);
+    } else if (handler.getState() !== State.CANCELLED && handler.getState() !== State.FAILED) {
+      if (this.shouldActivate(handler)) {
+        this.makeActive(handler);
+      } else {
+        switch (handler.getState()) {
+          case State.ACTIVE:
+            handler.fail();
+            break;
+
+          case State.BEGAN:
+            handler.cancel();
+        }
+      }
+    }
+  }
+
+  shouldActivate(handler) {
+    for (const otherHandler of this.gestureHandlers) {
+      if (this.shouldHandlerBeCancelledBy(handler, otherHandler)) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  cleanupAwaitingHandlers(handler) {
+    for (let i = 0; i < this.awaitingHandlers.length; ++i) {
+      if (!this.awaitingHandlers[i].isAwaiting() && this.shouldHandlerWaitForOther(this.awaitingHandlers[i], handler)) {
+        this.cleanHandler(this.awaitingHandlers[i]);
+        this.awaitingHandlers.splice(i, 1);
+      }
+    }
+  }
+
+  onHandlerStateChange(handler, newState, oldState, sendIfDisabled) {
+    if (!handler.isEnabled() && !sendIfDisabled) {
+      return;
+    }
+
+    this.handlingChangeSemaphore += 1;
+
+    if (this.isFinished(newState)) {
+      this.awaitingHandlers.forEach(otherHandler => {
+        if (this.shouldHandlerWaitForOther(otherHandler, handler)) {
+          if (newState === State.END) {
+            otherHandler === null || otherHandler === void 0 ? void 0 : otherHandler.cancel();
+
+            if (otherHandler.getState() === State.END) {
+              // Handle edge case, where discrete gestures end immediately after activation thus
+              // their state is set to END and when the gesture they are waiting for activates they
+              // should be cancelled, however `cancel` was never sent as gestures were already in the END state.
+              // Send synthetic BEGAN -> CANCELLED to properly handle JS logic
+              otherHandler.sendEvent(State.CANCELLED, State.BEGAN);
+            }
+
+            otherHandler === null || otherHandler === void 0 ? void 0 : otherHandler.setAwaiting(false);
+          } else {
+            this.tryActivate(otherHandler);
+          }
+        }
+      });
+    }
+
+    if (newState === State.ACTIVE) {
+      this.tryActivate(handler);
+    } else if (oldState === State.ACTIVE || oldState === State.END) {
+      if (handler.isActive()) {
+        handler.sendEvent(newState, oldState);
+      } else if (oldState === State.ACTIVE && (newState === State.CANCELLED || newState === State.FAILED)) {
+        handler.sendEvent(newState, State.BEGAN);
+      }
+    } else if (oldState !== State.UNDETERMINED || newState !== State.CANCELLED) {
+      handler.sendEvent(newState, oldState);
+    }
+
+    this.handlingChangeSemaphore -= 1;
+    this.scheduleFinishedHandlersCleanup();
+
+    if (this.awaitingHandlers.indexOf(handler) < 0) {
+      this.cleanupAwaitingHandlers(handler);
+    }
+  }
+
+  makeActive(handler) {
+    const currentState = handler.getState();
+    handler.setActive(true);
+    handler.setShouldResetProgress(true);
+    handler.setActivationIndex(this.activationIndex++);
+
+    for (let i = this.gestureHandlers.length - 1; i >= 0; --i) {
+      if (this.shouldHandlerBeCancelledBy(this.gestureHandlers[i], handler)) {
+        this.gestureHandlers[i].cancel();
+      }
+    }
+
+    this.awaitingHandlers.forEach(otherHandler => {
+      if (this.shouldHandlerBeCancelledBy(otherHandler, handler)) {
+        otherHandler === null || otherHandler === void 0 ? void 0 : otherHandler.cancel();
+        otherHandler === null || otherHandler === void 0 ? void 0 : otherHandler.setAwaiting(true);
+      }
+    });
+    handler.sendEvent(State.ACTIVE, State.BEGAN);
+
+    if (currentState !== State.ACTIVE) {
+      handler.sendEvent(State.END, State.ACTIVE);
+
+      if (currentState !== State.END) {
+        handler.sendEvent(State.UNDETERMINED, State.END);
+      }
+    }
+
+    if (handler.isAwaiting()) {
+      handler.setAwaiting(false);
+
+      for (let i = 0; i < this.awaitingHandlers.length; ++i) {
+        if (this.awaitingHandlers[i] === handler) {
+          this.awaitingHandlers.splice(i, 1);
+        }
+      }
+    }
+  }
+
+  addAwaitingHandler(handler) {
+    let alreadyExists = false;
+    this.awaitingHandlers.forEach(otherHandler => {
+      if (otherHandler === handler) {
+        alreadyExists = true;
+        return;
+      }
+    });
+
+    if (alreadyExists) {
+      return;
+    }
+
+    this.awaitingHandlers.push(handler);
+    handler.setAwaiting(true);
+    handler.setActivationIndex(this.activationIndex++);
+  }
+
+  recordHandlerIfNotPresent(handler) {
+    let alreadyExists = false;
+    this.gestureHandlers.forEach(otherHandler => {
+      if (otherHandler === handler) {
+        alreadyExists = true;
+        return;
+      }
+    });
+
+    if (alreadyExists) {
+      return;
+    }
+
+    this.gestureHandlers.push(handler);
+    handler.setActive(false);
+    handler.setAwaiting(false);
+    handler.setActivationIndex(Number.MAX_SAFE_INTEGER);
+  }
+
+  shouldHandlerWaitForOther(handler, otherHandler) {
+    return handler !== otherHandler && (handler.shouldWaitForHandlerFailure(otherHandler) || otherHandler.shouldRequireToWaitForFailure(handler));
+  }
+
+  canRunSimultaneously(gh1, gh2) {
+    return gh1 === gh2 || gh1.shouldRecognizeSimultaneously(gh2) || gh2.shouldRecognizeSimultaneously(gh1);
+  }
+
+  shouldHandlerBeCancelledBy(handler, otherHandler) {
+    if (this.canRunSimultaneously(handler, otherHandler)) {
+      return false;
+    }
+
+    if (handler !== otherHandler && (handler.isAwaiting() || handler.getState() === State.ACTIVE)) {
+      // For now it always returns false
+      return handler.shouldBeCancelledByOther(otherHandler);
+    }
+
+    const handlerPointers = handler.getTrackedPointersID();
+    const otherPointers = otherHandler.getTrackedPointersID();
+
+    if (!PointerTracker.shareCommonPointers(handlerPointers, otherPointers) && handler.getDelegate().getView() !== otherHandler.getDelegate().getView()) {
+      return this.checkOverlap(handler, otherHandler);
+    }
+
+    return true;
+  }
+
+  checkOverlap(handler, otherHandler) {
+    // If handlers don't have common pointers, default return value is false.
+    // However, if at least on pointer overlaps with both handlers, we return true
+    // This solves issue in overlapping parents example
+    // TODO: Find better way to handle that issue, for example by activation order and handler cancelling
+    const handlerPointers = handler.getTrackedPointersID();
+    const otherPointers = otherHandler.getTrackedPointersID();
+    let overlap = false;
+    handlerPointers.forEach(pointer => {
+      const handlerX = handler.getTracker().getLastX(pointer);
+      const handlerY = handler.getTracker().getLastY(pointer);
+
+      if (handler.getDelegate().isPointerInBounds({
+        x: handlerX,
+        y: handlerY
+      }) && otherHandler.getDelegate().isPointerInBounds({
+        x: handlerX,
+        y: handlerY
+      })) {
+        overlap = true;
+      }
+    });
+    otherPointers.forEach(pointer => {
+      const otherX = otherHandler.getTracker().getLastX(pointer);
+      const otherY = otherHandler.getTracker().getLastY(pointer);
+
+      if (handler.getDelegate().isPointerInBounds({
+        x: otherX,
+        y: otherY
+      }) && otherHandler.getDelegate().isPointerInBounds({
+        x: otherX,
+        y: otherY
+      })) {
+        overlap = true;
+      }
+    });
+    return overlap;
+  }
+
+  isFinished(state) {
+    return state === State.END || state === State.FAILED || state === State.CANCELLED;
+  } // This function is called when handler receives touchdown event
+  // If handler is using mouse or pen as a pointer and any handler receives touch event,
+  // mouse/pen event dissappears - it doesn't send onPointerCancel nor onPointerUp (and others)
+  // This became a problem because handler was left at active state without any signal to end or fail
+  // To handle this, when new touch event is received, we loop through active handlers and check which type of
+  // pointer they're using. If there are any handler with mouse/pen as a pointer, we cancel them
+
+
+  cancelMouseAndPenGestures(currentHandler) {
+    this.gestureHandlers.forEach(handler => {
+      if (handler.getPointerType() !== PointerType.MOUSE && handler.getPointerType() !== PointerType.PEN) {
+        return;
+      }
+
+      if (handler !== currentHandler) {
+        handler.cancel();
+      } else {
+        // Handler that received touch event should have its pointer tracker reset
+        // This allows handler to smoothly change from mouse/pen to touch
+        // The drawback is, that when we try to use mouse/pen one more time, it doesn't send onPointerDown at the first time
+        // so it is required to click two times to get handler to work
+        //
+        // However, handler will receive manually created onPointerEnter that is triggered in EventManager in onPointerMove method.
+        // There may be possibility to use that fact to make handler respond properly to first mouse click
+        handler.getTracker().resetTracker();
+      }
+    });
+  }
+
+  static getInstance() {
+    if (!GestureHandlerOrchestrator.instance) {
+      GestureHandlerOrchestrator.instance = new GestureHandlerOrchestrator();
+    }
+
+    return GestureHandlerOrchestrator.instance;
+  }
+
+}
+
+_defineProperty(GestureHandlerOrchestrator, "instance", void 0);
+//# sourceMappingURL=GestureHandlerOrchestrator.js.map

package/lib/module/web/tools/GestureHandlerOrchestrator.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["GestureHandlerOrchestrator.ts"],"names":["State","PointerType","PointerTracker","GestureHandlerOrchestrator","constructor","scheduleFinishedHandlersCleanup","handlingChangeSemaphore","cleanupFinishedHandlers","cleanHandler","handler","reset","setActive","setAwaiting","setActivationIndex","Number","MAX_VALUE","removeHandlerFromOrchestrator","gestureHandlers","splice","indexOf","awaitingHandlers","i","length","isFinished","getState","isAwaiting","hasOtherHandlerToWaitFor","hasToWait","forEach","otherHandler","shouldHandlerWaitForOther","tryActivate","addAwaitingHandler","CANCELLED","FAILED","shouldActivate","makeActive","ACTIVE","fail","BEGAN","cancel","shouldHandlerBeCancelledBy","cleanupAwaitingHandlers","onHandlerStateChange","newState","oldState","sendIfDisabled","isEnabled","END","sendEvent","isActive","UNDETERMINED","currentState","setShouldResetProgress","activationIndex","alreadyExists","push","recordHandlerIfNotPresent","MAX_SAFE_INTEGER","shouldWaitForHandlerFailure","shouldRequireToWaitForFailure","canRunSimultaneously","gh1","gh2","shouldRecognizeSimultaneously","shouldBeCancelledByOther","handlerPointers","getTrackedPointersID","otherPointers","shareCommonPointers","getDelegate","getView","checkOverlap","overlap","pointer","handlerX","getTracker","getLastX","handlerY","getLastY","isPointerInBounds","x","y","otherX","otherY","state","cancelMouseAndPenGestures","currentHandler","getPointerType","MOUSE","PEN","resetTracker","getInstance","instance"],"mappings":"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","sourcesContent":["import { State } from '../../State';\r\nimport { PointerType } from '../interfaces';\r\n\r\nimport GestureHandler from '../handlers/GestureHandler';\r\nimport PointerTracker from './PointerTracker';\r\n\r\nexport default class GestureHandlerOrchestrator {\r\n  private static instance: GestureHandlerOrchestrator;\r\n\r\n  private gestureHandlers: GestureHandler[] = [];\r\n  private awaitingHandlers: GestureHandler[] = [];\r\n\r\n  private handlingChangeSemaphore = 0;\r\n  private activationIndex = 0;\r\n\r\n  // Private beacuse of Singleton\r\n  // eslint-disable-next-line no-useless-constructor, @typescript-eslint/no-empty-function\r\n  private constructor() {}\r\n\r\n  private scheduleFinishedHandlersCleanup(): void {\r\n    if (this.handlingChangeSemaphore === 0) {\r\n      this.cleanupFinishedHandlers();\r\n    }\r\n  }\r\n\r\n  private cleanHandler(handler: GestureHandler): void {\r\n    handler.reset();\r\n    handler.setActive(false);\r\n    handler.setAwaiting(false);\r\n    handler.setActivationIndex(Number.MAX_VALUE);\r\n  }\r\n\r\n  public removeHandlerFromOrchestrator(handler: GestureHandler): void {\r\n    this.gestureHandlers.splice(this.gestureHandlers.indexOf(handler), 1);\r\n    this.awaitingHandlers.splice(this.awaitingHandlers.indexOf(handler), 1);\r\n  }\r\n\r\n  private cleanupFinishedHandlers(): void {\r\n    for (let i = this.gestureHandlers.length - 1; i >= 0; --i) {\r\n      const handler = this.gestureHandlers[i];\r\n\r\n      if (!handler) {\r\n        continue;\r\n      }\r\n      if (this.isFinished(handler.getState()) && !handler.isAwaiting()) {\r\n        this.gestureHandlers.splice(i, 1);\r\n\r\n        this.cleanHandler(handler);\r\n      }\r\n    }\r\n  }\r\n\r\n  private hasOtherHandlerToWaitFor(handler: GestureHandler): boolean {\r\n    let hasToWait = false;\r\n    this.gestureHandlers.forEach((otherHandler) => {\r\n      if (\r\n        otherHandler &&\r\n        !this.isFinished(otherHandler.getState()) &&\r\n        this.shouldHandlerWaitForOther(handler, otherHandler)\r\n      ) {\r\n        hasToWait = true;\r\n        return;\r\n      }\r\n    });\r\n\r\n    return hasToWait;\r\n  }\r\n\r\n  private tryActivate(handler: GestureHandler): void {\r\n    if (this.hasOtherHandlerToWaitFor(handler)) {\r\n      this.addAwaitingHandler(handler);\r\n    } else if (\r\n      handler.getState() !== State.CANCELLED &&\r\n      handler.getState() !== State.FAILED\r\n    ) {\r\n      if (this.shouldActivate(handler)) {\r\n        this.makeActive(handler);\r\n      } else {\r\n        switch (handler.getState()) {\r\n          case State.ACTIVE:\r\n            handler.fail();\r\n            break;\r\n          case State.BEGAN:\r\n            handler.cancel();\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  private shouldActivate(handler: GestureHandler): boolean {\r\n    for (const otherHandler of this.gestureHandlers) {\r\n      if (this.shouldHandlerBeCancelledBy(handler, otherHandler)) {\r\n        return false;\r\n      }\r\n    }\r\n\r\n    return true;\r\n  }\r\n\r\n  private cleanupAwaitingHandlers(handler: GestureHandler): void {\r\n    for (let i = 0; i < this.awaitingHandlers.length; ++i) {\r\n      if (\r\n        !this.awaitingHandlers[i].isAwaiting() &&\r\n        this.shouldHandlerWaitForOther(this.awaitingHandlers[i], handler)\r\n      ) {\r\n        this.cleanHandler(this.awaitingHandlers[i]);\r\n        this.awaitingHandlers.splice(i, 1);\r\n      }\r\n    }\r\n  }\r\n\r\n  public onHandlerStateChange(\r\n    handler: GestureHandler,\r\n    newState: State,\r\n    oldState: State,\r\n    sendIfDisabled?: boolean\r\n  ): void {\r\n    if (!handler.isEnabled() && !sendIfDisabled) {\r\n      return;\r\n    }\r\n\r\n    this.handlingChangeSemaphore += 1;\r\n\r\n    if (this.isFinished(newState)) {\r\n      this.awaitingHandlers.forEach((otherHandler) => {\r\n        if (this.shouldHandlerWaitForOther(otherHandler, handler)) {\r\n          if (newState === State.END) {\r\n            otherHandler?.cancel();\r\n            if (otherHandler.getState() === State.END) {\r\n              // Handle edge case, where discrete gestures end immediately after activation thus\r\n              // their state is set to END and when the gesture they are waiting for activates they\r\n              // should be cancelled, however `cancel` was never sent as gestures were already in the END state.\r\n              // Send synthetic BEGAN -> CANCELLED to properly handle JS logic\r\n              otherHandler.sendEvent(State.CANCELLED, State.BEGAN);\r\n            }\r\n            otherHandler?.setAwaiting(false);\r\n          } else {\r\n            this.tryActivate(otherHandler);\r\n          }\r\n        }\r\n      });\r\n    }\r\n\r\n    if (newState === State.ACTIVE) {\r\n      this.tryActivate(handler);\r\n    } else if (oldState === State.ACTIVE || oldState === State.END) {\r\n      if (handler.isActive()) {\r\n        handler.sendEvent(newState, oldState);\r\n      } else if (\r\n        oldState === State.ACTIVE &&\r\n        (newState === State.CANCELLED || newState === State.FAILED)\r\n      ) {\r\n        handler.sendEvent(newState, State.BEGAN);\r\n      }\r\n    } else if (\r\n      oldState !== State.UNDETERMINED ||\r\n      newState !== State.CANCELLED\r\n    ) {\r\n      handler.sendEvent(newState, oldState);\r\n    }\r\n\r\n    this.handlingChangeSemaphore -= 1;\r\n\r\n    this.scheduleFinishedHandlersCleanup();\r\n\r\n    if (this.awaitingHandlers.indexOf(handler) < 0) {\r\n      this.cleanupAwaitingHandlers(handler);\r\n    }\r\n  }\r\n\r\n  private makeActive(handler: GestureHandler): void {\r\n    const currentState = handler.getState();\r\n\r\n    handler.setActive(true);\r\n    handler.setShouldResetProgress(true);\r\n    handler.setActivationIndex(this.activationIndex++);\r\n\r\n    for (let i = this.gestureHandlers.length - 1; i >= 0; --i) {\r\n      if (this.shouldHandlerBeCancelledBy(this.gestureHandlers[i], handler)) {\r\n        this.gestureHandlers[i].cancel();\r\n      }\r\n    }\r\n\r\n    this.awaitingHandlers.forEach((otherHandler) => {\r\n      if (this.shouldHandlerBeCancelledBy(otherHandler, handler)) {\r\n        otherHandler?.cancel();\r\n        otherHandler?.setAwaiting(true);\r\n      }\r\n    });\r\n\r\n    handler.sendEvent(State.ACTIVE, State.BEGAN);\r\n\r\n    if (currentState !== State.ACTIVE) {\r\n      handler.sendEvent(State.END, State.ACTIVE);\r\n      if (currentState !== State.END) {\r\n        handler.sendEvent(State.UNDETERMINED, State.END);\r\n      }\r\n    }\r\n\r\n    if (handler.isAwaiting()) {\r\n      handler.setAwaiting(false);\r\n      for (let i = 0; i < this.awaitingHandlers.length; ++i) {\r\n        if (this.awaitingHandlers[i] === handler) {\r\n          this.awaitingHandlers.splice(i, 1);\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  private addAwaitingHandler(handler: GestureHandler): void {\r\n    let alreadyExists = false;\r\n\r\n    this.awaitingHandlers.forEach((otherHandler) => {\r\n      if (otherHandler === handler) {\r\n        alreadyExists = true;\r\n        return;\r\n      }\r\n    });\r\n\r\n    if (alreadyExists) {\r\n      return;\r\n    }\r\n\r\n    this.awaitingHandlers.push(handler);\r\n\r\n    handler.setAwaiting(true);\r\n    handler.setActivationIndex(this.activationIndex++);\r\n  }\r\n\r\n  public recordHandlerIfNotPresent(handler: GestureHandler): void {\r\n    let alreadyExists = false;\r\n\r\n    this.gestureHandlers.forEach((otherHandler) => {\r\n      if (otherHandler === handler) {\r\n        alreadyExists = true;\r\n        return;\r\n      }\r\n    });\r\n\r\n    if (alreadyExists) {\r\n      return;\r\n    }\r\n\r\n    this.gestureHandlers.push(handler);\r\n\r\n    handler.setActive(false);\r\n    handler.setAwaiting(false);\r\n    handler.setActivationIndex(Number.MAX_SAFE_INTEGER);\r\n  }\r\n\r\n  private shouldHandlerWaitForOther(\r\n    handler: GestureHandler,\r\n    otherHandler: GestureHandler\r\n  ): boolean {\r\n    return (\r\n      handler !== otherHandler &&\r\n      (handler.shouldWaitForHandlerFailure(otherHandler) ||\r\n        otherHandler.shouldRequireToWaitForFailure(handler))\r\n    );\r\n  }\r\n\r\n  private canRunSimultaneously(\r\n    gh1: GestureHandler,\r\n    gh2: GestureHandler\r\n  ): boolean {\r\n    return (\r\n      gh1 === gh2 ||\r\n      gh1.shouldRecognizeSimultaneously(gh2) ||\r\n      gh2.shouldRecognizeSimultaneously(gh1)\r\n    );\r\n  }\r\n\r\n  private shouldHandlerBeCancelledBy(\r\n    handler: GestureHandler,\r\n    otherHandler: GestureHandler\r\n  ): boolean {\r\n    if (this.canRunSimultaneously(handler, otherHandler)) {\r\n      return false;\r\n    }\r\n\r\n    if (\r\n      handler !== otherHandler &&\r\n      (handler.isAwaiting() || handler.getState() === State.ACTIVE)\r\n    ) {\r\n      // For now it always returns false\r\n      return handler.shouldBeCancelledByOther(otherHandler);\r\n    }\r\n\r\n    const handlerPointers: number[] = handler.getTrackedPointersID();\r\n    const otherPointers: number[] = otherHandler.getTrackedPointersID();\r\n\r\n    if (\r\n      !PointerTracker.shareCommonPointers(handlerPointers, otherPointers) &&\r\n      handler.getDelegate().getView() !== otherHandler.getDelegate().getView()\r\n    ) {\r\n      return this.checkOverlap(handler, otherHandler);\r\n    }\r\n\r\n    return true;\r\n  }\r\n\r\n  private checkOverlap(\r\n    handler: GestureHandler,\r\n    otherHandler: GestureHandler\r\n  ): boolean {\r\n    // If handlers don't have common pointers, default return value is false.\r\n    // However, if at least on pointer overlaps with both handlers, we return true\r\n    // This solves issue in overlapping parents example\r\n\r\n    // TODO: Find better way to handle that issue, for example by activation order and handler cancelling\r\n\r\n    const handlerPointers: number[] = handler.getTrackedPointersID();\r\n    const otherPointers: number[] = otherHandler.getTrackedPointersID();\r\n\r\n    let overlap = false;\r\n\r\n    handlerPointers.forEach((pointer: number) => {\r\n      const handlerX: number = handler.getTracker().getLastX(pointer);\r\n      const handlerY: number = handler.getTracker().getLastY(pointer);\r\n\r\n      if (\r\n        handler.getDelegate().isPointerInBounds({ x: handlerX, y: handlerY }) &&\r\n        otherHandler\r\n          .getDelegate()\r\n          .isPointerInBounds({ x: handlerX, y: handlerY })\r\n      ) {\r\n        overlap = true;\r\n      }\r\n    });\r\n\r\n    otherPointers.forEach((pointer: number) => {\r\n      const otherX: number = otherHandler.getTracker().getLastX(pointer);\r\n      const otherY: number = otherHandler.getTracker().getLastY(pointer);\r\n\r\n      if (\r\n        handler.getDelegate().isPointerInBounds({ x: otherX, y: otherY }) &&\r\n        otherHandler.getDelegate().isPointerInBounds({ x: otherX, y: otherY })\r\n      ) {\r\n        overlap = true;\r\n      }\r\n    });\r\n\r\n    return overlap;\r\n  }\r\n\r\n  private isFinished(state: State): boolean {\r\n    return (\r\n      state === State.END || state === State.FAILED || state === State.CANCELLED\r\n    );\r\n  }\r\n\r\n  // This function is called when handler receives touchdown event\r\n  // If handler is using mouse or pen as a pointer and any handler receives touch event,\r\n  // mouse/pen event dissappears - it doesn't send onPointerCancel nor onPointerUp (and others)\r\n  // This became a problem because handler was left at active state without any signal to end or fail\r\n  // To handle this, when new touch event is received, we loop through active handlers and check which type of\r\n  // pointer they're using. If there are any handler with mouse/pen as a pointer, we cancel them\r\n  public cancelMouseAndPenGestures(currentHandler: GestureHandler): void {\r\n    this.gestureHandlers.forEach((handler: GestureHandler) => {\r\n      if (\r\n        handler.getPointerType() !== PointerType.MOUSE &&\r\n        handler.getPointerType() !== PointerType.PEN\r\n      ) {\r\n        return;\r\n      }\r\n\r\n      if (handler !== currentHandler) {\r\n        handler.cancel();\r\n      } else {\r\n        // Handler that received touch event should have its pointer tracker reset\r\n        // This allows handler to smoothly change from mouse/pen to touch\r\n        // The drawback is, that when we try to use mouse/pen one more time, it doesn't send onPointerDown at the first time\r\n        // so it is required to click two times to get handler to work\r\n        //\r\n        // However, handler will receive manually created onPointerEnter that is triggered in EventManager in onPointerMove method.\r\n        // There may be possibility to use that fact to make handler respond properly to first mouse click\r\n        handler.getTracker().resetTracker();\r\n      }\r\n    });\r\n  }\r\n\r\n  public static getInstance(): GestureHandlerOrchestrator {\r\n    if (!GestureHandlerOrchestrator.instance) {\r\n      GestureHandlerOrchestrator.instance = new GestureHandlerOrchestrator();\r\n    }\r\n\r\n    return GestureHandlerOrchestrator.instance;\r\n  }\r\n}\r\n"]}

package/lib/module/web/tools/GestureHandlerWebDelegate.js

@@ -0,0 +1,102 @@
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+import { findNodeHandle } from 'react-native';
+import PointerEventManager from './PointerEventManager';
+import TouchEventManager from './TouchEventManager';
+import { State } from '../../State';
+import { isPointerInBounds } from '../utils';
+export class GestureHandlerWebDelegate {
+  constructor() {
+    _defineProperty(this, "view", void 0);
+
+    _defineProperty(this, "gestureHandler", void 0);
+
+    _defineProperty(this, "eventManagers", []);
+  }
+
+  getView() {
+    return this.view;
+  }
+
+  init(viewRef, handler) {
+    if (!viewRef) {
+      throw new Error(`Cannot find HTML Element for handler ${handler.getTag()}`);
+    }
+
+    this.gestureHandler = handler;
+    this.view = findNodeHandle(viewRef);
+    this.view.style['touchAction'] = 'none'; //@ts-ignore This one disables default events on Safari
+
+    this.view.style['WebkitTouchCallout'] = 'none';
+    const config = handler.getConfig();
+
+    if (!config.userSelect) {
+      this.view.style['webkitUserSelect'] = 'none';
+      this.view.style['userSelect'] = 'none';
+    } else {
+      this.view.style['webkitUserSelect'] = config.userSelect;
+      this.view.style['userSelect'] = config.userSelect;
+    }
+
+    this.eventManagers.push(new PointerEventManager(this.view));
+    this.eventManagers.push(new TouchEventManager(this.view));
+    this.eventManagers.forEach(manager => this.gestureHandler.attachEventManager(manager));
+  }
+
+  isPointerInBounds({
+    x,
+    y
+  }) {
+    return isPointerInBounds(this.view, {
+      x,
+      y
+    });
+  }
+
+  measureView() {
+    const rect = this.view.getBoundingClientRect();
+    return {
+      pageX: rect.left,
+      pageY: rect.top,
+      width: rect.width,
+      height: rect.height
+    };
+  }
+
+  reset() {
+    this.eventManagers.forEach(manager => manager.resetManager());
+  }
+
+  tryResetCursor() {
+    const config = this.gestureHandler.getConfig();
+
+    if (config.activeCursor && config.activeCursor !== 'auto' && this.gestureHandler.getState() === State.ACTIVE) {
+      this.view.style.cursor = 'auto';
+    }
+  }
+
+  onBegin() {// no-op for now
+  }
+
+  onActivate() {
+    const config = this.gestureHandler.getConfig();
+
+    if ((!this.view.style.cursor || this.view.style.cursor === 'auto') && config.activeCursor) {
+      this.view.style.cursor = config.activeCursor;
+    }
+  }
+
+  onEnd() {
+    this.tryResetCursor();
+  }
+
+  onCancel() {
+    this.tryResetCursor();
+  }
+
+  onFail() {
+    this.tryResetCursor();
+  }
+
+}
+//# sourceMappingURL=GestureHandlerWebDelegate.js.map

package/lib/module/web/tools/GestureHandlerWebDelegate.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["GestureHandlerWebDelegate.ts"],"names":["findNodeHandle","PointerEventManager","TouchEventManager","State","isPointerInBounds","GestureHandlerWebDelegate","getView","view","init","viewRef","handler","Error","getTag","gestureHandler","style","config","getConfig","userSelect","eventManagers","push","forEach","manager","attachEventManager","x","y","measureView","rect","getBoundingClientRect","pageX","left","pageY","top","width","height","reset","resetManager","tryResetCursor","activeCursor","getState","ACTIVE","cursor","onBegin","onActivate","onEnd","onCancel","onFail"],"mappings":"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","sourcesContent":["import { findNodeHandle } from 'react-native';\r\nimport type GestureHandler from '../handlers/GestureHandler';\r\nimport {\r\n  GestureHandlerDelegate,\r\n  MeasureResult,\r\n} from './GestureHandlerDelegate';\r\nimport PointerEventManager from './PointerEventManager';\r\nimport TouchEventManager from './TouchEventManager';\r\nimport { State } from '../../State';\r\nimport { isPointerInBounds } from '../utils';\r\nimport EventManager from './EventManager';\r\n\r\nexport class GestureHandlerWebDelegate\r\n  implements GestureHandlerDelegate<HTMLElement>\r\n{\r\n  private view!: HTMLElement;\r\n  private gestureHandler!: GestureHandler;\r\n  private eventManagers: EventManager<unknown>[] = [];\r\n\r\n  getView(): HTMLElement {\r\n    return this.view;\r\n  }\r\n\r\n  init(viewRef: number, handler: GestureHandler): void {\r\n    if (!viewRef) {\r\n      throw new Error(\r\n        `Cannot find HTML Element for handler ${handler.getTag()}`\r\n      );\r\n    }\r\n\r\n    this.gestureHandler = handler;\r\n    this.view = findNodeHandle(viewRef) as unknown as HTMLElement;\r\n\r\n    this.view.style['touchAction'] = 'none';\r\n    //@ts-ignore This one disables default events on Safari\r\n    this.view.style['WebkitTouchCallout'] = 'none';\r\n\r\n    const config = handler.getConfig();\r\n\r\n    if (!config.userSelect) {\r\n      this.view.style['webkitUserSelect'] = 'none';\r\n      this.view.style['userSelect'] = 'none';\r\n    } else {\r\n      this.view.style['webkitUserSelect'] = config.userSelect;\r\n      this.view.style['userSelect'] = config.userSelect;\r\n    }\r\n\r\n    this.eventManagers.push(new PointerEventManager(this.view));\r\n    this.eventManagers.push(new TouchEventManager(this.view));\r\n\r\n    this.eventManagers.forEach((manager) =>\r\n      this.gestureHandler.attachEventManager(manager)\r\n    );\r\n  }\r\n\r\n  isPointerInBounds({ x, y }: { x: number; y: number }): boolean {\r\n    return isPointerInBounds(this.view, { x, y });\r\n  }\r\n\r\n  measureView(): MeasureResult {\r\n    const rect = this.view.getBoundingClientRect();\r\n\r\n    return {\r\n      pageX: rect.left,\r\n      pageY: rect.top,\r\n      width: rect.width,\r\n      height: rect.height,\r\n    };\r\n  }\r\n\r\n  reset(): void {\r\n    this.eventManagers.forEach((manager: EventManager<unknown>) =>\r\n      manager.resetManager()\r\n    );\r\n  }\r\n\r\n  tryResetCursor() {\r\n    const config = this.gestureHandler.getConfig();\r\n\r\n    if (\r\n      config.activeCursor &&\r\n      config.activeCursor !== 'auto' &&\r\n      this.gestureHandler.getState() === State.ACTIVE\r\n    ) {\r\n      this.view.style.cursor = 'auto';\r\n    }\r\n  }\r\n\r\n  onBegin(): void {\r\n    // no-op for now\r\n  }\r\n\r\n  onActivate(): void {\r\n    const config = this.gestureHandler.getConfig();\r\n\r\n    if (\r\n      (!this.view.style.cursor || this.view.style.cursor === 'auto') &&\r\n      config.activeCursor\r\n    ) {\r\n      this.view.style.cursor = config.activeCursor;\r\n    }\r\n  }\r\n\r\n  onEnd(): void {\r\n    this.tryResetCursor();\r\n  }\r\n\r\n  onCancel(): void {\r\n    this.tryResetCursor();\r\n  }\r\n\r\n  onFail(): void {\r\n    this.tryResetCursor();\r\n  }\r\n}\r\n"]}