react-native-gesture-handler 2.22.1 → 2.23.1

package/lib/commonjs/web/handlers/GestureHandler.js

@@ -28,37 +28,37 @@ class GestureHandler {
   constructor(delegate) {
     _defineProperty(this, "lastSentState", null);
 
-    _defineProperty(this, "currentState", _State.State.UNDETERMINED);
+    _defineProperty(this, "_state", _State.State.UNDETERMINED);
 
-    _defineProperty(this, "shouldCancelWhenOutside", false);
+    _defineProperty(this, "_shouldCancelWhenOutside", false);
 
     _defineProperty(this, "hasCustomActivationCriteria", false);
 
-    _defineProperty(this, "enabled", false);
+    _defineProperty(this, "_enabled", false);
 
     _defineProperty(this, "viewRef", void 0);
 
     _defineProperty(this, "propsRef", void 0);
 
-    _defineProperty(this, "handlerTag", void 0);
+    _defineProperty(this, "_handlerTag", void 0);
 
-    _defineProperty(this, "config", {
+    _defineProperty(this, "_config", {
       enabled: false
     });
 
-    _defineProperty(this, "tracker", new _PointerTracker.default());
+    _defineProperty(this, "_tracker", new _PointerTracker.default());
 
-    _defineProperty(this, "activationIndex", 0);
+    _defineProperty(this, "_activationIndex", 0);
 
-    _defineProperty(this, "awaiting", false);
+    _defineProperty(this, "_awaiting", false);
 
-    _defineProperty(this, "active", false);
+    _defineProperty(this, "_active", false);
 
-    _defineProperty(this, "shouldResetProgress", false);
+    _defineProperty(this, "_shouldResetProgress", false);
 
-    _defineProperty(this, "pointerType", _PointerType.PointerType.MOUSE);
+    _defineProperty(this, "_pointerType", _PointerType.PointerType.MOUSE);
 
-    _defineProperty(this, "delegate", void 0);
+    _defineProperty(this, "_delegate", void 0);
 
     _defineProperty(this, "sendEvent", (newState, oldState) => {
       const {
@@ -75,13 +75,13 @@ class GestureHandler {
         invokeNullableMethod(onGestureHandlerStateChange, resultEvent);
       }
 
-      if (this.currentState === _State.State.ACTIVE) {
+      if (this.state === _State.State.ACTIVE) {
         resultEvent.nativeEvent.oldState = undefined;
         invokeNullableMethod(onGestureHandlerEvent, resultEvent);
       }
     });
 
-    this.delegate = delegate;
+    this._delegate = delegate;
   } //
   // Initializing handler
   //
@@ -90,7 +90,7 @@ class GestureHandler {
   init(viewRef, propsRef) {
     this.propsRef = propsRef;
     this.viewRef = viewRef;
-    this.currentState = _State.State.UNDETERMINED;
+    this.state = _State.State.UNDETERMINED;
     this.delegate.init(viewRef, this);
   }
 
@@ -124,30 +124,30 @@ class GestureHandler {
     this.onReset();
     this.resetProgress();
     this.delegate.reset();
-    this.currentState = _State.State.UNDETERMINED;
+    this.state = _State.State.UNDETERMINED;
   } //
   // State logic
   //
 
 
   moveToState(newState, sendIfDisabled) {
-    if (this.currentState === newState) {
+    if (this.state === newState) {
       return;
     }
 
-    const oldState = this.currentState;
-    this.currentState = newState;
+    const oldState = this.state;
+    this.state = newState;
 
-    if (this.tracker.getTrackedPointersCount() > 0 && this.config.needsPointerData && this.isFinished()) {
+    if (this.tracker.trackedPointersCount > 0 && this.config.needsPointerData && this.isFinished()) {
       this.cancelTouches();
     }
 
-    _GestureHandlerOrchestrator.default.getInstance().onHandlerStateChange(this, newState, oldState, sendIfDisabled);
+    _GestureHandlerOrchestrator.default.instance.onHandlerStateChange(this, newState, oldState, sendIfDisabled);
 
     this.onStateChange(newState, oldState);
 
     if (!this.enabled && this.isFinished()) {
-      this.currentState = _State.State.UNDETERMINED;
+      this.state = _State.State.UNDETERMINED;
     }
   }
 
@@ -158,7 +158,7 @@ class GestureHandler {
       return;
     }
 
-    if (this.currentState === _State.State.UNDETERMINED) {
+    if (this.state === _State.State.UNDETERMINED) {
       this.moveToState(_State.State.BEGAN);
     }
   }
@@ -168,7 +168,7 @@ class GestureHandler {
 
 
   fail(sendIfDisabled) {
-    if (this.currentState === _State.State.ACTIVE || this.currentState === _State.State.BEGAN) {
+    if (this.state === _State.State.ACTIVE || this.state === _State.State.BEGAN) {
       // Here the order of calling the delegate and moveToState is important.
       // At this point we can use currentState as previuos state, because immediately after changing cursor we call moveToState method.
       this.delegate.onFail();
@@ -183,7 +183,7 @@ class GestureHandler {
 
 
   cancel(sendIfDisabled) {
-    if (this.currentState === _State.State.ACTIVE || this.currentState === _State.State.UNDETERMINED || this.currentState === _State.State.BEGAN) {
+    if (this.state === _State.State.ACTIVE || this.state === _State.State.UNDETERMINED || this.state === _State.State.BEGAN) {
       this.onCancel(); // Same as above - order matters
 
       this.delegate.onCancel();
@@ -192,14 +192,14 @@ class GestureHandler {
   }
 
   activate(force = false) {
-    if ((this.config.manualActivation !== true || force) && (this.currentState === _State.State.UNDETERMINED || this.currentState === _State.State.BEGAN)) {
+    if ((this.config.manualActivation !== true || force) && (this.state === _State.State.UNDETERMINED || this.state === _State.State.BEGAN)) {
       this.delegate.onActivate();
       this.moveToState(_State.State.ACTIVE);
     }
   }
 
   end() {
-    if (this.currentState === _State.State.BEGAN || this.currentState === _State.State.ACTIVE) {
+    if (this.state === _State.State.BEGAN || this.state === _State.State.ACTIVE) {
       // Same as above - order matters
       this.delegate.onEnd();
       this.moveToState(_State.State.END);
@@ -211,22 +211,6 @@ class GestureHandler {
   //
 
 
-  isAwaiting() {
-    return this.awaiting;
-  }
-
-  setAwaiting(value) {
-    this.awaiting = value;
-  }
-
-  isActive() {
-    return this.active;
-  }
-
-  setActive(value) {
-    this.active = value;
-  }
-
   getShouldResetProgress() {
     return this.shouldResetProgress;
   }
@@ -235,20 +219,12 @@ class GestureHandler {
     this.shouldResetProgress = value;
   }
 
-  getActivationIndex() {
-    return this.activationIndex;
-  }
-
-  setActivationIndex(value) {
-    this.activationIndex = value;
-  }
-
   shouldWaitForHandlerFailure(handler) {
     if (handler === this) {
       return false;
     }
 
-    return _InteractionManager.default.getInstance().shouldWaitForHandlerFailure(this, handler);
+    return _InteractionManager.default.instance.shouldWaitForHandlerFailure(this, handler);
   }
 
   shouldRequireToWaitForFailure(handler) {
@@ -256,7 +232,7 @@ class GestureHandler {
       return false;
     }
 
-    return _InteractionManager.default.getInstance().shouldRequireHandlerToWaitForFailure(this, handler);
+    return _InteractionManager.default.instance.shouldRequireHandlerToWaitForFailure(this, handler);
   }
 
   shouldRecognizeSimultaneously(handler) {
@@ -264,7 +240,7 @@ class GestureHandler {
       return true;
     }
 
-    return _InteractionManager.default.getInstance().shouldRecognizeSimultaneously(this, handler);
+    return _InteractionManager.default.instance.shouldRecognizeSimultaneously(this, handler);
   }
 
   shouldBeCancelledByOther(handler) {
@@ -272,19 +248,19 @@ class GestureHandler {
       return false;
     }
 
-    return _InteractionManager.default.getInstance().shouldHandlerBeCancelledBy(this, handler);
+    return _InteractionManager.default.instance.shouldHandlerBeCancelledBy(this, handler);
   } //
   // Event actions
   //
 
 
   onPointerDown(event) {
-    _GestureHandlerOrchestrator.default.getInstance().recordHandlerIfNotPresent(this);
+    _GestureHandlerOrchestrator.default.instance.recordHandlerIfNotPresent(this);
 
     this.pointerType = event.pointerType;
 
     if (this.pointerType === _PointerType.PointerType.TOUCH) {
-      _GestureHandlerOrchestrator.default.getInstance().cancelMouseAndPenGestures(this);
+      _GestureHandlerOrchestrator.default.instance.cancelMouseAndPenGestures(this);
     } // TODO: Bring back touch events along with introducing `handleDown` method that will handle handler specific stuff
 
   } // Adding another pointer to existing ones
@@ -309,7 +285,7 @@ class GestureHandler {
 
   onPointerLeave(event) {
     if (this.shouldCancelWhenOutside) {
-      switch (this.currentState) {
+      switch (this.state) {
         case _State.State.ACTIVE:
           this.cancel();
           break;
@@ -354,7 +330,7 @@ class GestureHandler {
     }
 
     if (this.active) {
-      this.sendEvent(this.currentState, this.currentState);
+      this.sendEvent(this.state, this.state);
     }
 
     this.tryToSendTouchEvent(event);
@@ -387,7 +363,7 @@ class GestureHandler {
   transformEventData(newState, oldState) {
     return {
       nativeEvent: {
-        numberOfPointers: this.tracker.getTrackedPointersCount(),
+        numberOfPointers: this.tracker.trackedPointersCount,
         state: newState,
         pointerInside: this.delegate.isPointerInBounds(this.tracker.getAbsoluteCoordsAverage()),
         ...this.transformNativeEvent(),
@@ -404,7 +380,7 @@ class GestureHandler {
     const rect = this.delegate.measureView();
     const all = [];
     const changed = [];
-    const trackerData = this.tracker.getData(); // This if handles edge case where all pointers have been cancelled
+    const trackerData = this.tracker.trackedPointers; // This if handles edge case where all pointers have been cancelled
     // When pointercancel is triggered, reset method is called. This means that tracker will be reset after first pointer being cancelled
     // The problem is, that handler will receive another pointercancel event from the rest of the pointers
     // To avoid crashing, we don't send event if tracker tracks no pointers, i.e. has been reset
@@ -480,7 +456,7 @@ class GestureHandler {
     return {
       nativeEvent: {
         handlerTag: this.handlerTag,
-        state: this.currentState,
+        state: this.state,
         eventType: eventType,
         changedTouches: changed,
         allTouches: all,
@@ -495,7 +471,7 @@ class GestureHandler {
     const rect = this.delegate.measureView();
     const all = [];
     const changed = [];
-    const trackerData = this.tracker.getData();
+    const trackerData = this.tracker.trackedPointers;
 
     if (trackerData.size === 0) {
       return;
@@ -521,7 +497,7 @@ class GestureHandler {
     const cancelEvent = {
       nativeEvent: {
         handlerTag: this.handlerTag,
-        state: this.currentState,
+        state: this.state,
         eventType: _interfaces.TouchEventType.CANCELLED,
         changedTouches: changed,
         allTouches: all,
@@ -555,7 +531,7 @@ class GestureHandler {
     enabled = true,
     ...props
   }) {
-    this.config = {
+    this._config = {
       enabled: enabled,
       ...props
     };
@@ -563,7 +539,7 @@ class GestureHandler {
     this.delegate.onEnabledChange(enabled);
 
     if (this.config.shouldCancelWhenOutside !== undefined) {
-      this.setShouldCancelWhenOutside(this.config.shouldCancelWhenOutside);
+      this.shouldCancelWhenOutside = this.config.shouldCancelWhenOutside;
     }
 
     this.validateHitSlops();
@@ -572,13 +548,13 @@ class GestureHandler {
       return;
     }
 
-    switch (this.currentState) {
+    switch (this.state) {
       case _State.State.ACTIVE:
         this.fail(true);
         break;
 
       case _State.State.UNDETERMINED:
-        _GestureHandlerOrchestrator.default.getInstance().removeHandlerFromOrchestrator(this);
+        _GestureHandlerOrchestrator.default.instance.removeHandlerFromOrchestrator(this);
 
         break;
 
@@ -697,52 +673,96 @@ class GestureHandler {
   //
 
 
-  getTag() {
-    return this.handlerTag;
+  get handlerTag() {
+    return this._handlerTag;
   }
 
-  setTag(tag) {
-    this.handlerTag = tag;
+  set handlerTag(value) {
+    this._handlerTag = value;
   }
 
-  getConfig() {
-    return this.config;
+  get config() {
+    return this._config;
   }
 
-  getDelegate() {
-    return this.delegate;
+  get delegate() {
+    return this._delegate;
   }
 
-  getTracker() {
-    return this.tracker;
+  get tracker() {
+    return this._tracker;
   }
 
-  getTrackedPointersID() {
-    return this.tracker.getTrackedPointersID();
+  get state() {
+    return this._state;
   }
 
-  getState() {
-    return this.currentState;
+  set state(value) {
+    this._state = value;
   }
 
-  isEnabled() {
-    return this.enabled;
+  get shouldCancelWhenOutside() {
+    return this._shouldCancelWhenOutside;
   }
 
-  isFinished() {
-    return this.currentState === _State.State.END || this.currentState === _State.State.FAILED || this.currentState === _State.State.CANCELLED;
+  set shouldCancelWhenOutside(value) {
+    this._shouldCancelWhenOutside = value;
+  }
+
+  get enabled() {
+    return this._enabled;
+  }
+
+  set enabled(value) {
+    this._enabled = value;
+  }
+
+  get pointerType() {
+    return this._pointerType;
+  }
+
+  set pointerType(value) {
+    this._pointerType = value;
+  }
+
+  get active() {
+    return this._active;
   }
 
-  setShouldCancelWhenOutside(shouldCancel) {
-    this.shouldCancelWhenOutside = shouldCancel;
+  set active(value) {
+    this._active = value;
   }
 
-  getShouldCancelWhenOutside() {
-    return this.shouldCancelWhenOutside;
+  get awaiting() {
+    return this._awaiting;
   }
 
-  getPointerType() {
-    return this.pointerType;
+  set awaiting(value) {
+    this._awaiting = value;
+  }
+
+  get activationIndex() {
+    return this._activationIndex;
+  }
+
+  set activationIndex(value) {
+    this._activationIndex = value;
+  }
+
+  get shouldResetProgress() {
+    return this._shouldResetProgress;
+  }
+
+  set shouldResetProgress(value) {
+    this._shouldResetProgress = value;
+  }
+
+  getTrackedPointersID() {
+    return this.tracker.trackedPointersIDs;
+  }
+
+  isFinished() {
+    return this.state === _State.State.END || this.state === _State.State.FAILED || this.state === _State.State.CANCELLED;
   }
 
 }