react-native-gesture-handler 2.5.0 → 2.6.0

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

@@ -0,0 +1,270 @@
+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 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, "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.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.ACTIVE) {
+      this.tryActivate(handler, event);
+    } else if (oldState === State.ACTIVE || oldState === State.END) {
+      if (handler.isActive()) {
+        handler.sendEvent(event, newState, oldState);
+      } else if (oldState === State.ACTIVE) {
+        handler.sendEvent(event, newState, State.BEGAN);
+      }
+    } else if (oldState !== State.UNDETERMINED || newState !== 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.ACTIVE, State.BEGAN);
+
+    if (currentState !== State.ACTIVE) {
+      handler.sendEvent(event, State.END, State.ACTIVE);
+
+      if (currentState !== State.END) {
+        handler.sendEvent(event, State.UNDETERMINED, 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.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.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.END || state === State.FAILED || state === State.CANCELLED;
+  }
+
+  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","PointerTracker","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","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","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/module/web/tools/InteractionManager.js

@@ -0,0 +1,93 @@
+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; }
+
+export default 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();
+  }
+
+}
+//# sourceMappingURL=InteractionManager.js.map

package/lib/module/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":"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","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/module/web/tools/NodeManager.js

@@ -0,0 +1,39 @@
+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
+export default 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
+    };
+  }
+
+}
+
+_defineProperty(NodeManager, "gestures", {});
+//# sourceMappingURL=NodeManager.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["NodeManager.ts"],"names":["NodeManager","getHandler","tag","gestures","Error","createGestureHandler","handlerTag","handler","setTag","dropGestureHandler","getNodes"],"mappings":";;AAGA;AACA,eAAe,MAAMA,WAAN,CAAkB;AAMd,SAAVC,UAAU,CAACC,GAAD,EAAc;AAC7B,QAAIA,GAAG,IAAI,KAAKC,QAAhB,EAA0B;AACxB,aAAO,KAAKA,QAAL,CAAcD,GAAd,CAAP;AACD;;AAED,UAAM,IAAIE,KAAJ,CAAW,sBAAqBF,GAAI,EAApC,CAAN;AACD;;AAE0B,SAApBG,oBAAoB,CACzBC,UADyB,EAEzBC,OAFyB,EAGzB;AACA,QAAID,UAAU,IAAI,KAAKH,QAAvB,EAAiC;AAC/B,YAAM,IAAIC,KAAJ,CAAW,oBAAmBE,UAAW,iBAAzC,CAAN;AACD;;AAED,SAAKH,QAAL,CAAcG,UAAd,IAA4BC,OAA5B;AACA,SAAKJ,QAAL,CAAcG,UAAd,EAA0BE,MAA1B,CAAiCF,UAAjC;AACD;;AAEwB,SAAlBG,kBAAkB,CAACH,UAAD,EAAqB;AAC5C,QAAI,EAAEA,UAAU,IAAI,KAAKH,QAArB,CAAJ,EAAoC;AAClC;AACD,KAH2C,CAK5C;;;AACA,WAAO,KAAKA,QAAL,CAAcG,UAAd,CAAP;AACD;;AAEc,SAARI,QAAQ,GAAG;AAChB,WAAO,EAAE,GAAG,KAAKP;AAAV,KAAP;AACD;;AArC8B;;gBAAZH,W,cAIf,E","sourcesContent":["import { ValueOf } from '../../typeUtils';\nimport { Gestures } from '../../RNGestureHandlerModule.web';\n\n// eslint-disable-next-line @typescript-eslint/no-extraneous-class\nexport default class NodeManager {\n  private static gestures: Record<\n    number,\n    InstanceType<ValueOf<typeof Gestures>>\n  > = {};\n\n  static getHandler(tag: number) {\n    if (tag in this.gestures) {\n      return this.gestures[tag];\n    }\n\n    throw new Error(`No handler for tag ${tag}`);\n  }\n\n  static createGestureHandler(\n    handlerTag: number,\n    handler: InstanceType<ValueOf<typeof Gestures>>\n  ) {\n    if (handlerTag in this.gestures) {\n      throw new Error(`Handler with tag ${handlerTag} already exists`);\n    }\n\n    this.gestures[handlerTag] = handler;\n    this.gestures[handlerTag].setTag(handlerTag);\n  }\n\n  static dropGestureHandler(handlerTag: number) {\n    if (!(handlerTag in this.gestures)) {\n      return;\n    }\n\n    // eslint-disable-next-line @typescript-eslint/no-dynamic-delete\n    delete this.gestures[handlerTag];\n  }\n\n  static getNodes() {\n    return { ...this.gestures };\n  }\n}\n"]}

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

@@ -0,0 +1,122 @@
+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; }
+
+const VELOCITY_FACTOR = 0.2;
+export default class PointerTracker {
+  constructor() {
+    _defineProperty(this, "trackedPointers", new Map());
+  }
+
+  addToTracker(event) {
+    if (this.trackedPointers.has(event.pointerId)) {
+      return;
+    }
+
+    const newElement = {
+      lastX: event.x,
+      lastY: event.y,
+      timeStamp: event.time,
+      velocityX: 0,
+      velocityY: 0
+    };
+    this.trackedPointers.set(event.pointerId, newElement);
+  }
+
+  removeFromTracker(pointerId) {
+    this.trackedPointers.delete(pointerId);
+  }
+
+  track(event) {
+    const element = this.trackedPointers.get(event.pointerId);
+
+    if (!element) {
+      return;
+    }
+
+    const dx = event.x - element.lastX;
+    const dy = event.y - element.lastY;
+    const dt = event.time - element.timeStamp;
+    element.velocityX = dx / dt * 1000 * VELOCITY_FACTOR;
+    element.velocityY = dy / dt * 1000 * VELOCITY_FACTOR;
+    element.lastX = event.x;
+    element.lastY = event.y;
+    this.trackedPointers.set(event.pointerId, element);
+  }
+
+  getVelocityX(pointerId) {
+    var _this$trackedPointers;
+
+    return (_this$trackedPointers = this.trackedPointers.get(pointerId)) === null || _this$trackedPointers === void 0 ? void 0 : _this$trackedPointers.velocityX;
+  }
+
+  getVelocityY(pointerId) {
+    var _this$trackedPointers2;
+
+    return (_this$trackedPointers2 = this.trackedPointers.get(pointerId)) === null || _this$trackedPointers2 === void 0 ? void 0 : _this$trackedPointers2.velocityY;
+  }
+
+  getLastX(pointerId) {
+    var _this$trackedPointers3;
+
+    return (_this$trackedPointers3 = this.trackedPointers.get(pointerId)) === null || _this$trackedPointers3 === void 0 ? void 0 : _this$trackedPointers3.lastX;
+  }
+
+  getLastY(pointerId) {
+    var _this$trackedPointers4;
+
+    return (_this$trackedPointers4 = this.trackedPointers.get(pointerId)) === null || _this$trackedPointers4 === void 0 ? void 0 : _this$trackedPointers4.lastY;
+  }
+
+  getLastAvgX() {
+    return this.getSumX() / this.trackedPointers.size;
+  }
+
+  getLastAvgY() {
+    return this.getSumY() / this.trackedPointers.size;
+  }
+
+  getSumX(ignoredPointer) {
+    let sumX = 0;
+    this.trackedPointers.forEach((value, key) => {
+      if (key !== ignoredPointer) {
+        sumX += value.lastX;
+      }
+    });
+    return sumX;
+  }
+
+  getSumY(ignoredPointer) {
+    let sumY = 0;
+    this.trackedPointers.forEach((value, key) => {
+      if (key !== ignoredPointer) {
+        sumY += value.lastY;
+      }
+    });
+    return sumY;
+  }
+
+  getTrackedPointersCount() {
+    return this.trackedPointers.size;
+  }
+
+  getTrackedPointersID() {
+    const keys = [];
+    this.trackedPointers.forEach((_value, key) => {
+      keys.push(key);
+    });
+    return keys;
+  }
+
+  getData() {
+    return this.trackedPointers;
+  }
+
+  resetTracker() {
+    this.trackedPointers.clear();
+  }
+
+  static shareCommonPointers(stPointers, ndPointers) {
+    return stPointers.some(pointerId => ndPointers.includes(pointerId));
+  }
+
+}
+//# sourceMappingURL=PointerTracker.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["PointerTracker.ts"],"names":["VELOCITY_FACTOR","PointerTracker","Map","addToTracker","event","trackedPointers","has","pointerId","newElement","lastX","x","lastY","y","timeStamp","time","velocityX","velocityY","set","removeFromTracker","delete","track","element","get","dx","dy","dt","getVelocityX","getVelocityY","getLastX","getLastY","getLastAvgX","getSumX","size","getLastAvgY","getSumY","ignoredPointer","sumX","forEach","value","key","sumY","getTrackedPointersCount","getTrackedPointersID","keys","_value","push","getData","resetTracker","clear","shareCommonPointers","stPointers","ndPointers","some","includes"],"mappings":";;AAYA,MAAMA,eAAe,GAAG,GAAxB;AAEA,eAAe,MAAMC,cAAN,CAAqB;AAAA;AAAA,6CACqB,IAAIC,GAAJ,EADrB;AAAA;;AAM3BC,EAAAA,YAAY,CAACC,KAAD,EAAmC;AACpD,QAAI,KAAKC,eAAL,CAAqBC,GAArB,CAAyBF,KAAK,CAACG,SAA/B,CAAJ,EAA+C;AAC7C;AACD;;AAED,UAAMC,UAA0B,GAAG;AACjCC,MAAAA,KAAK,EAAEL,KAAK,CAACM,CADoB;AAEjCC,MAAAA,KAAK,EAAEP,KAAK,CAACQ,CAFoB;AAGjCC,MAAAA,SAAS,EAAET,KAAK,CAACU,IAHgB;AAIjCC,MAAAA,SAAS,EAAE,CAJsB;AAKjCC,MAAAA,SAAS,EAAE;AALsB,KAAnC;AAQA,SAAKX,eAAL,CAAqBY,GAArB,CAAyBb,KAAK,CAACG,SAA/B,EAA0CC,UAA1C;AACD;;AAEMU,EAAAA,iBAAiB,CAACX,SAAD,EAA0B;AAChD,SAAKF,eAAL,CAAqBc,MAArB,CAA4BZ,SAA5B;AACD;;AAEMa,EAAAA,KAAK,CAAChB,KAAD,EAAmC;AAC7C,UAAMiB,OAAuB,GAAG,KAAKhB,eAAL,CAAqBiB,GAArB,CAC9BlB,KAAK,CAACG,SADwB,CAAhC;;AAIA,QAAI,CAACc,OAAL,EAAc;AACZ;AACD;;AAED,UAAME,EAAE,GAAGnB,KAAK,CAACM,CAAN,GAAUW,OAAO,CAACZ,KAA7B;AACA,UAAMe,EAAE,GAAGpB,KAAK,CAACQ,CAAN,GAAUS,OAAO,CAACV,KAA7B;AACA,UAAMc,EAAE,GAAGrB,KAAK,CAACU,IAAN,GAAaO,OAAO,CAACR,SAAhC;AAEAQ,IAAAA,OAAO,CAACN,SAAR,GAAqBQ,EAAE,GAAGE,EAAN,GAAY,IAAZ,GAAmBzB,eAAvC;AACAqB,IAAAA,OAAO,CAACL,SAAR,GAAqBQ,EAAE,GAAGC,EAAN,GAAY,IAAZ,GAAmBzB,eAAvC;AAEAqB,IAAAA,OAAO,CAACZ,KAAR,GAAgBL,KAAK,CAACM,CAAtB;AACAW,IAAAA,OAAO,CAACV,KAAR,GAAgBP,KAAK,CAACQ,CAAtB;AAEA,SAAKP,eAAL,CAAqBY,GAArB,CAAyBb,KAAK,CAACG,SAA/B,EAA0Cc,OAA1C;AACD;;AAEMK,EAAAA,YAAY,CAACnB,SAAD,EAA4B;AAAA;;AAC7C,oCAAO,KAAKF,eAAL,CAAqBiB,GAArB,CAAyBf,SAAzB,CAAP,0DAAO,sBAAqCQ,SAA5C;AACD;;AACMY,EAAAA,YAAY,CAACpB,SAAD,EAA4B;AAAA;;AAC7C,qCAAO,KAAKF,eAAL,CAAqBiB,GAArB,CAAyBf,SAAzB,CAAP,2DAAO,uBAAqCS,SAA5C;AACD;;AACMY,EAAAA,QAAQ,CAACrB,SAAD,EAA4B;AAAA;;AACzC,qCAAO,KAAKF,eAAL,CAAqBiB,GAArB,CAAyBf,SAAzB,CAAP,2DAAO,uBAAqCE,KAA5C;AACD;;AACMoB,EAAAA,QAAQ,CAACtB,SAAD,EAA4B;AAAA;;AACzC,qCAAO,KAAKF,eAAL,CAAqBiB,GAArB,CAAyBf,SAAzB,CAAP,2DAAO,uBAAqCI,KAA5C;AACD;;AACMmB,EAAAA,WAAW,GAAW;AAC3B,WAAO,KAAKC,OAAL,KAAiB,KAAK1B,eAAL,CAAqB2B,IAA7C;AACD;;AACMC,EAAAA,WAAW,GAAW;AAC3B,WAAO,KAAKC,OAAL,KAAiB,KAAK7B,eAAL,CAAqB2B,IAA7C;AACD;;AACMD,EAAAA,OAAO,CAACI,cAAD,EAAkC;AAC9C,QAAIC,IAAI,GAAG,CAAX;AAEA,SAAK/B,eAAL,CAAqBgC,OAArB,CAA6B,CAACC,KAAD,EAAQC,GAAR,KAAgB;AAC3C,UAAIA,GAAG,KAAKJ,cAAZ,EAA4B;AAC1BC,QAAAA,IAAI,IAAIE,KAAK,CAAC7B,KAAd;AACD;AACF,KAJD;AAMA,WAAO2B,IAAP;AACD;;AACMF,EAAAA,OAAO,CAACC,cAAD,EAAkC;AAC9C,QAAIK,IAAI,GAAG,CAAX;AAEA,SAAKnC,eAAL,CAAqBgC,OAArB,CAA6B,CAACC,KAAD,EAAQC,GAAR,KAAgB;AAC3C,UAAIA,GAAG,KAAKJ,cAAZ,EAA4B;AAC1BK,QAAAA,IAAI,IAAIF,KAAK,CAAC3B,KAAd;AACD;AACF,KAJD;AAMA,WAAO6B,IAAP;AACD;;AACMC,EAAAA,uBAAuB,GAAW;AACvC,WAAO,KAAKpC,eAAL,CAAqB2B,IAA5B;AACD;;AACMU,EAAAA,oBAAoB,GAAa;AACtC,UAAMC,IAAc,GAAG,EAAvB;AAEA,SAAKtC,eAAL,CAAqBgC,OAArB,CAA6B,CAACO,MAAD,EAASL,GAAT,KAAiB;AAC5CI,MAAAA,IAAI,CAACE,IAAL,CAAUN,GAAV;AACD,KAFD;AAIA,WAAOI,IAAP;AACD;;AAEMG,EAAAA,OAAO,GAAgC;AAC5C,WAAO,KAAKzC,eAAZ;AACD;;AAEM0C,EAAAA,YAAY,GAAS;AAC1B,SAAK1C,eAAL,CAAqB2C,KAArB;AACD;;AAEgC,SAAnBC,mBAAmB,CAC/BC,UAD+B,EAE/BC,UAF+B,EAGtB;AACT,WAAOD,UAAU,CAACE,IAAX,CAAiB7C,SAAD,IAAe4C,UAAU,CAACE,QAAX,CAAoB9C,SAApB,CAA/B,CAAP;AACD;;AAlHiC","sourcesContent":["import { AdaptedPointerEvent } from '../interfaces';\n\ninterface TrackerElement {\n  lastX: number;\n  lastY: number;\n\n  timeStamp: number;\n\n  velocityX: number;\n  velocityY: number;\n}\n\nconst VELOCITY_FACTOR = 0.2;\n\nexport default class PointerTracker {\n  private trackedPointers: Map<number, TrackerElement> = new Map<\n    number,\n    TrackerElement\n  >();\n\n  public addToTracker(event: AdaptedPointerEvent): void {\n    if (this.trackedPointers.has(event.pointerId)) {\n      return;\n    }\n\n    const newElement: TrackerElement = {\n      lastX: event.x,\n      lastY: event.y,\n      timeStamp: event.time,\n      velocityX: 0,\n      velocityY: 0,\n    };\n\n    this.trackedPointers.set(event.pointerId, newElement);\n  }\n\n  public removeFromTracker(pointerId: number): void {\n    this.trackedPointers.delete(pointerId);\n  }\n\n  public track(event: AdaptedPointerEvent): void {\n    const element: TrackerElement = this.trackedPointers.get(\n      event.pointerId\n    ) as TrackerElement;\n\n    if (!element) {\n      return;\n    }\n\n    const dx = event.x - element.lastX;\n    const dy = event.y - element.lastY;\n    const dt = event.time - element.timeStamp;\n\n    element.velocityX = (dx / dt) * 1000 * VELOCITY_FACTOR;\n    element.velocityY = (dy / dt) * 1000 * VELOCITY_FACTOR;\n\n    element.lastX = event.x;\n    element.lastY = event.y;\n\n    this.trackedPointers.set(event.pointerId, element);\n  }\n\n  public getVelocityX(pointerId: number): number {\n    return this.trackedPointers.get(pointerId)?.velocityX as number;\n  }\n  public getVelocityY(pointerId: number): number {\n    return this.trackedPointers.get(pointerId)?.velocityY as number;\n  }\n  public getLastX(pointerId: number): number {\n    return this.trackedPointers.get(pointerId)?.lastX as number;\n  }\n  public getLastY(pointerId: number): number {\n    return this.trackedPointers.get(pointerId)?.lastY as number;\n  }\n  public getLastAvgX(): number {\n    return this.getSumX() / this.trackedPointers.size;\n  }\n  public getLastAvgY(): number {\n    return this.getSumY() / this.trackedPointers.size;\n  }\n  public getSumX(ignoredPointer?: number): number {\n    let sumX = 0;\n\n    this.trackedPointers.forEach((value, key) => {\n      if (key !== ignoredPointer) {\n        sumX += value.lastX;\n      }\n    });\n\n    return sumX;\n  }\n  public getSumY(ignoredPointer?: number): number {\n    let sumY = 0;\n\n    this.trackedPointers.forEach((value, key) => {\n      if (key !== ignoredPointer) {\n        sumY += value.lastY;\n      }\n    });\n\n    return sumY;\n  }\n  public getTrackedPointersCount(): number {\n    return this.trackedPointers.size;\n  }\n  public getTrackedPointersID(): number[] {\n    const keys: number[] = [];\n\n    this.trackedPointers.forEach((_value, key) => {\n      keys.push(key);\n    });\n\n    return keys;\n  }\n\n  public getData(): Map<number, TrackerElement> {\n    return this.trackedPointers;\n  }\n\n  public resetTracker(): void {\n    this.trackedPointers.clear();\n  }\n\n  public static shareCommonPointers(\n    stPointers: number[],\n    ndPointers: number[]\n  ): boolean {\n    return stPointers.some((pointerId) => ndPointers.includes(pointerId));\n  }\n}\n"]}