@amazon-devices/react-native-gesture-handler 2.0.1759135970 → 4.0.0

package/lib/commonjs/web/interfaces.js.map

@@ -1 +1 @@
-{"version":3,"names":["MouseButtons","exports","EventTypes","TouchEventType","PointerType"],"sources":["interfaces.ts"],"sourcesContent":["import { UserSelect, ActiveCursor } from '../handlers/gestureHandlerCommon';\nimport { Directions } from '../Directions';\nimport { State } from '../State';\n\nexport interface HitSlop {\n  left?: number;\n  right?: number;\n  top?: number;\n  bottom?: number;\n  horizontal?: number;\n  vertical?: number;\n  width?: number;\n  height?: number;\n}\n\nexport interface Handler {\n  handlerTag: number;\n}\n\ntype ConfigArgs =\n  | number\n  | boolean\n  | HitSlop\n  | UserSelect\n  | ActiveCursor\n  | Directions\n  | Handler[]\n  | null\n  | undefined;\n\nexport interface Config extends Record<string, ConfigArgs> {\n  enabled?: boolean;\n  simultaneousHandlers?: Handler[] | null;\n  waitFor?: Handler[] | null;\n  hitSlop?: HitSlop;\n  shouldCancelWhenOutside?: boolean;\n  userSelect?: UserSelect;\n  activeCursor?: ActiveCursor;\n\n  activateAfterLongPress?: number;\n  failOffsetXStart?: number;\n  failOffsetYStart?: number;\n  failOffsetXEnd?: number;\n  failOffsetYEnd?: number;\n  activeOffsetXStart?: number;\n  activeOffsetXEnd?: number;\n  activeOffsetYStart?: number;\n  activeOffsetYEnd?: number;\n  minPointers?: number;\n  maxPointers?: number;\n  minDist?: number;\n  minDistSq?: number;\n  minVelocity?: number;\n  minVelocityX?: number;\n  minVelocityY?: number;\n  minVelocitySq?: number;\n  maxDist?: number;\n  maxDistSq?: number;\n  numberOfPointers?: number;\n  minDurationMs?: number;\n  numberOfTaps?: number;\n  maxDurationMs?: number;\n  maxDelayMs?: number;\n  maxDeltaX?: number;\n  maxDeltaY?: number;\n  shouldActivateOnStart?: boolean;\n  disallowInterruption?: boolean;\n  direction?: Directions;\n}\n\ntype NativeEventArgs = number | State | boolean | undefined;\ninterface NativeEvent extends Record<string, NativeEventArgs> {\n  numberOfPointers: number;\n  state: State;\n  pointerInside: boolean | undefined;\n  handlerTag: number;\n  target: number;\n  oldState?: State;\n}\n\nexport interface PointerData {\n  id: number;\n  x: number;\n  y: number;\n  absoluteX: number;\n  absoluteY: number;\n}\n\ntype TouchNativeArgs = number | State | TouchEventType | PointerData[];\n\ninterface NativeTouchEvent extends Record<string, TouchNativeArgs> {\n  handlerTag: number;\n  state: State;\n  eventType: TouchEventType;\n  changedTouches: PointerData[];\n  allTouches: PointerData[];\n  numberOfTouches: number;\n}\n\nexport interface ResultEvent extends Record<string, NativeEvent | number> {\n  nativeEvent: NativeEvent;\n  timeStamp: number;\n}\n\nexport interface ResultTouchEvent\n  extends Record<string, NativeTouchEvent | number> {\n  nativeEvent: NativeTouchEvent;\n  timeStamp: number;\n}\n\nexport interface PropsRef {\n  onGestureHandlerEvent: () => void;\n  onGestureHandlerStateChange: () => void;\n}\n\nexport interface AdaptedEvent {\n  x: number;\n  y: number;\n  offsetX: number;\n  offsetY: number;\n  pointerId: number;\n  eventType: EventTypes;\n  pointerType: PointerType;\n  buttons: number;\n  time: number;\n  allTouches?: TouchList;\n  changedTouches?: TouchList;\n  touchEventType?: TouchEventType;\n}\n\nexport enum MouseButtons {\n  NONE,\n  LEFT,\n  RIGHT,\n  LEFT_RIGHT,\n  SCROLL,\n  SCROLL_LEFT,\n  SCROLL_RIGHT,\n  SCROLL_LEFT_RIGHT,\n}\n\nexport enum EventTypes {\n  DOWN,\n  ADDITIONAL_POINTER_DOWN,\n  UP,\n  ADDITIONAL_POINTER_UP,\n  MOVE,\n  ENTER,\n  LEAVE,\n  CANCEL,\n}\n\nexport enum TouchEventType {\n  UNDETERMINED,\n  DOWN,\n  MOVE,\n  UP,\n  CANCELLED,\n}\n\nexport enum PointerType {\n  NONE = 'none',\n  MOUSE = 'mouse',\n  TOUCH = 'touch',\n  PEN = 'pen',\n}\n"],"mappings":";;;;;;IAkIYA,YAAY,GAAAC,OAAA,CAAAD,YAAA,0BAAZA,YAAY;EAAZA,YAAY,CAAZA,YAAY;EAAZA,YAAY,CAAZA,YAAY;EAAZA,YAAY,CAAZA,YAAY;EAAZA,YAAY,CAAZA,YAAY;EAAZA,YAAY,CAAZA,YAAY;EAAZA,YAAY,CAAZA,YAAY;EAAZA,YAAY,CAAZA,YAAY;EAAZA,YAAY,CAAZA,YAAY;EAAA,OAAZA,YAAY;AAAA;AAAA,IAWZE,UAAU,GAAAD,OAAA,CAAAC,UAAA,0BAAVA,UAAU;EAAVA,UAAU,CAAVA,UAAU;EAAVA,UAAU,CAAVA,UAAU;EAAVA,UAAU,CAAVA,UAAU;EAAVA,UAAU,CAAVA,UAAU;EAAVA,UAAU,CAAVA,UAAU;EAAVA,UAAU,CAAVA,UAAU;EAAVA,UAAU,CAAVA,UAAU;EAAVA,UAAU,CAAVA,UAAU;EAAA,OAAVA,UAAU;AAAA;AAAA,IAWVC,cAAc,GAAAF,OAAA,CAAAE,cAAA,0BAAdA,cAAc;EAAdA,cAAc,CAAdA,cAAc;EAAdA,cAAc,CAAdA,cAAc;EAAdA,cAAc,CAAdA,cAAc;EAAdA,cAAc,CAAdA,cAAc;EAAdA,cAAc,CAAdA,cAAc;EAAA,OAAdA,cAAc;AAAA;AAAA,IAQdC,WAAW,GAAAH,OAAA,CAAAG,WAAA,0BAAXA,WAAW;EAAXA,WAAW;EAAXA,WAAW;EAAXA,WAAW;EAAXA,WAAW;EAAA,OAAXA,WAAW;AAAA","ignoreList":[]}
+{"version":3,"names":["EventTypes","exports","TouchEventType","WheelDevice"],"sourceRoot":"../../../src","sources":["web/interfaces.ts"],"mappings":";;;;;;IA6JYA,UAAU,GAAAC,OAAA,CAAAD,UAAA,0BAAVA,UAAU;EAAVA,UAAU,CAAVA,UAAU;EAAVA,UAAU,CAAVA,UAAU;EAAVA,UAAU,CAAVA,UAAU;EAAVA,UAAU,CAAVA,UAAU;EAAVA,UAAU,CAAVA,UAAU;EAAVA,UAAU,CAAVA,UAAU;EAAVA,UAAU,CAAVA,UAAU;EAAVA,UAAU,CAAVA,UAAU;EAAA,OAAVA,UAAU;AAAA;AAAA,IAWVE,cAAc,GAAAD,OAAA,CAAAC,cAAA,0BAAdA,cAAc;EAAdA,cAAc,CAAdA,cAAc;EAAdA,cAAc,CAAdA,cAAc;EAAdA,cAAc,CAAdA,cAAc;EAAdA,cAAc,CAAdA,cAAc;EAAdA,cAAc,CAAdA,cAAc;EAAA,OAAdA,cAAc;AAAA;AAAA,IAQdC,WAAW,GAAAF,OAAA,CAAAE,WAAA,0BAAXA,WAAW;EAAXA,WAAW,CAAXA,WAAW;EAAXA,WAAW,CAAXA,WAAW;EAAXA,WAAW,CAAXA,WAAW;EAAA,OAAXA,WAAW;AAAA","ignoreList":[]}

package/lib/commonjs/web/tools/CircularBuffer.js

@@ -4,33 +4,23 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
-function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
-function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
-function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 class CircularBuffer {
   constructor(size) {
-    _defineProperty(this, "bufferSize", void 0);
-    _defineProperty(this, "buffer", void 0);
-    _defineProperty(this, "index", void 0);
-    _defineProperty(this, "actualSize", void 0);
-    this.bufferSize = size;
+    this.capacity = size;
     this.buffer = new Array(size);
     this.index = 0;
-    this.actualSize = 0;
-  }
-  get size() {
-    return this.actualSize;
+    this._size = 0;
   }
   push(element) {
     this.buffer[this.index] = element;
-    this.index = (this.index + 1) % this.bufferSize;
-    this.actualSize = Math.min(this.actualSize + 1, this.bufferSize);
+    this.index = (this.index + 1) % this.capacity;
+    this._size = Math.min(this.size + 1, this.capacity);
   }
   get(at) {
-    if (this.actualSize === this.bufferSize) {
-      let index = (this.index + at) % this.bufferSize;
+    if (this._size === this.capacity) {
+      let index = (this.index + at) % this.capacity;
       if (index < 0) {
-        index += this.bufferSize;
+        index += this.capacity;
       }
       return this.buffer[index];
     } else {
@@ -38,9 +28,12 @@ class CircularBuffer {
     }
   }
   clear() {
-    this.buffer = new Array(this.bufferSize);
+    this.buffer = new Array(this.capacity);
     this.index = 0;
-    this.actualSize = 0;
+    this._size = 0;
+  }
+  get size() {
+    return this._size;
   }
 }
 exports.default = CircularBuffer;

package/lib/commonjs/web/tools/CircularBuffer.js.map

@@ -1 +1 @@
-{"version":3,"names":["CircularBuffer","constructor","size","_defineProperty","bufferSize","buffer","Array","index","actualSize","push","element","Math","min","get","at","clear","exports","default"],"sources":["CircularBuffer.ts"],"sourcesContent":["export default class CircularBuffer<T> {\n  private bufferSize: number;\n  private buffer: T[];\n  private index: number;\n  private actualSize: number;\n\n  constructor(size: number) {\n    this.bufferSize = size;\n    this.buffer = new Array<T>(size);\n    this.index = 0;\n    this.actualSize = 0;\n  }\n\n  public get size(): number {\n    return this.actualSize;\n  }\n\n  public push(element: T): void {\n    this.buffer[this.index] = element;\n    this.index = (this.index + 1) % this.bufferSize;\n    this.actualSize = Math.min(this.actualSize + 1, this.bufferSize);\n  }\n\n  public get(at: number): T {\n    if (this.actualSize === this.bufferSize) {\n      let index = (this.index + at) % this.bufferSize;\n      if (index < 0) {\n        index += this.bufferSize;\n      }\n\n      return this.buffer[index];\n    } else {\n      return this.buffer[at];\n    }\n  }\n\n  public clear(): void {\n    this.buffer = new Array<T>(this.bufferSize);\n    this.index = 0;\n    this.actualSize = 0;\n  }\n}\n"],"mappings":";;;;;;;;;AAAe,MAAMA,cAAc,CAAI;EAMrCC,WAAWA,CAACC,IAAY,EAAE;IAAAC,eAAA;IAAAA,eAAA;IAAAA,eAAA;IAAAA,eAAA;IACxB,IAAI,CAACC,UAAU,GAAGF,IAAI;IACtB,IAAI,CAACG,MAAM,GAAG,IAAIC,KAAK,CAAIJ,IAAI,CAAC;IAChC,IAAI,CAACK,KAAK,GAAG,CAAC;IACd,IAAI,CAACC,UAAU,GAAG,CAAC;EACrB;EAEA,IAAWN,IAAIA,CAAA,EAAW;IACxB,OAAO,IAAI,CAACM,UAAU;EACxB;EAEOC,IAAIA,CAACC,OAAU,EAAQ;IAC5B,IAAI,CAACL,MAAM,CAAC,IAAI,CAACE,KAAK,CAAC,GAAGG,OAAO;IACjC,IAAI,CAACH,KAAK,GAAG,CAAC,IAAI,CAACA,KAAK,GAAG,CAAC,IAAI,IAAI,CAACH,UAAU;IAC/C,IAAI,CAACI,UAAU,GAAGG,IAAI,CAACC,GAAG,CAAC,IAAI,CAACJ,UAAU,GAAG,CAAC,EAAE,IAAI,CAACJ,UAAU,CAAC;EAClE;EAEOS,GAAGA,CAACC,EAAU,EAAK;IACxB,IAAI,IAAI,CAACN,UAAU,KAAK,IAAI,CAACJ,UAAU,EAAE;MACvC,IAAIG,KAAK,GAAG,CAAC,IAAI,CAACA,KAAK,GAAGO,EAAE,IAAI,IAAI,CAACV,UAAU;MAC/C,IAAIG,KAAK,GAAG,CAAC,EAAE;QACbA,KAAK,IAAI,IAAI,CAACH,UAAU;MAC1B;MAEA,OAAO,IAAI,CAACC,MAAM,CAACE,KAAK,CAAC;IAC3B,CAAC,MAAM;MACL,OAAO,IAAI,CAACF,MAAM,CAACS,EAAE,CAAC;IACxB;EACF;EAEOC,KAAKA,CAAA,EAAS;IACnB,IAAI,CAACV,MAAM,GAAG,IAAIC,KAAK,CAAI,IAAI,CAACF,UAAU,CAAC;IAC3C,IAAI,CAACG,KAAK,GAAG,CAAC;IACd,IAAI,CAACC,UAAU,GAAG,CAAC;EACrB;AACF;AAACQ,OAAA,CAAAC,OAAA,GAAAjB,cAAA","ignoreList":[]}
+{"version":3,"names":["CircularBuffer","constructor","size","capacity","buffer","Array","index","_size","push","element","Math","min","get","at","clear","exports","default"],"sourceRoot":"../../../../src","sources":["web/tools/CircularBuffer.ts"],"mappings":";;;;;;AAAe,MAAMA,cAAc,CAAI;EAMrCC,WAAWA,CAACC,IAAY,EAAE;IACxB,IAAI,CAACC,QAAQ,GAAGD,IAAI;IACpB,IAAI,CAACE,MAAM,GAAG,IAAIC,KAAK,CAAIH,IAAI,CAAC;IAChC,IAAI,CAACI,KAAK,GAAG,CAAC;IACd,IAAI,CAACC,KAAK,GAAG,CAAC;EAChB;EAEOC,IAAIA,CAACC,OAAU,EAAQ;IAC5B,IAAI,CAACL,MAAM,CAAC,IAAI,CAACE,KAAK,CAAC,GAAGG,OAAO;IACjC,IAAI,CAACH,KAAK,GAAG,CAAC,IAAI,CAACA,KAAK,GAAG,CAAC,IAAI,IAAI,CAACH,QAAQ;IAC7C,IAAI,CAACI,KAAK,GAAGG,IAAI,CAACC,GAAG,CAAC,IAAI,CAACT,IAAI,GAAG,CAAC,EAAE,IAAI,CAACC,QAAQ,CAAC;EACrD;EAEOS,GAAGA,CAACC,EAAU,EAAK;IACxB,IAAI,IAAI,CAACN,KAAK,KAAK,IAAI,CAACJ,QAAQ,EAAE;MAChC,IAAIG,KAAK,GAAG,CAAC,IAAI,CAACA,KAAK,GAAGO,EAAE,IAAI,IAAI,CAACV,QAAQ;MAC7C,IAAIG,KAAK,GAAG,CAAC,EAAE;QACbA,KAAK,IAAI,IAAI,CAACH,QAAQ;MACxB;MAEA,OAAO,IAAI,CAACC,MAAM,CAACE,KAAK,CAAC;IAC3B,CAAC,MAAM;MACL,OAAO,IAAI,CAACF,MAAM,CAACS,EAAE,CAAC;IACxB;EACF;EAEOC,KAAKA,CAAA,EAAS;IACnB,IAAI,CAACV,MAAM,GAAG,IAAIC,KAAK,CAAI,IAAI,CAACF,QAAQ,CAAC;IACzC,IAAI,CAACG,KAAK,GAAG,CAAC;IACd,IAAI,CAACC,KAAK,GAAG,CAAC;EAChB;EAEA,IAAWL,IAAIA,CAAA,EAAG;IAChB,OAAO,IAAI,CAACK,KAAK;EACnB;AACF;AAACQ,OAAA,CAAAC,OAAA,GAAAhB,cAAA","ignoreList":[]}

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

@@ -4,16 +4,11 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
-function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
-function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
-function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 /* eslint-disable @typescript-eslint/no-empty-function */
 
 class EventManager {
+  pointersInBounds = [];
   constructor(view) {
-    _defineProperty(this, "view", void 0);
-    _defineProperty(this, "pointersInBounds", []);
-    _defineProperty(this, "activePointersCounter", void 0);
     this.view = view;
     this.activePointersCounter = 0;
   }
@@ -22,8 +17,8 @@ class EventManager {
   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)
+  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
@@ -33,6 +28,7 @@ class EventManager {
   onPointerOutOfBounds(_event) {}
   onPointerMoveOver(_event) {}
   onPointerMoveOut(_event) {}
+  onWheel(_event) {}
   setOnPointerDown(callback) {
     this.onPointerDown = callback;
   }
@@ -66,6 +62,9 @@ class EventManager {
   setOnPointerMoveOut(callback) {
     this.onPointerMoveOut = callback;
   }
+  setOnWheel(callback) {
+    this.onWheel = callback;
+  }
   markAsInBounds(pointerId) {
     if (this.pointersInBounds.indexOf(pointerId) >= 0) {
       return;

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

@@ -1 +1 @@
-{"version":3,"names":["EventManager","constructor","view","_defineProperty","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","exports","default"],"sources":["EventManager.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-empty-function */\nimport { AdaptedEvent, EventTypes, TouchEventType } from '../interfaces';\n\nexport default abstract class EventManager<T> {\n  protected readonly view: T;\n  protected pointersInBounds: number[] = [];\n  protected activePointersCounter: number;\n\n  constructor(view: T) {\n    this.view = view;\n    this.activePointersCounter = 0;\n  }\n\n  public abstract setListeners(): void;\n  protected abstract mapEvent(\n    event: Event,\n    eventType: EventTypes,\n    index?: number,\n    touchEventType?: TouchEventType\n  ): AdaptedEvent;\n\n  protected onPointerDown(_event: AdaptedEvent): void {}\n  protected onPointerAdd(_event: AdaptedEvent): void {}\n  protected onPointerUp(_event: AdaptedEvent): void {}\n  protected onPointerRemove(_event: AdaptedEvent): void {}\n  protected onPointerMove(_event: AdaptedEvent): void {}\n  protected onPointerLeave(_event: AdaptedEvent): void {} // called only when pointer is pressed (or touching)\n  protected onPointerEnter(_event: AdaptedEvent): void {} // called only when pointer is pressed (or touching)\n  protected onPointerCancel(_event: AdaptedEvent): void {\n    // When pointer cancel is triggered and there are more pointers on the view, only one pointer is cancelled\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\n    // Events that correspond to removing the pointer (pointerup, touchend) have condition, that they don't perform any action when activePointersCounter\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\n  }\n  protected onPointerOutOfBounds(_event: AdaptedEvent): void {}\n  protected onPointerMoveOver(_event: AdaptedEvent): void {}\n  protected onPointerMoveOut(_event: AdaptedEvent): void {}\n\n  public setOnPointerDown(callback: (event: AdaptedEvent) => void): void {\n    this.onPointerDown = callback;\n  }\n  public setOnPointerAdd(callback: (event: AdaptedEvent) => void): void {\n    this.onPointerAdd = callback;\n  }\n  public setOnPointerUp(callback: (event: AdaptedEvent) => void): void {\n    this.onPointerUp = callback;\n  }\n  public setOnPointerRemove(callback: (event: AdaptedEvent) => void): void {\n    this.onPointerRemove = callback;\n  }\n  public setOnPointerMove(callback: (event: AdaptedEvent) => void): void {\n    this.onPointerMove = callback;\n  }\n  public setOnPointerLeave(callback: (event: AdaptedEvent) => void): void {\n    this.onPointerLeave = callback;\n  }\n  public setOnPointerEnter(callback: (event: AdaptedEvent) => void): void {\n    this.onPointerEnter = callback;\n  }\n  public setOnPointerCancel(callback: (event: AdaptedEvent) => void): void {\n    this.onPointerCancel = callback;\n  }\n  public setOnPointerOutOfBounds(\n    callback: (event: AdaptedEvent) => void\n  ): void {\n    this.onPointerOutOfBounds = callback;\n  }\n  public setOnPointerMoveOver(callback: (event: AdaptedEvent) => void): void {\n    this.onPointerMoveOver = callback;\n  }\n  public setOnPointerMoveOut(callback: (event: AdaptedEvent) => void): void {\n    this.onPointerMoveOut = callback;\n  }\n\n  protected markAsInBounds(pointerId: number): void {\n    if (this.pointersInBounds.indexOf(pointerId) >= 0) {\n      return;\n    }\n\n    this.pointersInBounds.push(pointerId);\n  }\n\n  protected markAsOutOfBounds(pointerId: number): void {\n    const index: number = this.pointersInBounds.indexOf(pointerId);\n\n    if (index < 0) {\n      return;\n    }\n\n    this.pointersInBounds.splice(index, 1);\n  }\n\n  public resetManager(): void {\n    // Reseting activePointersCounter is necessary to make gestures such as pinch work properly\n    // There are gestures that end when there is still one active pointer (like pinch/rotation)\n    // When these gestures end, they are reset, but they still receive events from pointer that is active\n    // This causes trouble, since only onPointerDown registers gesture in orchestrator, and while gestures receive\n    // Events from active pointer after they finished, next pointerdown event will be registered as additional pointer, not the first one\n    // This casues trouble like gestures getting stuck in END state, even though they should have gone to UNDETERMINED\n\n    this.activePointersCounter = 0;\n    this.pointersInBounds = [];\n  }\n}\n"],"mappings":";;;;;;;;;AAAA;;AAGe,MAAeA,YAAY,CAAI;EAK5CC,WAAWA,CAACC,IAAO,EAAE;IAAAC,eAAA;IAAAA,eAAA,2BAHkB,EAAE;IAAAA,eAAA;IAIvC,IAAI,CAACD,IAAI,GAAGA,IAAI;IAChB,IAAI,CAACE,qBAAqB,GAAG,CAAC;EAChC;EAUUC,aAAaA,CAACC,MAAoB,EAAQ,CAAC;EAC3CC,YAAYA,CAACD,MAAoB,EAAQ,CAAC;EAC1CE,WAAWA,CAACF,MAAoB,EAAQ,CAAC;EACzCG,eAAeA,CAACH,MAAoB,EAAQ,CAAC;EAC7CI,aAAaA,CAACJ,MAAoB,EAAQ,CAAC;EAC3CK,cAAcA,CAACL,MAAoB,EAAQ,CAAC,CAAC,CAAC;EAC9CM,cAAcA,CAACN,MAAoB,EAAQ,CAAC,CAAC,CAAC;EAC9CO,eAAeA,CAACP,MAAoB,EAAQ;IACpD;IACA;IACA;IACA;EAAA;EAEQQ,oBAAoBA,CAACR,MAAoB,EAAQ,CAAC;EAClDS,iBAAiBA,CAACT,MAAoB,EAAQ,CAAC;EAC/CU,gBAAgBA,CAACV,MAAoB,EAAQ,CAAC;EAEjDW,gBAAgBA,CAACC,QAAuC,EAAQ;IACrE,IAAI,CAACb,aAAa,GAAGa,QAAQ;EAC/B;EACOC,eAAeA,CAACD,QAAuC,EAAQ;IACpE,IAAI,CAACX,YAAY,GAAGW,QAAQ;EAC9B;EACOE,cAAcA,CAACF,QAAuC,EAAQ;IACnE,IAAI,CAACV,WAAW,GAAGU,QAAQ;EAC7B;EACOG,kBAAkBA,CAACH,QAAuC,EAAQ;IACvE,IAAI,CAACT,eAAe,GAAGS,QAAQ;EACjC;EACOI,gBAAgBA,CAACJ,QAAuC,EAAQ;IACrE,IAAI,CAACR,aAAa,GAAGQ,QAAQ;EAC/B;EACOK,iBAAiBA,CAACL,QAAuC,EAAQ;IACtE,IAAI,CAACP,cAAc,GAAGO,QAAQ;EAChC;EACOM,iBAAiBA,CAACN,QAAuC,EAAQ;IACtE,IAAI,CAACN,cAAc,GAAGM,QAAQ;EAChC;EACOO,kBAAkBA,CAACP,QAAuC,EAAQ;IACvE,IAAI,CAACL,eAAe,GAAGK,QAAQ;EACjC;EACOQ,uBAAuBA,CAC5BR,QAAuC,EACjC;IACN,IAAI,CAACJ,oBAAoB,GAAGI,QAAQ;EACtC;EACOS,oBAAoBA,CAACT,QAAuC,EAAQ;IACzE,IAAI,CAACH,iBAAiB,GAAGG,QAAQ;EACnC;EACOU,mBAAmBA,CAACV,QAAuC,EAAQ;IACxE,IAAI,CAACF,gBAAgB,GAAGE,QAAQ;EAClC;EAEUW,cAAcA,CAACC,SAAiB,EAAQ;IAChD,IAAI,IAAI,CAACC,gBAAgB,CAACC,OAAO,CAACF,SAAS,CAAC,IAAI,CAAC,EAAE;MACjD;IACF;IAEA,IAAI,CAACC,gBAAgB,CAACE,IAAI,CAACH,SAAS,CAAC;EACvC;EAEUI,iBAAiBA,CAACJ,SAAiB,EAAQ;IACnD,MAAMK,KAAa,GAAG,IAAI,CAACJ,gBAAgB,CAACC,OAAO,CAACF,SAAS,CAAC;IAE9D,IAAIK,KAAK,GAAG,CAAC,EAAE;MACb;IACF;IAEA,IAAI,CAACJ,gBAAgB,CAACK,MAAM,CAACD,KAAK,EAAE,CAAC,CAAC;EACxC;EAEOE,YAAYA,CAAA,EAAS;IAC1B;IACA;IACA;IACA;IACA;IACA;;IAEA,IAAI,CAACjC,qBAAqB,GAAG,CAAC;IAC9B,IAAI,CAAC2B,gBAAgB,GAAG,EAAE;EAC5B;AACF;AAACO,OAAA,CAAAC,OAAA,GAAAvC,YAAA","ignoreList":[]}
+{"version":3,"names":["EventManager","pointersInBounds","constructor","view","activePointersCounter","onPointerDown","_event","onPointerAdd","onPointerUp","onPointerRemove","onPointerMove","onPointerLeave","onPointerEnter","onPointerCancel","onPointerOutOfBounds","onPointerMoveOver","onPointerMoveOut","onWheel","setOnPointerDown","callback","setOnPointerAdd","setOnPointerUp","setOnPointerRemove","setOnPointerMove","setOnPointerLeave","setOnPointerEnter","setOnPointerCancel","setOnPointerOutOfBounds","setOnPointerMoveOver","setOnPointerMoveOut","setOnWheel","markAsInBounds","pointerId","indexOf","push","markAsOutOfBounds","index","splice","resetManager","exports","default"],"sourceRoot":"../../../../src","sources":["web/tools/EventManager.ts"],"mappings":"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","ignoreList":[]}

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

@@ -1 +1 @@
-{"version":3,"names":[],"sources":["GestureHandlerDelegate.ts"],"sourcesContent":["import type GestureHandler from '../handlers/GestureHandler';\n\nexport interface MeasureResult {\n  pageX: number;\n  pageY: number;\n  width: number;\n  height: number;\n}\n\nexport interface GestureHandlerDelegate<T> {\n  getView(): T;\n\n  init(viewRef: number, handler: GestureHandler): void;\n  isPointerInBounds({ x, y }: { x: number; y: number }): boolean;\n  measureView(): MeasureResult;\n  reset(): void;\n\n  onBegin(): void;\n  onActivate(): void;\n  onEnd(): void;\n  onCancel(): void;\n  onFail(): void;\n}\n"],"mappings":"","ignoreList":[]}
+{"version":3,"names":[],"sourceRoot":"../../../../src","sources":["web/tools/GestureHandlerDelegate.ts"],"mappings":"","ignoreList":[]}

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

@@ -4,24 +4,20 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
+var _PointerType = require("../../PointerType");
 var _State = require("../../State");
-var _interfaces = require("../interfaces");
 var _PointerTracker = _interopRequireDefault(require("./PointerTracker"));
-var _GestureHandlerOrchestrator;
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
-function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
-function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 class GestureHandlerOrchestrator {
+  gestureHandlers = [];
+  awaitingHandlers = [];
+  awaitingHandlersTags = new Set();
+  handlingChangeSemaphore = 0;
+  activationIndex = 0;
+
   // 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, "handlersToCancel", []);
-    _defineProperty(this, "handlingChangeSemaphore", 0);
-    _defineProperty(this, "activationIndex", 0);
-  }
+  constructor() {}
   scheduleFinishedHandlersCleanup() {
     if (this.handlingChangeSemaphore === 0) {
       this.cleanupFinishedHandlers();
@@ -29,98 +25,116 @@ class GestureHandlerOrchestrator {
   }
   cleanHandler(handler) {
     handler.reset();
-    handler.setActive(false);
-    handler.setAwaiting(false);
-    handler.setActivationIndex(Number.MAX_VALUE);
+    handler.active = false;
+    handler.awaiting = false;
+    handler.activationIndex = Number.MAX_VALUE;
   }
   removeHandlerFromOrchestrator(handler) {
-    this.gestureHandlers.splice(this.gestureHandlers.indexOf(handler), 1);
-    this.awaitingHandlers.splice(this.awaitingHandlers.indexOf(handler), 1);
-    this.handlersToCancel.splice(this.handlersToCancel.indexOf(handler), 1);
+    const indexInGestureHandlers = this.gestureHandlers.indexOf(handler);
+    const indexInAwaitingHandlers = this.awaitingHandlers.indexOf(handler);
+    if (indexInGestureHandlers >= 0) {
+      this.gestureHandlers.splice(indexInGestureHandlers, 1);
+    }
+    if (indexInAwaitingHandlers >= 0) {
+      this.awaitingHandlers.splice(indexInAwaitingHandlers, 1);
+      this.awaitingHandlersTags.delete(handler.handlerTag);
+    }
   }
   cleanupFinishedHandlers() {
+    const handlersToRemove = new Set();
     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);
+      if (this.isFinished(handler.state) && !handler.awaiting) {
         this.cleanHandler(handler);
+        handlersToRemove.add(handler);
       }
     }
+    this.gestureHandlers = this.gestureHandlers.filter(handler => !handlersToRemove.has(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;
+    const hasToWaitFor = otherHandler => {
+      return !this.isFinished(otherHandler.state) && this.shouldHandlerWaitForOther(handler, otherHandler);
+    };
+    return this.gestureHandlers.some(hasToWaitFor);
+  }
+  shouldBeCancelledByFinishedHandler(handler) {
+    const shouldBeCancelled = otherHandler => {
+      return this.shouldHandlerWaitForOther(handler, otherHandler) && otherHandler.state === _State.State.END;
+    };
+    return this.gestureHandlers.some(shouldBeCancelled);
   }
   tryActivate(handler) {
+    if (this.shouldBeCancelledByFinishedHandler(handler)) {
+      handler.cancel();
+      return;
+    }
     if (this.hasOtherHandlerToWaitFor(handler)) {
       this.addAwaitingHandler(handler);
-    } else if (handler.getState() !== _State.State.CANCELLED && handler.getState() !== _State.State.FAILED) {
-      if (this.shouldActivate(handler)) {
-        this.makeActive(handler);
-      } else {
-        switch (handler.getState()) {
-          case _State.State.ACTIVE:
-            handler.fail();
-            break;
-          case _State.State.BEGAN:
-            handler.cancel();
-        }
-      }
+      return;
+    }
+    const handlerState = handler.state;
+    if (handlerState === _State.State.CANCELLED || handlerState === _State.State.FAILED) {
+      return;
+    }
+    if (this.shouldActivate(handler)) {
+      this.makeActive(handler);
+      return;
+    }
+    if (handlerState === _State.State.ACTIVE) {
+      handler.fail();
+      return;
+    }
+    if (handlerState === _State.State.BEGAN) {
+      handler.cancel();
     }
   }
   shouldActivate(handler) {
-    for (const otherHandler of this.gestureHandlers) {
-      if (this.shouldHandlerBeCancelledBy(handler, otherHandler)) {
-        return false;
-      }
-    }
-    return true;
+    const shouldBeCancelledBy = otherHandler => {
+      return this.shouldHandlerBeCancelledBy(handler, otherHandler);
+    };
+    return !this.gestureHandlers.some(shouldBeCancelledBy);
   }
   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);
+    const shouldWait = otherHandler => {
+      return !otherHandler.awaiting && this.shouldHandlerWaitForOther(otherHandler, handler);
+    };
+    for (const otherHandler of this.awaitingHandlers) {
+      if (shouldWait(otherHandler)) {
+        this.cleanHandler(otherHandler);
+        this.awaitingHandlersTags.delete(otherHandler.handlerTag);
       }
     }
+    this.awaitingHandlers = this.awaitingHandlers.filter(otherHandler => this.awaitingHandlersTags.has(otherHandler.handlerTag));
   }
   onHandlerStateChange(handler, newState, oldState, sendIfDisabled) {
-    if (!handler.isEnabled() && !sendIfDisabled) {
+    if (!handler.enabled && !sendIfDisabled) {
       return;
     }
     this.handlingChangeSemaphore += 1;
     if (this.isFinished(newState)) {
-      this.awaitingHandlers.forEach(otherHandler => {
-        if (this.shouldHandlerWaitForOther(otherHandler, handler)) {
-          if (newState === _State.State.END) {
-            otherHandler === null || otherHandler === void 0 || otherHandler.cancel();
-            if (otherHandler.getState() === _State.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.State.CANCELLED, _State.State.BEGAN);
-            }
-            otherHandler === null || otherHandler === void 0 || otherHandler.setAwaiting(false);
-          } else {
-            this.tryActivate(otherHandler);
-          }
+      for (const otherHandler of this.awaitingHandlers) {
+        if (!this.shouldHandlerWaitForOther(otherHandler, handler) || !this.awaitingHandlersTags.has(otherHandler.handlerTag)) {
+          continue;
         }
-      });
+        if (newState !== _State.State.END) {
+          this.tryActivate(otherHandler);
+          continue;
+        }
+        otherHandler.cancel();
+        if (otherHandler.state === _State.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.State.CANCELLED, _State.State.BEGAN);
+        }
+        otherHandler.awaiting = false;
+      }
     }
     if (newState === _State.State.ACTIVE) {
       this.tryActivate(handler);
     } else if (oldState === _State.State.ACTIVE || oldState === _State.State.END) {
-      if (handler.isActive()) {
+      if (handler.active) {
         handler.sendEvent(newState, oldState);
       } else if (oldState === _State.State.ACTIVE && (newState === _State.State.CANCELLED || newState === _State.State.FAILED)) {
         handler.sendEvent(newState, _State.State.BEGAN);
@@ -130,32 +144,25 @@ class GestureHandlerOrchestrator {
     }
     this.handlingChangeSemaphore -= 1;
     this.scheduleFinishedHandlersCleanup();
-    if (this.awaitingHandlers.indexOf(handler) < 0) {
+    if (!this.awaitingHandlers.includes(handler)) {
       this.cleanupAwaitingHandlers(handler);
     }
   }
   makeActive(handler) {
-    const currentState = handler.getState();
-    handler.setActive(true);
-    handler.setShouldResetProgress(true);
-    handler.setActivationIndex(this.activationIndex++);
-    this.gestureHandlers.forEach(otherHandler => {
-      // Order of arguments is correct - we check whether current handler should cancel existing handlers
-
-      if (this.shouldHandlerBeCancelledBy(otherHandler, handler)) {
-        this.handlersToCancel.push(otherHandler);
+    const currentState = handler.state;
+    handler.active = true;
+    handler.shouldResetProgress = true;
+    handler.activationIndex = this.activationIndex++;
+    for (let i = this.gestureHandlers.length - 1; i >= 0; --i) {
+      if (this.shouldHandlerBeCancelledBy(this.gestureHandlers[i], handler)) {
+        this.gestureHandlers[i].cancel();
       }
-    });
-    for (let i = this.handlersToCancel.length - 1; i >= 0; --i) {
-      var _this$handlersToCance;
-      (_this$handlersToCance = this.handlersToCancel[i]) === null || _this$handlersToCance === void 0 || _this$handlersToCance.cancel();
     }
-    this.awaitingHandlers.forEach(otherHandler => {
+    for (const otherHandler of this.awaitingHandlers) {
       if (this.shouldHandlerBeCancelledBy(otherHandler, handler)) {
-        otherHandler === null || otherHandler === void 0 || otherHandler.cancel();
-        otherHandler === null || otherHandler === void 0 || otherHandler.setAwaiting(true);
+        otherHandler.awaiting = false;
       }
-    });
+    }
     handler.sendEvent(_State.State.ACTIVE, _State.State.BEGAN);
     if (currentState !== _State.State.ACTIVE) {
       handler.sendEvent(_State.State.END, _State.State.ACTIVE);
@@ -163,46 +170,29 @@ class GestureHandlerOrchestrator {
         handler.sendEvent(_State.State.UNDETERMINED, _State.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);
-        }
-      }
+    if (!handler.awaiting) {
+      return;
     }
-    this.handlersToCancel = [];
+    handler.awaiting = false;
+    this.awaitingHandlers = this.awaitingHandlers.filter(otherHandler => otherHandler !== handler);
   }
   addAwaitingHandler(handler) {
-    let alreadyExists = false;
-    this.awaitingHandlers.forEach(otherHandler => {
-      if (otherHandler === handler) {
-        alreadyExists = true;
-        return;
-      }
-    });
-    if (alreadyExists) {
+    if (this.awaitingHandlers.includes(handler)) {
       return;
     }
     this.awaitingHandlers.push(handler);
-    handler.setAwaiting(true);
-    handler.setActivationIndex(this.activationIndex++);
+    this.awaitingHandlersTags.add(handler.handlerTag);
+    handler.awaiting = true;
+    handler.activationIndex = this.activationIndex++;
   }
   recordHandlerIfNotPresent(handler) {
-    let alreadyExists = false;
-    this.gestureHandlers.forEach(otherHandler => {
-      if (otherHandler === handler) {
-        alreadyExists = true;
-        return;
-      }
-    });
-    if (alreadyExists) {
+    if (this.gestureHandlers.includes(handler)) {
       return;
     }
     this.gestureHandlers.push(handler);
-    handler.setActive(false);
-    handler.setAwaiting(false);
-    handler.setActivationIndex(Number.MAX_SAFE_INTEGER);
+    handler.active = false;
+    handler.awaiting = false;
+    handler.activationIndex = Number.MAX_SAFE_INTEGER;
   }
   shouldHandlerWaitForOther(handler, otherHandler) {
     return handler !== otherHandler && (handler.shouldWaitForHandlerFailure(otherHandler) || otherHandler.shouldRequireToWaitForFailure(handler));
@@ -214,13 +204,12 @@ class GestureHandlerOrchestrator {
     if (this.canRunSimultaneously(handler, otherHandler)) {
       return false;
     }
-    if (handler !== otherHandler && (handler.isAwaiting() || handler.getState() === _State.State.ACTIVE)) {
-      // For now it always returns false
+    if (handler.awaiting || handler.state === _State.State.ACTIVE) {
       return handler.shouldBeCancelledByOther(otherHandler);
     }
     const handlerPointers = handler.getTrackedPointersID();
     const otherPointers = otherHandler.getTrackedPointersID();
-    if (!_PointerTracker.default.shareCommonPointers(handlerPointers, otherPointers) && handler.getDelegate().getView() !== otherHandler.getDelegate().getView()) {
+    if (!_PointerTracker.default.shareCommonPointers(handlerPointers, otherPointers) && handler.delegate.view !== otherHandler.delegate.view) {
       return this.checkOverlap(handler, otherHandler);
     }
     return true;
@@ -232,36 +221,11 @@ class GestureHandlerOrchestrator {
 
     // 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;
+    const isPointerWithinBothBounds = pointer => {
+      const point = handler.tracker.getLastAbsoluteCoords(pointer);
+      return point && handler.delegate.isPointerInBounds(point) && otherHandler.delegate.isPointerInBounds(point);
+    };
+    return handler.getTrackedPointersID().some(isPointerWithinBothBounds);
   }
   isFinished(state) {
     return state === _State.State.END || state === _State.State.FAILED || state === _State.State.CANCELLED;
@@ -275,7 +239,7 @@ class GestureHandlerOrchestrator {
   // 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() !== _interfaces.PointerType.MOUSE && handler.getPointerType() !== _interfaces.PointerType.PEN) {
+      if (handler.pointerType !== _PointerType.PointerType.MOUSE && handler.pointerType !== _PointerType.PointerType.STYLUS) {
         return;
       }
       if (handler !== currentHandler) {
@@ -288,18 +252,16 @@ class GestureHandlerOrchestrator {
         //
         // 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();
+        handler.tracker.resetTracker();
       }
     });
   }
-  static getInstance() {
-    if (!GestureHandlerOrchestrator.instance) {
-      GestureHandlerOrchestrator.instance = new GestureHandlerOrchestrator();
+  static get instance() {
+    if (!GestureHandlerOrchestrator._instance) {
+      GestureHandlerOrchestrator._instance = new GestureHandlerOrchestrator();
     }
-    return GestureHandlerOrchestrator.instance;
+    return GestureHandlerOrchestrator._instance;
   }
 }
 exports.default = GestureHandlerOrchestrator;
-_GestureHandlerOrchestrator = GestureHandlerOrchestrator;
-_defineProperty(GestureHandlerOrchestrator, "instance", void 0);
 //# sourceMappingURL=GestureHandlerOrchestrator.js.map