react-native-gesture-handler 2.25.0 → 2.26.0

package/lib/{module/web/handlers/NativeViewGestureHandler.js → commonjs/web/handlers/NativeViewGestureHandler.ts}

@@ -1,84 +1,75 @@
-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 { Platform } from 'react-native';
 import { State } from '../../State';
 import { DEFAULT_TOUCH_SLOP } from '../constants';
+import { AdaptedEvent, Config } from '../interfaces';
+
 import GestureHandler from './GestureHandler';
 export default class NativeViewGestureHandler extends GestureHandler {
-  constructor(...args) {
-    super(...args);
-
-    _defineProperty(this, "buttonRole", void 0);
-
-    _defineProperty(this, "shouldActivateOnStart", false);
+  private buttonRole!: boolean;
 
-    _defineProperty(this, "disallowInterruption", false);
+  // TODO: Implement logic for activation on start
+  // @ts-ignore Logic yet to be implemented
+  private shouldActivateOnStart = false;
+  private disallowInterruption = false;
 
-    _defineProperty(this, "startX", 0);
+  private startX = 0;
+  private startY = 0;
+  private minDistSq = DEFAULT_TOUCH_SLOP * DEFAULT_TOUCH_SLOP;
 
-    _defineProperty(this, "startY", 0);
-
-    _defineProperty(this, "minDistSq", DEFAULT_TOUCH_SLOP * DEFAULT_TOUCH_SLOP);
-  }
-
-  init(ref, propsRef) {
+  public init(ref: number, propsRef: React.RefObject<unknown>): void {
     super.init(ref, propsRef);
+
     this.shouldCancelWhenOutside = true;
 
     if (Platform.OS !== 'web') {
       return;
     }
 
-    const view = this.delegate.view;
+    const view = this.delegate.view as HTMLElement;
+
     this.restoreViewStyles(view);
     this.buttonRole = view.getAttribute('role') === 'button';
   }
 
-  updateGestureConfig({
-    enabled = true,
-    ...props
-  }) {
-    super.updateGestureConfig({
-      enabled: enabled,
-      ...props
-    });
+  public updateGestureConfig({ enabled = true, ...props }: Config): void {
+    super.updateGestureConfig({ enabled: enabled, ...props });
 
     if (this.config.shouldActivateOnStart !== undefined) {
       this.shouldActivateOnStart = this.config.shouldActivateOnStart;
     }
-
     if (this.config.disallowInterruption !== undefined) {
       this.disallowInterruption = this.config.disallowInterruption;
     }
 
-    const view = this.delegate.view;
+    const view = this.delegate.view as HTMLElement;
     this.restoreViewStyles(view);
   }
 
-  restoreViewStyles(view) {
+  private restoreViewStyles(view: HTMLElement) {
     if (!view) {
       return;
     }
 
-    view.style['touchAction'] = 'auto'; // @ts-ignore Turns on defualt touch behavior on Safari
-
+    view.style['touchAction'] = 'auto';
+    // @ts-ignore Turns on defualt touch behavior on Safari
     view.style['WebkitTouchCallout'] = 'auto';
   }
 
-  onPointerDown(event) {
+  protected onPointerDown(event: AdaptedEvent): void {
     this.tracker.addToTracker(event);
     super.onPointerDown(event);
     this.newPointerAction();
+
     this.tryToSendTouchEvent(event);
   }
 
-  onPointerAdd(event) {
+  protected onPointerAdd(event: AdaptedEvent): void {
     this.tracker.addToTracker(event);
     super.onPointerAdd(event);
     this.newPointerAction();
   }
 
-  newPointerAction() {
+  private newPointerAction(): void {
     const lastCoords = this.tracker.getAbsoluteCoordsAverage();
     this.startX = lastCoords.x;
     this.startY = lastCoords.y;
@@ -88,7 +79,8 @@ export default class NativeViewGestureHandler extends GestureHandler {
     }
 
     this.begin();
-    const view = this.delegate.view;
+
+    const view = this.delegate.view as HTMLElement;
     const isRNGHText = view.hasAttribute('rnghtext');
 
     if (this.buttonRole || isRNGHText) {
@@ -96,8 +88,9 @@ export default class NativeViewGestureHandler extends GestureHandler {
     }
   }
 
-  onPointerMove(event) {
+  protected onPointerMove(event: AdaptedEvent): void {
     this.tracker.track(event);
+
     const lastCoords = this.tracker.getAbsoluteCoordsAverage();
     const dx = this.startX - lastCoords.x;
     const dy = this.startY - lastCoords.y;
@@ -112,23 +105,23 @@ export default class NativeViewGestureHandler extends GestureHandler {
     }
   }
 
-  onPointerLeave() {
+  protected onPointerLeave(): void {
     if (this.state === State.BEGAN || this.state === State.ACTIVE) {
       this.cancel();
     }
   }
 
-  onPointerUp(event) {
+  protected onPointerUp(event: AdaptedEvent): void {
     super.onPointerUp(event);
     this.onUp(event);
   }
 
-  onPointerRemove(event) {
+  protected onPointerRemove(event: AdaptedEvent): void {
     super.onPointerRemove(event);
     this.onUp(event);
   }
 
-  onUp(event) {
+  private onUp(event: AdaptedEvent): void {
     this.tracker.removeFromTracker(event.pointerId);
 
     if (this.tracker.trackedPointersCount === 0) {
@@ -140,35 +133,43 @@ export default class NativeViewGestureHandler extends GestureHandler {
     }
   }
 
-  shouldRecognizeSimultaneously(handler) {
+  public shouldRecognizeSimultaneously(handler: GestureHandler): boolean {
     if (super.shouldRecognizeSimultaneously(handler)) {
       return true;
     }
 
-    if (handler instanceof NativeViewGestureHandler && handler.state === State.ACTIVE && handler.disallowsInterruption()) {
+    if (
+      handler instanceof NativeViewGestureHandler &&
+      handler.state === State.ACTIVE &&
+      handler.disallowsInterruption()
+    ) {
       return false;
     }
 
     const canBeInterrupted = !this.disallowInterruption;
 
-    if (this.state === State.ACTIVE && handler.state === State.ACTIVE && canBeInterrupted) {
+    if (
+      this.state === State.ACTIVE &&
+      handler.state === State.ACTIVE &&
+      canBeInterrupted
+    ) {
       return false;
     }
 
-    return this.state === State.ACTIVE && canBeInterrupted && handler.handlerTag > 0;
+    return (
+      this.state === State.ACTIVE && canBeInterrupted && handler.handlerTag > 0
+    );
   }
 
-  shouldBeCancelledByOther(_handler) {
+  public shouldBeCancelledByOther(_handler: GestureHandler): boolean {
     return !this.disallowInterruption;
   }
 
-  disallowsInterruption() {
+  public disallowsInterruption(): boolean {
     return this.disallowInterruption;
   }
 
-  isButton() {
+  public isButton(): boolean {
     return this.buttonRole;
   }
-
 }
-//# sourceMappingURL=NativeViewGestureHandler.js.map