react-native-gesture-handler 2.5.0 → 2.6.0

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

@@ -0,0 +1,169 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _interfaces = require("../interfaces");
+
+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; }
+
+class EventManager {
+  constructor(view) {
+    _defineProperty(this, "activePointers", []);
+
+    _defineProperty(this, "view", void 0);
+
+    this.view = view;
+  }
+
+  setListeners() {
+    this.view.addEventListener('pointerdown', event => {
+      if (!this.isPointerInBounds({
+        x: event.clientX,
+        y: event.clientY
+      })) {
+        return;
+      }
+
+      const adaptedEvent = this.mapEvent(event, _interfaces.EventTypes.DOWN);
+      const target = event.target;
+      target.setPointerCapture(adaptedEvent.pointerId);
+      this.addActivePointer(adaptedEvent.pointerId);
+      this.onPointerDown(adaptedEvent);
+    });
+    this.view.addEventListener('pointerup', event => {
+      const adaptedEvent = this.mapEvent(event, _interfaces.EventTypes.UP);
+      const target = event.target;
+      this.onPointerUp(adaptedEvent);
+      target.releasePointerCapture(adaptedEvent.pointerId);
+      this.removeActivePointer(adaptedEvent.pointerId);
+    });
+    this.view.addEventListener('pointermove', event => {
+      if (event.pointerType === 'mouse' && event.buttons !== _interfaces.MouseButtons.LEFT) {
+        return;
+      }
+
+      const adaptedEvent = this.mapEvent(event, _interfaces.EventTypes.MOVE);
+      const inBounds = this.isPointerInBounds({
+        x: adaptedEvent.x,
+        y: adaptedEvent.y
+      });
+      const pointerIndex = this.activePointers.indexOf(adaptedEvent.pointerId);
+
+      if (inBounds) {
+        if (pointerIndex < 0) {
+          adaptedEvent.eventType = _interfaces.EventTypes.ENTER;
+          this.onPointerEnter(adaptedEvent);
+          this.addActivePointer(adaptedEvent.pointerId);
+        } else {
+          this.onPointerMove(adaptedEvent);
+        }
+      } else {
+        if (pointerIndex >= 0) {
+          adaptedEvent.eventType = _interfaces.EventTypes.OUT;
+          this.onPointerOut(adaptedEvent);
+          this.removeActivePointer(adaptedEvent.pointerId);
+        } else {
+          this.onPointerOutOfBounds(adaptedEvent);
+        }
+      }
+    });
+    this.view.addEventListener('pointercancel', event => {
+      event.preventDefault();
+      const adaptedEvent = this.mapEvent(event, _interfaces.EventTypes.CANCEL);
+      this.onPointerCancel(adaptedEvent);
+    });
+  }
+
+  onPointerDown(_event) {}
+
+  onPointerUp(_event) {}
+
+  onPointerMove(_event) {}
+
+  onPointerOut(_event) {}
+
+  onPointerEnter(_event) {}
+
+  onPointerCancel(_event) {}
+
+  onPointerOutOfBounds(_event) {}
+
+  setOnPointerDown(callback) {
+    this.onPointerDown = callback;
+  }
+
+  setOnPointerUp(callback) {
+    this.onPointerUp = callback;
+  }
+
+  setOnPointerMove(callback) {
+    this.onPointerMove = callback;
+  }
+
+  setOnPointerOut(callback) {
+    this.onPointerOut = callback;
+  }
+
+  setOnPointerEnter(callback) {
+    this.onPointerEnter = callback;
+  }
+
+  setOnPointerCancel(callback) {
+    this.onPointerCancel = callback;
+  }
+
+  setOnPointerOutOfBounds(callback) {
+    this.onPointerOutOfBounds = callback;
+  }
+
+  mapEvent(event, eventType) {
+    return {
+      x: event.clientX,
+      y: event.clientY,
+      offsetX: event.offsetX,
+      offsetY: event.offsetY,
+      pointerId: event.pointerId,
+      eventType: eventType,
+      pointerType: event.pointerType,
+      buttons: event.buttons,
+      time: event.timeStamp
+    };
+  }
+
+  isPointerInBounds({
+    x,
+    y
+  }) {
+    if (!this.view) {
+      return false;
+    }
+
+    const rect = this.view.getBoundingClientRect();
+    return x >= rect.left && x <= rect.right && y >= rect.top && y <= rect.bottom;
+  }
+
+  addActivePointer(pointerId) {
+    if (this.activePointers.indexOf(pointerId) >= 0) {
+      return;
+    }
+
+    this.activePointers.push(pointerId);
+  }
+
+  removeActivePointer(pointerId) {
+    const index = this.activePointers.indexOf(pointerId);
+
+    if (index < 0) {
+      return;
+    }
+
+    this.activePointers.splice(index, 1);
+  }
+
+}
+
+exports.default = EventManager;
+//# sourceMappingURL=EventManager.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["EventManager.ts"],"names":["EventManager","constructor","view","setListeners","addEventListener","event","isPointerInBounds","x","clientX","y","clientY","adaptedEvent","mapEvent","EventTypes","DOWN","target","setPointerCapture","pointerId","addActivePointer","onPointerDown","UP","onPointerUp","releasePointerCapture","removeActivePointer","pointerType","buttons","MouseButtons","LEFT","MOVE","inBounds","pointerIndex","activePointers","indexOf","eventType","ENTER","onPointerEnter","onPointerMove","OUT","onPointerOut","onPointerOutOfBounds","preventDefault","CANCEL","onPointerCancel","_event","setOnPointerDown","callback","setOnPointerUp","setOnPointerMove","setOnPointerOut","setOnPointerEnter","setOnPointerCancel","setOnPointerOutOfBounds","offsetX","offsetY","time","timeStamp","rect","getBoundingClientRect","left","right","top","bottom","push","index","splice"],"mappings":";;;;;;;AAEA;;;;AAEe,MAAMA,YAAN,CAAmB;AAIhCC,EAAAA,WAAW,CAACC,IAAD,EAAoB;AAAA,4CAHI,EAGJ;;AAAA;;AAC7B,SAAKA,IAAL,GAAYA,IAAZ;AACD;;AAEMC,EAAAA,YAAY,GAAG;AACpB,SAAKD,IAAL,CAAUE,gBAAV,CAA2B,aAA3B,EAA2CC,KAAD,IAA+B;AACvE,UACE,CAAC,KAAKC,iBAAL,CAAuB;AACtBC,QAAAA,CAAC,EAAEF,KAAK,CAACG,OADa;AAEtBC,QAAAA,CAAC,EAAEJ,KAAK,CAACK;AAFa,OAAvB,CADH,EAKE;AACA;AACD;;AAED,YAAMC,YAAiC,GAAG,KAAKC,QAAL,CACxCP,KADwC,EAExCQ,uBAAWC,IAF6B,CAA1C;AAIA,YAAMC,MAAM,GAAGV,KAAK,CAACU,MAArB;AAEAA,MAAAA,MAAM,CAACC,iBAAP,CAAyBL,YAAY,CAACM,SAAtC;AACA,WAAKC,gBAAL,CAAsBP,YAAY,CAACM,SAAnC;AACA,WAAKE,aAAL,CAAmBR,YAAnB;AACD,KAnBD;AAqBA,SAAKT,IAAL,CAAUE,gBAAV,CAA2B,WAA3B,EAAyCC,KAAD,IAA+B;AACrE,YAAMM,YAAiC,GAAG,KAAKC,QAAL,CACxCP,KADwC,EAExCQ,uBAAWO,EAF6B,CAA1C;AAIA,YAAML,MAAM,GAAGV,KAAK,CAACU,MAArB;AAEA,WAAKM,WAAL,CAAiBV,YAAjB;AACAI,MAAAA,MAAM,CAACO,qBAAP,CAA6BX,YAAY,CAACM,SAA1C;AACA,WAAKM,mBAAL,CAAyBZ,YAAY,CAACM,SAAtC;AACD,KAVD;AAYA,SAAKf,IAAL,CAAUE,gBAAV,CAA2B,aAA3B,EAA2CC,KAAD,IAA+B;AACvE,UACEA,KAAK,CAACmB,WAAN,KAAsB,OAAtB,IACAnB,KAAK,CAACoB,OAAN,KAAkBC,yBAAaC,IAFjC,EAGE;AACA;AACD;;AAED,YAAMhB,YAAiC,GAAG,KAAKC,QAAL,CACxCP,KADwC,EAExCQ,uBAAWe,IAF6B,CAA1C;AAKA,YAAMC,QAAiB,GAAG,KAAKvB,iBAAL,CAAuB;AAC/CC,QAAAA,CAAC,EAAEI,YAAY,CAACJ,CAD+B;AAE/CE,QAAAA,CAAC,EAAEE,YAAY,CAACF;AAF+B,OAAvB,CAA1B;AAKA,YAAMqB,YAAoB,GAAG,KAAKC,cAAL,CAAoBC,OAApB,CAC3BrB,YAAY,CAACM,SADc,CAA7B;;AAIA,UAAIY,QAAJ,EAAc;AACZ,YAAIC,YAAY,GAAG,CAAnB,EAAsB;AACpBnB,UAAAA,YAAY,CAACsB,SAAb,GAAyBpB,uBAAWqB,KAApC;AACA,eAAKC,cAAL,CAAoBxB,YAApB;AACA,eAAKO,gBAAL,CAAsBP,YAAY,CAACM,SAAnC;AACD,SAJD,MAIO;AACL,eAAKmB,aAAL,CAAmBzB,YAAnB;AACD;AACF,OARD,MAQO;AACL,YAAImB,YAAY,IAAI,CAApB,EAAuB;AACrBnB,UAAAA,YAAY,CAACsB,SAAb,GAAyBpB,uBAAWwB,GAApC;AACA,eAAKC,YAAL,CAAkB3B,YAAlB;AACA,eAAKY,mBAAL,CAAyBZ,YAAY,CAACM,SAAtC;AACD,SAJD,MAIO;AACL,eAAKsB,oBAAL,CAA0B5B,YAA1B;AACD;AACF;AACF,KAvCD;AAyCA,SAAKT,IAAL,CAAUE,gBAAV,CAA2B,eAA3B,EAA6CC,KAAD,IAA+B;AACzEA,MAAAA,KAAK,CAACmC,cAAN;AAEA,YAAM7B,YAAiC,GAAG,KAAKC,QAAL,CACxCP,KADwC,EAExCQ,uBAAW4B,MAF6B,CAA1C;AAKA,WAAKC,eAAL,CAAqB/B,YAArB;AACD,KATD;AAUD;;AAEOQ,EAAAA,aAAa,CAACwB,MAAD,EAAoC,CAAE;;AACnDtB,EAAAA,WAAW,CAACsB,MAAD,EAAoC,CAAE;;AACjDP,EAAAA,aAAa,CAACO,MAAD,EAAoC,CAAE;;AACnDL,EAAAA,YAAY,CAACK,MAAD,EAAoC,CAAE;;AAClDR,EAAAA,cAAc,CAACQ,MAAD,EAAoC,CAAE;;AACpDD,EAAAA,eAAe,CAACC,MAAD,EAAoC,CAAE;;AACrDJ,EAAAA,oBAAoB,CAACI,MAAD,EAAoC,CAAE;;AAE3DC,EAAAA,gBAAgB,CACrBC,QADqB,EAEf;AACN,SAAK1B,aAAL,GAAqB0B,QAArB;AACD;;AACMC,EAAAA,cAAc,CAACD,QAAD,EAAuD;AAC1E,SAAKxB,WAAL,GAAmBwB,QAAnB;AACD;;AACME,EAAAA,gBAAgB,CACrBF,QADqB,EAEf;AACN,SAAKT,aAAL,GAAqBS,QAArB;AACD;;AACMG,EAAAA,eAAe,CAACH,QAAD,EAAuD;AAC3E,SAAKP,YAAL,GAAoBO,QAApB;AACD;;AACMI,EAAAA,iBAAiB,CACtBJ,QADsB,EAEhB;AACN,SAAKV,cAAL,GAAsBU,QAAtB;AACD;;AACMK,EAAAA,kBAAkB,CACvBL,QADuB,EAEjB;AACN,SAAKH,eAAL,GAAuBG,QAAvB;AACD;;AACMM,EAAAA,uBAAuB,CAC5BN,QAD4B,EAEtB;AACN,SAAKN,oBAAL,GAA4BM,QAA5B;AACD;;AAEOjC,EAAAA,QAAQ,CACdP,KADc,EAEd4B,SAFc,EAGO;AACrB,WAAO;AACL1B,MAAAA,CAAC,EAAEF,KAAK,CAACG,OADJ;AAELC,MAAAA,CAAC,EAAEJ,KAAK,CAACK,OAFJ;AAGL0C,MAAAA,OAAO,EAAE/C,KAAK,CAAC+C,OAHV;AAILC,MAAAA,OAAO,EAAEhD,KAAK,CAACgD,OAJV;AAKLpC,MAAAA,SAAS,EAAEZ,KAAK,CAACY,SALZ;AAMLgB,MAAAA,SAAS,EAAEA,SANN;AAOLT,MAAAA,WAAW,EAAEnB,KAAK,CAACmB,WAPd;AAQLC,MAAAA,OAAO,EAAEpB,KAAK,CAACoB,OARV;AASL6B,MAAAA,IAAI,EAAEjD,KAAK,CAACkD;AATP,KAAP;AAWD;;AAEMjD,EAAAA,iBAAiB,CAAC;AAAEC,IAAAA,CAAF;AAAKE,IAAAA;AAAL,GAAD,EAA8C;AACpE,QAAI,CAAC,KAAKP,IAAV,EAAgB;AACd,aAAO,KAAP;AACD;;AAED,UAAMsD,IAAa,GAAG,KAAKtD,IAAL,CAAUuD,qBAAV,EAAtB;AAEA,WACElD,CAAC,IAAIiD,IAAI,CAACE,IAAV,IAAkBnD,CAAC,IAAIiD,IAAI,CAACG,KAA5B,IAAqClD,CAAC,IAAI+C,IAAI,CAACI,GAA/C,IAAsDnD,CAAC,IAAI+C,IAAI,CAACK,MADlE;AAGD;;AAEO3C,EAAAA,gBAAgB,CAACD,SAAD,EAA0B;AAChD,QAAI,KAAKc,cAAL,CAAoBC,OAApB,CAA4Bf,SAA5B,KAA0C,CAA9C,EAAiD;AAC/C;AACD;;AAED,SAAKc,cAAL,CAAoB+B,IAApB,CAAyB7C,SAAzB;AACD;;AAEOM,EAAAA,mBAAmB,CAACN,SAAD,EAA0B;AACnD,UAAM8C,KAAa,GAAG,KAAKhC,cAAL,CAAoBC,OAApB,CAA4Bf,SAA5B,CAAtB;;AAEA,QAAI8C,KAAK,GAAG,CAAZ,EAAe;AACb;AACD;;AAED,SAAKhC,cAAL,CAAoBiC,MAApB,CAA2BD,KAA3B,EAAkC,CAAlC;AACD;;AApL+B","sourcesContent":["/* eslint-disable @typescript-eslint/no-empty-function */\n\nimport { EventTypes, AdaptedPointerEvent, MouseButtons } from '../interfaces';\n\nexport default class EventManager {\n  private activePointers: number[] = [];\n  private readonly view: HTMLElement;\n\n  constructor(view: HTMLElement) {\n    this.view = view;\n  }\n\n  public setListeners() {\n    this.view.addEventListener('pointerdown', (event: PointerEvent): void => {\n      if (\n        !this.isPointerInBounds({\n          x: event.clientX,\n          y: event.clientY,\n        })\n      ) {\n        return;\n      }\n\n      const adaptedEvent: AdaptedPointerEvent = this.mapEvent(\n        event,\n        EventTypes.DOWN\n      );\n      const target = event.target as HTMLElement;\n\n      target.setPointerCapture(adaptedEvent.pointerId);\n      this.addActivePointer(adaptedEvent.pointerId);\n      this.onPointerDown(adaptedEvent);\n    });\n\n    this.view.addEventListener('pointerup', (event: PointerEvent): void => {\n      const adaptedEvent: AdaptedPointerEvent = this.mapEvent(\n        event,\n        EventTypes.UP\n      );\n      const target = event.target as HTMLElement;\n\n      this.onPointerUp(adaptedEvent);\n      target.releasePointerCapture(adaptedEvent.pointerId);\n      this.removeActivePointer(adaptedEvent.pointerId);\n    });\n\n    this.view.addEventListener('pointermove', (event: PointerEvent): void => {\n      if (\n        event.pointerType === 'mouse' &&\n        event.buttons !== MouseButtons.LEFT\n      ) {\n        return;\n      }\n\n      const adaptedEvent: AdaptedPointerEvent = this.mapEvent(\n        event,\n        EventTypes.MOVE\n      );\n\n      const inBounds: boolean = this.isPointerInBounds({\n        x: adaptedEvent.x,\n        y: adaptedEvent.y,\n      });\n\n      const pointerIndex: number = this.activePointers.indexOf(\n        adaptedEvent.pointerId\n      );\n\n      if (inBounds) {\n        if (pointerIndex < 0) {\n          adaptedEvent.eventType = EventTypes.ENTER;\n          this.onPointerEnter(adaptedEvent);\n          this.addActivePointer(adaptedEvent.pointerId);\n        } else {\n          this.onPointerMove(adaptedEvent);\n        }\n      } else {\n        if (pointerIndex >= 0) {\n          adaptedEvent.eventType = EventTypes.OUT;\n          this.onPointerOut(adaptedEvent);\n          this.removeActivePointer(adaptedEvent.pointerId);\n        } else {\n          this.onPointerOutOfBounds(adaptedEvent);\n        }\n      }\n    });\n\n    this.view.addEventListener('pointercancel', (event: PointerEvent): void => {\n      event.preventDefault();\n\n      const adaptedEvent: AdaptedPointerEvent = this.mapEvent(\n        event,\n        EventTypes.CANCEL\n      );\n\n      this.onPointerCancel(adaptedEvent);\n    });\n  }\n\n  private onPointerDown(_event: AdaptedPointerEvent): void {}\n  private onPointerUp(_event: AdaptedPointerEvent): void {}\n  private onPointerMove(_event: AdaptedPointerEvent): void {}\n  private onPointerOut(_event: AdaptedPointerEvent): void {}\n  private onPointerEnter(_event: AdaptedPointerEvent): void {}\n  private onPointerCancel(_event: AdaptedPointerEvent): void {}\n  private onPointerOutOfBounds(_event: AdaptedPointerEvent): void {}\n\n  public setOnPointerDown(\n    callback: (event: AdaptedPointerEvent) => void\n  ): void {\n    this.onPointerDown = callback;\n  }\n  public setOnPointerUp(callback: (event: AdaptedPointerEvent) => void): void {\n    this.onPointerUp = callback;\n  }\n  public setOnPointerMove(\n    callback: (event: AdaptedPointerEvent) => void\n  ): void {\n    this.onPointerMove = callback;\n  }\n  public setOnPointerOut(callback: (event: AdaptedPointerEvent) => void): void {\n    this.onPointerOut = callback;\n  }\n  public setOnPointerEnter(\n    callback: (event: AdaptedPointerEvent) => void\n  ): void {\n    this.onPointerEnter = callback;\n  }\n  public setOnPointerCancel(\n    callback: (event: AdaptedPointerEvent) => void\n  ): void {\n    this.onPointerCancel = callback;\n  }\n  public setOnPointerOutOfBounds(\n    callback: (event: AdaptedPointerEvent) => void\n  ): void {\n    this.onPointerOutOfBounds = callback;\n  }\n\n  private mapEvent(\n    event: PointerEvent,\n    eventType: EventTypes\n  ): AdaptedPointerEvent {\n    return {\n      x: event.clientX,\n      y: event.clientY,\n      offsetX: event.offsetX,\n      offsetY: event.offsetY,\n      pointerId: event.pointerId,\n      eventType: eventType,\n      pointerType: event.pointerType,\n      buttons: event.buttons,\n      time: event.timeStamp,\n    };\n  }\n\n  public isPointerInBounds({ x, y }: { x: number; y: number }): boolean {\n    if (!this.view) {\n      return false;\n    }\n\n    const rect: DOMRect = this.view.getBoundingClientRect();\n\n    return (\n      x >= rect.left && x <= rect.right && y >= rect.top && y <= rect.bottom\n    );\n  }\n\n  private addActivePointer(pointerId: number): void {\n    if (this.activePointers.indexOf(pointerId) >= 0) {\n      return;\n    }\n\n    this.activePointers.push(pointerId);\n  }\n\n  private removeActivePointer(pointerId: number): void {\n    const index: number = this.activePointers.indexOf(pointerId);\n\n    if (index < 0) {\n      return;\n    }\n\n    this.activePointers.splice(index, 1);\n  }\n}\n"]}

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

@@ -0,0 +1,283 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _State = require("../../State");
+
+var _PointerTracker = _interopRequireDefault(require("./PointerTracker"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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; }
+
+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, "handlersToCancel", []);
+
+    _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);
+  }
+
+  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, event) {
+    if (this.hasOtherHandlerToWaitFor(handler)) {
+      this.addAwaitingHandler(handler);
+    } else {
+      this.makeActive(handler, event);
+    }
+  }
+
+  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, event) {
+    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 ? void 0 : otherHandler.cancel(event);
+            otherHandler === null || otherHandler === void 0 ? void 0 : otherHandler.setAwaiting(false);
+          } else {
+            this.tryActivate(otherHandler, event);
+          }
+        }
+      });
+    }
+
+    if (newState === _State.State.ACTIVE) {
+      this.tryActivate(handler, event);
+    } else if (oldState === _State.State.ACTIVE || oldState === _State.State.END) {
+      if (handler.isActive()) {
+        handler.sendEvent(event, newState, oldState);
+      } else if (oldState === _State.State.ACTIVE) {
+        handler.sendEvent(event, newState, _State.State.BEGAN);
+      }
+    } else if (oldState !== _State.State.UNDETERMINED || newState !== _State.State.CANCELLED) {
+      handler.sendEvent(event, newState, oldState);
+    }
+
+    this.handlingChangeSemaphore -= 1;
+    this.scheduleFinishedHandlersCleanup();
+
+    if (this.awaitingHandlers.indexOf(handler) < 0) {
+      this.cleanupAwaitingHandlers(handler);
+    }
+  }
+
+  makeActive(handler, event) {
+    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);
+      }
+    });
+
+    for (let i = this.handlersToCancel.length - 1; i >= 0; --i) {
+      var _this$handlersToCance;
+
+      (_this$handlersToCance = this.handlersToCancel[i]) === null || _this$handlersToCance === void 0 ? void 0 : _this$handlersToCance.cancel(event);
+    }
+
+    this.awaitingHandlers.forEach(otherHandler => {
+      if (this.shouldHandlerBeCancelledBy(otherHandler, handler)) {
+        otherHandler === null || otherHandler === void 0 ? void 0 : otherHandler.cancel(event);
+        otherHandler === null || otherHandler === void 0 ? void 0 : otherHandler.setAwaiting(true);
+      }
+    });
+    handler.sendEvent(event, _State.State.ACTIVE, _State.State.BEGAN);
+
+    if (currentState !== _State.State.ACTIVE) {
+      handler.sendEvent(event, _State.State.END, _State.State.ACTIVE);
+
+      if (currentState !== _State.State.END) {
+        handler.sendEvent(event, _State.State.UNDETERMINED, _State.State.END);
+      }
+    }
+
+    if (handler.isAwaiting()) {
+      handler.setAwaiting(false);
+      handler.end(event);
+    }
+
+    this.handlersToCancel = [];
+  }
+
+  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) {
+    const handlerPointers = handler.getTrackedPointersID();
+    const otherPointers = otherHandler.getTrackedPointersID();
+
+    if (!_PointerTracker.default.shareCommonPointers(handlerPointers, otherPointers) && handler.getView() !== otherHandler.getView()) {
+      return this.checkOverlap(handler, otherHandler);
+    }
+
+    if (this.canRunSimultaneously(handler, otherHandler)) {
+      return false;
+    }
+
+    if (handler !== otherHandler && (handler.isAwaiting() || handler.getState() === _State.State.ACTIVE)) {
+      // For now it always returns false
+      return handler.shouldBeCancelledByOther(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.getEventManager().isPointerInBounds({
+        x: handlerX,
+        y: handlerY
+      }) && otherHandler.getEventManager().isPointerInBounds({
+        x: handlerX,
+        y: handlerY
+      })) {
+        overlap = true;
+      }
+    });
+    otherPointers.forEach(pointer => {
+      const otherX = otherHandler.getTracker().getLastX(pointer);
+      const otherY = otherHandler.getTracker().getLastY(pointer);
+
+      if (handler.getEventManager().isPointerInBounds({
+        x: otherX,
+        y: otherY
+      }) && otherHandler.getEventManager().isPointerInBounds({
+        x: otherX,
+        y: otherY
+      })) {
+        overlap = true;
+      }
+    });
+    return overlap;
+  }
+
+  isFinished(state) {
+    return state === _State.State.END || state === _State.State.FAILED || state === _State.State.CANCELLED;
+  }
+
+  static getInstance() {
+    if (!GestureHandlerOrchestrator.instance) GestureHandlerOrchestrator.instance = new GestureHandlerOrchestrator();
+    return GestureHandlerOrchestrator.instance;
+  }
+
+}
+
+exports.default = GestureHandlerOrchestrator;
+
+_defineProperty(GestureHandlerOrchestrator, "instance", void 0);
+//# sourceMappingURL=GestureHandlerOrchestrator.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["GestureHandlerOrchestrator.ts"],"names":["GestureHandlerOrchestrator","constructor","scheduleFinishedHandlersCleanup","handlingChangeSemaphore","cleanupFinishedHandlers","cleanHandler","handler","reset","setActive","setAwaiting","setActivationIndex","Number","MAX_VALUE","i","gestureHandlers","length","isFinished","getState","isAwaiting","splice","hasOtherHandlerToWaitFor","hasToWait","forEach","otherHandler","shouldHandlerWaitForOther","tryActivate","event","addAwaitingHandler","makeActive","cleanupAwaitingHandlers","awaitingHandlers","onHandlerStateChange","newState","oldState","State","END","cancel","ACTIVE","isActive","sendEvent","BEGAN","UNDETERMINED","CANCELLED","indexOf","currentState","setShouldResetProgress","activationIndex","shouldHandlerBeCancelledBy","handlersToCancel","push","end","alreadyExists","recordHandlerIfNotPresent","MAX_SAFE_INTEGER","shouldWaitForHandlerFailure","shouldRequireToWaitForFailure","canRunSimultaneously","gh1","gh2","shouldRecognizeSimultaneously","handlerPointers","getTrackedPointersID","otherPointers","PointerTracker","shareCommonPointers","getView","checkOverlap","shouldBeCancelledByOther","overlap","pointer","handlerX","getTracker","getLastX","handlerY","getLastY","getEventManager","isPointerInBounds","x","y","otherX","otherY","state","FAILED","getInstance","instance"],"mappings":"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","sourcesContent":["import { State } from '../../State';\nimport { AdaptedPointerEvent } from '../interfaces';\n\nimport GestureHandler from '../handlers/GestureHandler';\nimport PointerTracker from './PointerTracker';\n\nexport default class GestureHandlerOrchestrator {\n  private static instance: GestureHandlerOrchestrator;\n\n  private gestureHandlers: GestureHandler[] = [];\n  private awaitingHandlers: GestureHandler[] = [];\n  private handlersToCancel: GestureHandler[] = [];\n\n  private handlingChangeSemaphore = 0;\n  private activationIndex = 0;\n\n  // Private beacuse of Singleton\n  // eslint-disable-next-line no-useless-constructor, @typescript-eslint/no-empty-function\n  private constructor() {}\n\n  private scheduleFinishedHandlersCleanup(): void {\n    if (this.handlingChangeSemaphore === 0) {\n      this.cleanupFinishedHandlers();\n    }\n  }\n\n  private cleanHandler(handler: GestureHandler): void {\n    handler.reset();\n    handler.setActive(false);\n    handler.setAwaiting(false);\n    handler.setActivationIndex(Number.MAX_VALUE);\n  }\n\n  private cleanupFinishedHandlers(): void {\n    for (let i = this.gestureHandlers.length - 1; i >= 0; --i) {\n      const handler = this.gestureHandlers[i];\n      if (!handler) {\n        continue;\n      }\n\n      if (this.isFinished(handler.getState()) && !handler.isAwaiting()) {\n        this.gestureHandlers.splice(i, 1);\n\n        this.cleanHandler(handler);\n      }\n    }\n  }\n\n  private hasOtherHandlerToWaitFor(handler: GestureHandler): boolean {\n    let hasToWait = false;\n    this.gestureHandlers.forEach((otherHandler) => {\n      if (\n        otherHandler &&\n        !this.isFinished(otherHandler.getState()) &&\n        this.shouldHandlerWaitForOther(handler, otherHandler)\n      ) {\n        hasToWait = true;\n        return;\n      }\n    });\n\n    return hasToWait;\n  }\n\n  private tryActivate(\n    handler: GestureHandler,\n    event: AdaptedPointerEvent\n  ): void {\n    if (this.hasOtherHandlerToWaitFor(handler)) {\n      this.addAwaitingHandler(handler);\n    } else {\n      this.makeActive(handler, event);\n    }\n  }\n\n  private cleanupAwaitingHandlers(handler: GestureHandler): void {\n    for (let i = 0; i < this.awaitingHandlers.length; ++i) {\n      if (\n        !this.awaitingHandlers[i].isAwaiting() &&\n        this.shouldHandlerWaitForOther(this.awaitingHandlers[i], handler)\n      ) {\n        this.cleanHandler(this.awaitingHandlers[i]);\n        this.awaitingHandlers.splice(i, 1);\n      }\n    }\n  }\n\n  public onHandlerStateChange(\n    handler: GestureHandler,\n    newState: State,\n    oldState: State,\n    event: AdaptedPointerEvent\n  ): void {\n    this.handlingChangeSemaphore += 1;\n\n    if (this.isFinished(newState)) {\n      this.awaitingHandlers.forEach((otherHandler) => {\n        if (this.shouldHandlerWaitForOther(otherHandler, handler)) {\n          if (newState === State.END) {\n            otherHandler?.cancel(event);\n            otherHandler?.setAwaiting(false);\n          } else {\n            this.tryActivate(otherHandler, event);\n          }\n        }\n      });\n    }\n\n    if (newState === State.ACTIVE) {\n      this.tryActivate(handler, event);\n    } else if (oldState === State.ACTIVE || oldState === State.END) {\n      if (handler.isActive()) {\n        handler.sendEvent(event, newState, oldState);\n      } else if (oldState === State.ACTIVE) {\n        handler.sendEvent(event, newState, State.BEGAN);\n      }\n    } else if (\n      oldState !== State.UNDETERMINED ||\n      newState !== State.CANCELLED\n    ) {\n      handler.sendEvent(event, newState, oldState);\n    }\n\n    this.handlingChangeSemaphore -= 1;\n\n    this.scheduleFinishedHandlersCleanup();\n\n    if (this.awaitingHandlers.indexOf(handler) < 0) {\n      this.cleanupAwaitingHandlers(handler);\n    }\n  }\n\n  private makeActive(\n    handler: GestureHandler,\n    event: AdaptedPointerEvent\n  ): void {\n    const currentState = handler.getState();\n\n    handler.setActive(true);\n    handler.setShouldResetProgress(true);\n    handler.setActivationIndex(this.activationIndex++);\n\n    this.gestureHandlers.forEach((otherHandler) => {\n      // Order of arguments is correct - we check whether current handler should cancel existing handlers\n      if (this.shouldHandlerBeCancelledBy(otherHandler, handler)) {\n        this.handlersToCancel.push(otherHandler);\n      }\n    });\n\n    for (let i = this.handlersToCancel.length - 1; i >= 0; --i) {\n      this.handlersToCancel[i]?.cancel(event);\n    }\n    this.awaitingHandlers.forEach((otherHandler) => {\n      if (this.shouldHandlerBeCancelledBy(otherHandler, handler)) {\n        otherHandler?.cancel(event);\n        otherHandler?.setAwaiting(true);\n      }\n    });\n\n    handler.sendEvent(event, State.ACTIVE, State.BEGAN);\n\n    if (currentState !== State.ACTIVE) {\n      handler.sendEvent(event, State.END, State.ACTIVE);\n      if (currentState !== State.END) {\n        handler.sendEvent(event, State.UNDETERMINED, State.END);\n      }\n    }\n\n    if (handler.isAwaiting()) {\n      handler.setAwaiting(false);\n      handler.end(event);\n    }\n\n    this.handlersToCancel = [];\n  }\n\n  private addAwaitingHandler(handler: GestureHandler): void {\n    let alreadyExists = false;\n\n    this.awaitingHandlers.forEach((otherHandler) => {\n      if (otherHandler === handler) {\n        alreadyExists = true;\n        return;\n      }\n    });\n\n    if (alreadyExists) {\n      return;\n    }\n\n    this.awaitingHandlers.push(handler);\n\n    handler.setAwaiting(true);\n    handler.setActivationIndex(this.activationIndex++);\n  }\n\n  public recordHandlerIfNotPresent(handler: GestureHandler): void {\n    let alreadyExists = false;\n\n    this.gestureHandlers.forEach((otherHandler) => {\n      if (otherHandler === handler) {\n        alreadyExists = true;\n        return;\n      }\n    });\n\n    if (alreadyExists) {\n      return;\n    }\n\n    this.gestureHandlers.push(handler);\n\n    handler.setActive(false);\n    handler.setAwaiting(false);\n    handler.setActivationIndex(Number.MAX_SAFE_INTEGER);\n  }\n\n  private shouldHandlerWaitForOther(\n    handler: GestureHandler,\n    otherHandler: GestureHandler\n  ): boolean {\n    return (\n      handler !== otherHandler &&\n      (handler.shouldWaitForHandlerFailure(otherHandler) ||\n        otherHandler.shouldRequireToWaitForFailure(handler))\n    );\n  }\n\n  private canRunSimultaneously(\n    gh1: GestureHandler,\n    gh2: GestureHandler\n  ): boolean {\n    return (\n      gh1 === gh2 ||\n      gh1.shouldRecognizeSimultaneously(gh2) ||\n      gh2.shouldRecognizeSimultaneously(gh1)\n    );\n  }\n\n  private shouldHandlerBeCancelledBy(\n    handler: GestureHandler,\n    otherHandler: GestureHandler\n  ): boolean {\n    const handlerPointers: number[] = handler.getTrackedPointersID();\n    const otherPointers: number[] = otherHandler.getTrackedPointersID();\n\n    if (\n      !PointerTracker.shareCommonPointers(handlerPointers, otherPointers) &&\n      handler.getView() !== otherHandler.getView()\n    ) {\n      return this.checkOverlap(handler, otherHandler);\n    }\n\n    if (this.canRunSimultaneously(handler, otherHandler)) {\n      return false;\n    }\n\n    if (\n      handler !== otherHandler &&\n      (handler.isAwaiting() || handler.getState() === State.ACTIVE)\n    ) {\n      // For now it always returns false\n      return handler.shouldBeCancelledByOther(otherHandler);\n    }\n\n    return true;\n  }\n\n  private checkOverlap(\n    handler: GestureHandler,\n    otherHandler: GestureHandler\n  ): boolean {\n    // If handlers don't have common pointers, default return value is false.\n    // However, if at least on pointer overlaps with both handlers, we return true\n    // This solves issue in overlapping parents example\n\n    // TODO: Find better way to handle that issue, for example by activation order and handler cancelling\n\n    const handlerPointers: number[] = handler.getTrackedPointersID();\n    const otherPointers: number[] = otherHandler.getTrackedPointersID();\n\n    let overlap = false;\n\n    handlerPointers.forEach((pointer: number) => {\n      const handlerX: number = handler.getTracker().getLastX(pointer);\n      const handlerY: number = handler.getTracker().getLastY(pointer);\n\n      if (\n        handler\n          .getEventManager()\n          .isPointerInBounds({ x: handlerX, y: handlerY }) &&\n        otherHandler\n          .getEventManager()\n          .isPointerInBounds({ x: handlerX, y: handlerY })\n      ) {\n        overlap = true;\n      }\n    });\n\n    otherPointers.forEach((pointer: number) => {\n      const otherX: number = otherHandler.getTracker().getLastX(pointer);\n      const otherY: number = otherHandler.getTracker().getLastY(pointer);\n\n      if (\n        handler.getEventManager().isPointerInBounds({ x: otherX, y: otherY }) &&\n        otherHandler\n          .getEventManager()\n          .isPointerInBounds({ x: otherX, y: otherY })\n      ) {\n        overlap = true;\n      }\n    });\n\n    return overlap;\n  }\n\n  private isFinished(state: State): boolean {\n    return (\n      state === State.END || state === State.FAILED || state === State.CANCELLED\n    );\n  }\n\n  public static getInstance(): GestureHandlerOrchestrator {\n    if (!GestureHandlerOrchestrator.instance)\n      GestureHandlerOrchestrator.instance = new GestureHandlerOrchestrator();\n\n    return GestureHandlerOrchestrator.instance;\n  }\n}\n"]}

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

@@ -0,0 +1,102 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+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; }
+
+class InteractionManager {
+  constructor() {
+    _defineProperty(this, "waitForRelations", new Map());
+
+    _defineProperty(this, "simultaneousRelations", new Map());
+  }
+
+  configureInteractions(handler, config) {
+    this.dropRelationsForHandlerWithTag(handler.getTag());
+
+    if (config.waitFor) {
+      const waitFor = [];
+      config.waitFor.forEach(handler => {
+        if (typeof handler === 'number') {
+          waitFor.push(handler);
+        } else {
+          waitFor.push(handler.handlerTag);
+        }
+      });
+      this.waitForRelations.set(handler.getTag(), waitFor);
+    }
+
+    if (config.simultaneousHandlers) {
+      const simultaneousHandlers = [];
+      config.simultaneousHandlers.forEach(handler => {
+        if (typeof handler === 'number') {
+          simultaneousHandlers.push(handler);
+        } else {
+          simultaneousHandlers.push(handler.handlerTag);
+        }
+      });
+      this.simultaneousRelations.set(handler.getTag(), simultaneousHandlers);
+    }
+
+    handler.setInteractionManager(this);
+  }
+
+  shouldWaitForHandlerFailure(handler, otherHandler) {
+    const waitFor = this.waitForRelations.get(handler.getTag());
+
+    if (!waitFor) {
+      return false;
+    }
+
+    let shouldWait = false;
+    waitFor.forEach(tag => {
+      if (tag === otherHandler.getTag()) {
+        shouldWait = true;
+        return; //Returns from callback
+      }
+    });
+    return shouldWait;
+  }
+
+  shouldRecognizeSimultaneously(handler, otherHandler) {
+    const simultaneousHandlers = this.simultaneousRelations.get(handler.getTag());
+
+    if (!simultaneousHandlers) {
+      return false;
+    }
+
+    let shouldRecognizeSimultaneously = false;
+    simultaneousHandlers.forEach(tag => {
+      if (tag === otherHandler.getTag()) {
+        shouldRecognizeSimultaneously = true;
+        return;
+      }
+    });
+    return shouldRecognizeSimultaneously;
+  }
+
+  shouldRequireHandlerToWaitForFailure(_handler, _otherHandler) {
+    return false;
+  }
+
+  shouldHandlerBeCancelledBy(_handler, _otherHandler) {
+    return false;
+  }
+
+  dropRelationsForHandlerWithTag(handlerTag) {
+    this.waitForRelations.delete(handlerTag);
+    this.simultaneousRelations.delete(handlerTag);
+  }
+
+  reset() {
+    this.waitForRelations.clear();
+    this.simultaneousRelations.clear();
+  }
+
+}
+
+exports.default = InteractionManager;
+//# sourceMappingURL=InteractionManager.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["InteractionManager.ts"],"names":["InteractionManager","Map","configureInteractions","handler","config","dropRelationsForHandlerWithTag","getTag","waitFor","forEach","push","handlerTag","waitForRelations","set","simultaneousHandlers","simultaneousRelations","setInteractionManager","shouldWaitForHandlerFailure","otherHandler","get","shouldWait","tag","shouldRecognizeSimultaneously","shouldRequireHandlerToWaitForFailure","_handler","_otherHandler","shouldHandlerBeCancelledBy","delete","reset","clear"],"mappings":";;;;;;;;;AAGe,MAAMA,kBAAN,CAAyB;AAAA;AAAA,8CACqB,IAAIC,GAAJ,EADrB;;AAAA,mDAE0B,IAAIA,GAAJ,EAF1B;AAAA;;AAI/BC,EAAAA,qBAAqB,CAACC,OAAD,EAA0BC,MAA1B,EAA0C;AACpE,SAAKC,8BAAL,CAAoCF,OAAO,CAACG,MAAR,EAApC;;AAEA,QAAIF,MAAM,CAACG,OAAX,EAAoB;AAClB,YAAMA,OAAiB,GAAG,EAA1B;AACAH,MAAAA,MAAM,CAACG,OAAP,CAAeC,OAAf,CAAwBL,OAAD,IAA4B;AACjD,YAAI,OAAOA,OAAP,KAAmB,QAAvB,EAAiC;AAC/BI,UAAAA,OAAO,CAACE,IAAR,CAAaN,OAAb;AACD,SAFD,MAEO;AACLI,UAAAA,OAAO,CAACE,IAAR,CAAaN,OAAO,CAACO,UAArB;AACD;AACF,OAND;AAQA,WAAKC,gBAAL,CAAsBC,GAAtB,CAA0BT,OAAO,CAACG,MAAR,EAA1B,EAA4CC,OAA5C;AACD;;AAED,QAAIH,MAAM,CAACS,oBAAX,EAAiC;AAC/B,YAAMA,oBAA8B,GAAG,EAAvC;AACAT,MAAAA,MAAM,CAACS,oBAAP,CAA4BL,OAA5B,CAAqCL,OAAD,IAA4B;AAC9D,YAAI,OAAOA,OAAP,KAAmB,QAAvB,EAAiC;AAC/BU,UAAAA,oBAAoB,CAACJ,IAArB,CAA0BN,OAA1B;AACD,SAFD,MAEO;AACLU,UAAAA,oBAAoB,CAACJ,IAArB,CAA0BN,OAAO,CAACO,UAAlC;AACD;AACF,OAND;AAQA,WAAKI,qBAAL,CAA2BF,GAA3B,CAA+BT,OAAO,CAACG,MAAR,EAA/B,EAAiDO,oBAAjD;AACD;;AACDV,IAAAA,OAAO,CAACY,qBAAR,CAA8B,IAA9B;AACD;;AAEMC,EAAAA,2BAA2B,CAChCb,OADgC,EAEhCc,YAFgC,EAGvB;AACT,UAAMV,OAA6B,GAAG,KAAKI,gBAAL,CAAsBO,GAAtB,CACpCf,OAAO,CAACG,MAAR,EADoC,CAAtC;;AAGA,QAAI,CAACC,OAAL,EAAc;AACZ,aAAO,KAAP;AACD;;AAED,QAAIY,UAAU,GAAG,KAAjB;AAEAZ,IAAAA,OAAO,CAACC,OAAR,CAAiBY,GAAD,IAAuB;AACrC,UAAIA,GAAG,KAAKH,YAAY,CAACX,MAAb,EAAZ,EAAmC;AACjCa,QAAAA,UAAU,GAAG,IAAb;AACA,eAFiC,CAEzB;AACT;AACF,KALD;AAOA,WAAOA,UAAP;AACD;;AAEME,EAAAA,6BAA6B,CAClClB,OADkC,EAElCc,YAFkC,EAGzB;AACT,UAAMJ,oBAEO,GAAG,KAAKC,qBAAL,CAA2BI,GAA3B,CAA+Bf,OAAO,CAACG,MAAR,EAA/B,CAFhB;;AAGA,QAAI,CAACO,oBAAL,EAA2B;AACzB,aAAO,KAAP;AACD;;AAED,QAAIQ,6BAA6B,GAAG,KAApC;AAEAR,IAAAA,oBAAoB,CAACL,OAArB,CAA8BY,GAAD,IAAuB;AAClD,UAAIA,GAAG,KAAKH,YAAY,CAACX,MAAb,EAAZ,EAAmC;AACjCe,QAAAA,6BAA6B,GAAG,IAAhC;AACA;AACD;AACF,KALD;AAOA,WAAOA,6BAAP;AACD;;AAEMC,EAAAA,oCAAoC,CACzCC,QADyC,EAEzCC,aAFyC,EAGhC;AACT,WAAO,KAAP;AACD;;AAEMC,EAAAA,0BAA0B,CAC/BF,QAD+B,EAE/BC,aAF+B,EAGtB;AACT,WAAO,KAAP;AACD;;AAEMnB,EAAAA,8BAA8B,CAACK,UAAD,EAA2B;AAC9D,SAAKC,gBAAL,CAAsBe,MAAtB,CAA6BhB,UAA7B;AACA,SAAKI,qBAAL,CAA2BY,MAA3B,CAAkChB,UAAlC;AACD;;AAEMiB,EAAAA,KAAK,GAAG;AACb,SAAKhB,gBAAL,CAAsBiB,KAAtB;AACA,SAAKd,qBAAL,CAA2Bc,KAA3B;AACD;;AAvGqC","sourcesContent":["import GestureHandler from '../handlers/GestureHandler';\nimport { Config, Handler } from '../interfaces';\n\nexport default class InteractionManager {\n  private readonly waitForRelations: Map<number, number[]> = new Map();\n  private readonly simultaneousRelations: Map<number, number[]> = new Map();\n\n  public configureInteractions(handler: GestureHandler, config: Config) {\n    this.dropRelationsForHandlerWithTag(handler.getTag());\n\n    if (config.waitFor) {\n      const waitFor: number[] = [];\n      config.waitFor.forEach((handler: Handler): void => {\n        if (typeof handler === 'number') {\n          waitFor.push(handler);\n        } else {\n          waitFor.push(handler.handlerTag);\n        }\n      });\n\n      this.waitForRelations.set(handler.getTag(), waitFor);\n    }\n\n    if (config.simultaneousHandlers) {\n      const simultaneousHandlers: number[] = [];\n      config.simultaneousHandlers.forEach((handler: Handler): void => {\n        if (typeof handler === 'number') {\n          simultaneousHandlers.push(handler);\n        } else {\n          simultaneousHandlers.push(handler.handlerTag);\n        }\n      });\n\n      this.simultaneousRelations.set(handler.getTag(), simultaneousHandlers);\n    }\n    handler.setInteractionManager(this);\n  }\n\n  public shouldWaitForHandlerFailure(\n    handler: GestureHandler,\n    otherHandler: GestureHandler\n  ): boolean {\n    const waitFor: number[] | undefined = this.waitForRelations.get(\n      handler.getTag()\n    );\n    if (!waitFor) {\n      return false;\n    }\n\n    let shouldWait = false;\n\n    waitFor.forEach((tag: number): void => {\n      if (tag === otherHandler.getTag()) {\n        shouldWait = true;\n        return; //Returns from callback\n      }\n    });\n\n    return shouldWait;\n  }\n\n  public shouldRecognizeSimultaneously(\n    handler: GestureHandler,\n    otherHandler: GestureHandler\n  ): boolean {\n    const simultaneousHandlers:\n      | number[]\n      | undefined = this.simultaneousRelations.get(handler.getTag());\n    if (!simultaneousHandlers) {\n      return false;\n    }\n\n    let shouldRecognizeSimultaneously = false;\n\n    simultaneousHandlers.forEach((tag: number): void => {\n      if (tag === otherHandler.getTag()) {\n        shouldRecognizeSimultaneously = true;\n        return;\n      }\n    });\n\n    return shouldRecognizeSimultaneously;\n  }\n\n  public shouldRequireHandlerToWaitForFailure(\n    _handler: GestureHandler,\n    _otherHandler: GestureHandler\n  ): boolean {\n    return false;\n  }\n\n  public shouldHandlerBeCancelledBy(\n    _handler: GestureHandler,\n    _otherHandler: GestureHandler\n  ): boolean {\n    return false;\n  }\n\n  public dropRelationsForHandlerWithTag(handlerTag: number): void {\n    this.waitForRelations.delete(handlerTag);\n    this.simultaneousRelations.delete(handlerTag);\n  }\n\n  public reset() {\n    this.waitForRelations.clear();\n    this.simultaneousRelations.clear();\n  }\n}\n"]}

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

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+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-next-line @typescript-eslint/no-extraneous-class
+class NodeManager {
+  static getHandler(tag) {
+    if (tag in this.gestures) {
+      return this.gestures[tag];
+    }
+
+    throw new Error(`No handler for tag ${tag}`);
+  }
+
+  static createGestureHandler(handlerTag, handler) {
+    if (handlerTag in this.gestures) {
+      throw new Error(`Handler with tag ${handlerTag} already exists`);
+    }
+
+    this.gestures[handlerTag] = handler;
+    this.gestures[handlerTag].setTag(handlerTag);
+  }
+
+  static dropGestureHandler(handlerTag) {
+    if (!(handlerTag in this.gestures)) {
+      return;
+    } // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+
+
+    delete this.gestures[handlerTag];
+  }
+
+  static getNodes() {
+    return { ...this.gestures
+    };
+  }
+
+}
+
+exports.default = NodeManager;
+
+_defineProperty(NodeManager, "gestures", {});
+//# sourceMappingURL=NodeManager.js.map