react-native-gesture-handler 2.22.1 → 2.23.0

package/lib/module/web_hammer/GestureHandler.js

@@ -1,73 +1,53 @@
-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; }
-
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 /* eslint-disable eslint-comments/no-unlimited-disable */
-
 /* eslint-disable */
 import Hammer from '@egjs/hammerjs';
 import { findNodeHandle } from 'react-native';
 import { State } from '../State';
 import { EventMap } from './constants';
 import * as NodeManager from './NodeManager';
-import { ghQueueMicrotask } from '../ghQueueMicrotask'; // TODO(TS) Replace with HammerInput if https://github.com/DefinitelyTyped/DefinitelyTyped/pull/50438/files is merged
+import { ghQueueMicrotask } from '../ghQueueMicrotask';
 
-let gestureInstances = 0;
+// TODO(TS) Replace with HammerInput if https://github.com/DefinitelyTyped/DefinitelyTyped/pull/50438/files is merged
 
+let gestureInstances = 0;
 class GestureHandler {
   get id() {
     return `${this.name}${this.gestureInstance}`;
-  } // a simple way to check if GestureHandler is NativeViewGestureHandler, since importing it
-  // here to use instanceof would cause import cycle
-
+  }
 
+  // a simple way to check if GestureHandler is NativeViewGestureHandler, since importing it
+  // here to use instanceof would cause import cycle
   get isNative() {
     return false;
   }
-
   get isDiscrete() {
     return false;
   }
-
   get shouldEnableGestureOnSetup() {
     throw new Error('Must override GestureHandler.shouldEnableGestureOnSetup');
   }
-
   constructor() {
     _defineProperty(this, "handlerTag", void 0);
-
     _defineProperty(this, "isGestureRunning", false);
-
     _defineProperty(this, "view", null);
-
     _defineProperty(this, "hasCustomActivationCriteria", void 0);
-
     _defineProperty(this, "hasGestureFailed", false);
-
     _defineProperty(this, "hammer", null);
-
     _defineProperty(this, "initialRotation", null);
-
     _defineProperty(this, "__initialX", void 0);
-
     _defineProperty(this, "__initialY", void 0);
-
     _defineProperty(this, "config", {});
-
     _defineProperty(this, "previousState", State.UNDETERMINED);
-
     _defineProperty(this, "pendingGestures", {});
-
     _defineProperty(this, "oldState", State.UNDETERMINED);
-
     _defineProperty(this, "lastSentState", null);
-
     _defineProperty(this, "gestureInstance", void 0);
-
     _defineProperty(this, "_stillWaiting", void 0);
-
     _defineProperty(this, "propsRef", void 0);
-
     _defineProperty(this, "ref", void 0);
-
     _defineProperty(this, "clearSelfAsPending", () => {
       if (Array.isArray(this.config.waitFor)) {
         for (const gesture of this.config.waitFor) {
@@ -75,18 +55,14 @@ class GestureHandler {
         }
       }
     });
-
     _defineProperty(this, "destroy", () => {
       this.clearSelfAsPending();
-
       if (this.hammer) {
         this.hammer.stop(false);
         this.hammer.destroy();
       }
-
       this.hammer = null;
     });
-
     _defineProperty(this, "isPointInView", ({
       x,
       y
@@ -96,7 +72,6 @@ class GestureHandler {
       const pointerInside = x >= rect.left && x <= rect.right && y >= rect.top && y <= rect.bottom;
       return pointerInside;
     });
-
     _defineProperty(this, "sendEvent", nativeEvent => {
       const {
         onGestureHandlerEvent,
@@ -104,42 +79,36 @@ class GestureHandler {
       } = this.propsRef.current;
       const event = this.transformEventData(nativeEvent);
       invokeNullableMethod(onGestureHandlerEvent, event);
-
       if (this.lastSentState !== event.nativeEvent.state) {
         this.lastSentState = event.nativeEvent.state;
         invokeNullableMethod(onGestureHandlerStateChange, event);
       }
     });
-
     _defineProperty(this, "sync", () => {
       const gesture = this.hammer.get(this.name);
       if (!gesture) return;
-
       const enable = (recognizer, inputData) => {
         if (!this.config.enabled) {
           this.isGestureRunning = false;
           this.hasGestureFailed = false;
           return false;
-        } // Prevent events before the system is ready.
-
+        }
 
+        // Prevent events before the system is ready.
         if (!inputData || !recognizer.options || typeof inputData.maxPointers === 'undefined') {
           return this.shouldEnableGestureOnSetup;
         }
-
         if (this.hasGestureFailed) {
           return false;
         }
-
         if (!this.isDiscrete) {
           if (this.isGestureRunning) {
             return true;
-          } // The built-in hammer.js "waitFor" doesn't work across multiple views.
+          }
+          // The built-in hammer.js "waitFor" doesn't work across multiple views.
           // Only process if there are views to wait for.
-
-
-          this._stillWaiting = this._getPendingGestures(); // This gesture should continue waiting.
-
+          this._stillWaiting = this._getPendingGestures();
+          // This gesture should continue waiting.
           if (this._stillWaiting.length) {
             // Check to see if one of the gestures you're waiting for has started.
             // If it has then the gesture should fail.
@@ -150,74 +119,62 @@ class GestureHandler {
                 this.isGestureRunning = false;
                 return false;
               }
-            } // This gesture shouldn't start until the others have finished.
-
-
+            }
+            // This gesture shouldn't start until the others have finished.
             return false;
           }
-        } // Use default behaviour
-
+        }
 
+        // Use default behaviour
         if (!this.hasCustomActivationCriteria) {
           return true;
         }
-
-        const deltaRotation = this.initialRotation == null ? 0 : inputData.rotation - this.initialRotation; // @ts-ignore FIXME(TS)
-
+        const deltaRotation = this.initialRotation == null ? 0 : inputData.rotation - this.initialRotation;
+        // @ts-ignore FIXME(TS)
         const {
           success,
           failed
-        } = this.isGestureEnabledForEvent(this.getConfig(), recognizer, { ...inputData,
+        } = this.isGestureEnabledForEvent(this.getConfig(), recognizer, {
+          ...inputData,
           deltaRotation
         });
-
         if (failed) {
           this.simulateCancelEvent(inputData);
           this.hasGestureFailed = true;
         }
-
         return success;
       };
-
-      const params = this.getHammerConfig(); // @ts-ignore FIXME(TS)
-
-      gesture.set({ ...params,
+      const params = this.getHammerConfig();
+      // @ts-ignore FIXME(TS)
+      gesture.set({
+        ...params,
         enable
       });
     });
-
     this.gestureInstance = gestureInstances++;
     this.hasCustomActivationCriteria = false;
   }
-
   getConfig() {
     return this.config;
   }
-
   onWaitingEnded(_gesture) {}
-
   removePendingGesture(id) {
     delete this.pendingGestures[id];
   }
-
   addPendingGesture(gesture) {
     this.pendingGestures[gesture.id] = gesture;
   }
-
   isGestureEnabledForEvent(_config, _recognizer, _event) {
     return {
       success: true
     };
   }
-
   get NativeGestureClass() {
     throw new Error('Must override GestureHandler.NativeGestureClass');
   }
-
   updateHasCustomActivationCriteria(_config) {
     return true;
   }
-
   updateGestureConfig({
     enabled = true,
     ...props
@@ -228,48 +185,41 @@ class GestureHandler {
       ...props
     });
     this.hasCustomActivationCriteria = this.updateHasCustomActivationCriteria(this.config);
-
     if (Array.isArray(this.config.waitFor)) {
       for (const gesture of this.config.waitFor) {
         gesture.addPendingGesture(this);
       }
     }
-
     if (this.hammer) {
       this.sync();
     }
-
     return this.config;
   }
-
   getState(type) {
     // @ts-ignore TODO(TS) check if this is needed
     if (type == 0) {
       return 0;
     }
-
     return EventMap[type];
   }
-
   transformEventData(event) {
     const {
       eventType,
       maxPointers: numberOfPointers
-    } = event; // const direction = DirectionMap[ev.direction];
-
+    } = event;
+    // const direction = DirectionMap[ev.direction];
     const changedTouch = event.changedPointers[0];
     const pointerInside = this.isPointInView({
       x: changedTouch.clientX,
       y: changedTouch.clientY
-    }); // TODO(TS) Remove cast after https://github.com/DefinitelyTyped/DefinitelyTyped/pull/50966 is merged.
+    });
 
+    // TODO(TS) Remove cast after https://github.com/DefinitelyTyped/DefinitelyTyped/pull/50966 is merged.
     const state = this.getState(eventType);
-
     if (state !== this.previousState) {
       this.oldState = this.previousState;
       this.previousState = state;
     }
-
     return {
       nativeEvent: {
         numberOfPointers,
@@ -287,11 +237,9 @@ class GestureHandler {
       timeStamp: Date.now()
     };
   }
-
   transformNativeEvent(_event) {
     return {};
   }
-
   cancelPendingGestures(event) {
     for (const gesture of Object.values(this.pendingGestures)) {
       if (gesture && gesture.isGestureRunning) {
@@ -300,37 +248,34 @@ class GestureHandler {
       }
     }
   }
-
   notifyPendingGestures() {
     for (const gesture of Object.values(this.pendingGestures)) {
       if (gesture) {
         gesture.onWaitingEnded(this);
       }
     }
-  } // FIXME event is undefined in runtime when firstly invoked (see Draggable example), check other functions taking event as input
-
+  }
 
+  // FIXME event is undefined in runtime when firstly invoked (see Draggable example), check other functions taking event as input
   onGestureEnded(event) {
     this.isGestureRunning = false;
     this.cancelPendingGestures(event);
   }
-
   forceInvalidate(event) {
     if (this.isGestureRunning) {
       this.hasGestureFailed = true;
       this.cancelEvent(event);
     }
   }
-
   cancelEvent(event) {
     this.notifyPendingGestures();
-    this.sendEvent({ ...event,
+    this.sendEvent({
+      ...event,
       eventType: Hammer.INPUT_CANCEL,
       isFinal: true
     });
     this.onGestureEnded(event);
   }
-
   onRawEvent({
     isFirst
   }) {
@@ -338,28 +283,26 @@ class GestureHandler {
       this.hasGestureFailed = false;
     }
   }
-
   shouldUseTouchEvents(config) {
     var _config$simultaneousH, _config$simultaneousH2;
-
     return (_config$simultaneousH = (_config$simultaneousH2 = config.simultaneousHandlers) === null || _config$simultaneousH2 === void 0 ? void 0 : _config$simultaneousH2.some(handler => handler.isNative)) !== null && _config$simultaneousH !== void 0 ? _config$simultaneousH : false;
   }
-
   setView(ref, propsRef) {
     if (ref == null) {
       this.destroy();
       this.view = null;
       return;
-    } // @ts-ignore window doesn't exist on global type as we don't want to use Node types
-
+    }
 
-    const SUPPORTS_TOUCH = ('ontouchstart' in window);
+    // @ts-ignore window doesn't exist on global type as we don't want to use Node types
+    const SUPPORTS_TOUCH = 'ontouchstart' in window;
     this.propsRef = propsRef;
     this.ref = ref;
-    this.view = findNodeHandle(ref); // When the browser starts handling the gesture (e.g. scrolling), it sends a pointercancel event and stops
+    this.view = findNodeHandle(ref);
+
+    // When the browser starts handling the gesture (e.g. scrolling), it sends a pointercancel event and stops
     // sending additional pointer events. This is not the case with touch events, so if the gesture is simultaneous
     // with a NativeGestureHandler, we need to check if touch events are supported and use them if possible.
-
     this.hammer = SUPPORTS_TOUCH && this.shouldUseTouchEvents(this.config) ? new Hammer.Manager(this.view, {
       inputClass: Hammer.TouchInput
     }) : new Hammer.Manager(this.view);
@@ -368,8 +311,8 @@ class GestureHandler {
     this.lastSentState = null;
     const {
       NativeGestureClass
-    } = this; // @ts-ignore TODO(TS)
-
+    } = this;
+    // @ts-ignore TODO(TS)
     const gesture = new NativeGestureClass(this.getHammerConfig());
     this.hammer.add(gesture);
     this.hammer.on('hammer.input', ev => {
@@ -378,14 +321,13 @@ class GestureHandler {
         this.isGestureRunning = false;
         return;
       }
+      this.onRawEvent(ev);
 
-      this.onRawEvent(ev); // TODO: Bacon: Check against something other than null
+      // TODO: Bacon: Check against something other than null
       // The isFirst value is not called when the first rotation is calculated.
-
       if (this.initialRotation === null && ev.rotation !== 0) {
         this.initialRotation = ev.rotation;
       }
-
       if (ev.isFinal) {
         // in favor of a willFail otherwise the last frame of the gesture will be captured.
         setTimeout(() => {
@@ -397,7 +339,6 @@ class GestureHandler {
     this.setupEvents();
     this.sync();
   }
-
   setupEvents() {
     // TODO(TS) Hammer types aren't exactly that what we get in runtime
     if (!this.isDiscrete) {
@@ -406,10 +347,8 @@ class GestureHandler {
         this.onGestureEnded(event);
       });
     }
-
     this.hammer.on(this.name, ev => this.onGestureActivated(ev)); // TODO(TS) remove cast after https://github.com/DefinitelyTyped/DefinitelyTyped/pull/50438 is merged
   }
-
   onStart({
     deltaX,
     deltaY,
@@ -424,13 +363,10 @@ class GestureHandler {
     this.__initialY = deltaY;
     this.initialRotation = rotation;
   }
-
   onGestureActivated(ev) {
     this.sendEvent(ev);
   }
-
   onSuccess() {}
-
   _getPendingGestures() {
     if (Array.isArray(this.config.waitFor) && this.config.waitFor.length) {
       // Get the list of gestures that this gesture is still waiting for.
@@ -440,39 +376,35 @@ class GestureHandler {
       }) => hasGestureFailed === false);
       return stillWaiting;
     }
-
     return [];
   }
-
   getHammerConfig() {
     const pointers = this.config.minPointers === this.config.maxPointers ? this.config.minPointers : 0;
     return {
       pointers
     };
   }
+  simulateCancelEvent(_inputData) {}
 
-  simulateCancelEvent(_inputData) {} // Validate the props
-
-
+  // Validate the props
   ensureConfig(config) {
-    const props = { ...config
-    }; // TODO(TS) We use ! to assert that if property is present then value is not empty (null, undefined)
+    const props = {
+      ...config
+    };
 
+    // TODO(TS) We use ! to assert that if property is present then value is not empty (null, undefined)
     if ('minDist' in config) {
       props.minDist = config.minDist;
       props.minDistSq = props.minDist * props.minDist;
     }
-
     if ('minVelocity' in config) {
       props.minVelocity = config.minVelocity;
       props.minVelocitySq = props.minVelocity * props.minVelocity;
     }
-
     if ('maxDist' in config) {
       props.maxDist = config.maxDist;
       props.maxDistSq = config.maxDist * config.maxDist;
     }
-
     if ('waitFor' in config) {
       props.waitFor = asArray(config.waitFor).map(({
         handlerTag
@@ -480,7 +412,6 @@ class GestureHandler {
     } else {
       props.waitFor = null;
     }
-
     if ('simultaneousHandlers' in config) {
       const shouldUseTouchEvents = this.shouldUseTouchEvents(this.config);
       props.simultaneousHandlers = asArray(config.simultaneousHandlers).map(handler => {
@@ -490,7 +421,6 @@ class GestureHandler {
           return NodeManager.getHandler(handler.handlerTag);
         }
       }).filter(v => v);
-
       if (shouldUseTouchEvents !== this.shouldUseTouchEvents(props)) {
         ghQueueMicrotask(() => {
           // if the undelying event API needs to be changed, we need to unmount and mount
@@ -502,7 +432,6 @@ class GestureHandler {
     } else {
       props.simultaneousHandlers = null;
     }
-
     const configProps = ['minPointers', 'maxPointers', 'minDist', 'maxDist', 'maxDistSq', 'minVelocitySq', 'minDistSq', 'minVelocity', 'failOffsetXStart', 'failOffsetYStart', 'failOffsetXEnd', 'failOffsetYEnd', 'activeOffsetXStart', 'activeOffsetXEnd', 'activeOffsetYStart', 'activeOffsetYEnd'];
     configProps.forEach(prop => {
       if (typeof props[prop] === 'undefined') {
@@ -511,11 +440,10 @@ class GestureHandler {
     });
     return props; // TODO(TS) how to convince TS that props are filled?
   }
+}
 
-} // TODO(TS) investigate this method
+// TODO(TS) investigate this method
 // Used for sending data to a callback or AnimatedEvent
-
-
 function invokeNullableMethod(method, event) {
   if (method) {
     if (typeof method === 'function') {
@@ -524,20 +452,17 @@ function invokeNullableMethod(method, event) {
       // For use with reanimated's AnimatedEvent
       if ('__getHandler' in method && typeof method.__getHandler === 'function') {
         const handler = method.__getHandler();
-
         invokeNullableMethod(handler, event);
       } else {
         if ('__nodeConfig' in method) {
           const {
             argMapping
           } = method.__nodeConfig;
-
           if (Array.isArray(argMapping)) {
             for (const [index, [key, value]] of argMapping.entries()) {
               if (key in event.nativeEvent) {
                 // @ts-ignore fix method type
                 const nativeValue = event.nativeEvent[key];
-
                 if (value && value.setValue) {
                   // Reanimated API
                   value.setValue(nativeValue);
@@ -553,11 +478,9 @@ function invokeNullableMethod(method, event) {
     }
   }
 }
-
 function asArray(value) {
   // TODO(TS) use config.waitFor type
   return value == null ? [] : Array.isArray(value) ? value : [value];
 }
-
 export default GestureHandler;
 //# sourceMappingURL=GestureHandler.js.map