@react-native-oh-tpl/react-native-gesture-handler 2.12.1-0.0.1 → 2.12.6-1

package/src/web/tools/PointerEventManager.ts

@@ -1,202 +0,0 @@
-import { AdaptedEvent, EventTypes, PointerType } from '../interfaces';
-import EventManager from './EventManager';
-import { isPointerInBounds } from '../utils';
-
-export default class PointerEventManager extends EventManager<HTMLElement> {
-  private trackedPointers = new Set<number>();
-
-  public setListeners(): void {
-    this.view.addEventListener('pointerdown', (event: PointerEvent): void => {
-      if (event.pointerType === PointerType.TOUCH) {
-        return;
-      }
-      if (
-        !isPointerInBounds(this.view, { x: event.clientX, y: event.clientY })
-      ) {
-        return;
-      }
-
-      const adaptedEvent: AdaptedEvent = this.mapEvent(event, EventTypes.DOWN);
-      const target = event.target as HTMLElement;
-
-      if (target instanceof HTMLDivElement) {
-        target.setPointerCapture(adaptedEvent.pointerId);
-      }
-
-      this.markAsInBounds(adaptedEvent.pointerId);
-      this.trackedPointers.add(adaptedEvent.pointerId);
-
-      if (++this.activePointersCounter > 1) {
-        adaptedEvent.eventType = EventTypes.ADDITIONAL_POINTER_DOWN;
-        this.onPointerAdd(adaptedEvent);
-      } else {
-        this.onPointerDown(adaptedEvent);
-      }
-    });
-
-    this.view.addEventListener('pointerup', (event: PointerEvent): void => {
-      if (event.pointerType === PointerType.TOUCH) {
-        return;
-      }
-
-      // When we call reset on gesture handlers, it also resets their event managers
-      // In some handlers (like RotationGestureHandler) reset is called before all pointers leave view
-      // This means, that activePointersCounter will be set to 0, while there are still remaining pointers on view
-      // Removing them will end in activePointersCounter going below 0, therefore handlers won't behave properly
-      if (this.activePointersCounter === 0) {
-        return;
-      }
-
-      const adaptedEvent: AdaptedEvent = this.mapEvent(event, EventTypes.UP);
-      const target = event.target as HTMLElement;
-
-      if (target instanceof HTMLDivElement) {
-        target.releasePointerCapture(adaptedEvent.pointerId);
-      }
-
-      this.markAsOutOfBounds(adaptedEvent.pointerId);
-      this.trackedPointers.delete(adaptedEvent.pointerId);
-
-      if (--this.activePointersCounter > 0) {
-        adaptedEvent.eventType = EventTypes.ADDITIONAL_POINTER_UP;
-        this.onPointerRemove(adaptedEvent);
-      } else {
-        this.onPointerUp(adaptedEvent);
-      }
-    });
-
-    this.view.addEventListener('pointermove', (event: PointerEvent): void => {
-      if (event.pointerType === PointerType.TOUCH) {
-        return;
-      }
-
-      const adaptedEvent: AdaptedEvent = this.mapEvent(event, EventTypes.MOVE);
-      const target = event.target as HTMLElement;
-
-      // You may be wondering why are we setting pointer capture here, when we
-      // already set it in `pointerdown` handler. Well, that's a great question,
-      // for which I don't have an answer. Specification (https://www.w3.org/TR/pointerevents2/#dom-element-setpointercapture)
-      // says that the requirement for `setPointerCapture` to work is that pointer
-      // must be in 'active buttons state`, otherwise it will fail silently, which
-      // is lovely. Obviously, when `pointerdown` is fired, one of the buttons
-      // (when using mouse) is pressed, but that doesn't mean that `setPointerCapture`
-      // will succeed, for some reason. Since it fails silently, we don't actually know
-      // if it worked or not (there's `gotpointercapture` event, but the complexity of
-      // incorporating it here seems stupid), so we just call it again here, every time
-      // pointer moves until it succeeds.
-      // God, I do love web development.
-      if (
-        !target.hasPointerCapture(event.pointerId) &&
-        target instanceof HTMLDivElement
-      ) {
-        target.setPointerCapture(event.pointerId);
-      }
-
-      const inBounds: boolean = isPointerInBounds(this.view, {
-        x: adaptedEvent.x,
-        y: adaptedEvent.y,
-      });
-
-      const pointerIndex: number = this.pointersInBounds.indexOf(
-        adaptedEvent.pointerId
-      );
-
-      if (inBounds) {
-        if (pointerIndex < 0) {
-          adaptedEvent.eventType = EventTypes.ENTER;
-          this.onPointerEnter(adaptedEvent);
-          this.markAsInBounds(adaptedEvent.pointerId);
-        } else {
-          this.onPointerMove(adaptedEvent);
-        }
-      } else {
-        if (pointerIndex >= 0) {
-          adaptedEvent.eventType = EventTypes.LEAVE;
-          this.onPointerLeave(adaptedEvent);
-          this.markAsOutOfBounds(adaptedEvent.pointerId);
-        } else {
-          this.onPointerOutOfBounds(adaptedEvent);
-        }
-      }
-    });
-
-    this.view.addEventListener('pointercancel', (event: PointerEvent): void => {
-      if (event.pointerType === PointerType.TOUCH) {
-        return;
-      }
-
-      const adaptedEvent: AdaptedEvent = this.mapEvent(
-        event,
-        EventTypes.CANCEL
-      );
-
-      this.onPointerCancel(adaptedEvent);
-      this.markAsOutOfBounds(adaptedEvent.pointerId);
-      this.activePointersCounter = 0;
-      this.trackedPointers.clear();
-    });
-
-    // onPointerEnter and onPointerLeave are triggered by a custom logic responsible for
-    // handling shouldCancelWhenOutside flag, and are unreliable unless the pointer is down.
-    // We therefore use pointerenter and pointerleave events to handle the hover gesture,
-    // mapping them to onPointerMoveOver and onPointerMoveOut respectively.
-
-    this.view.addEventListener('pointerenter', (event: PointerEvent): void => {
-      if (event.pointerType === PointerType.TOUCH) {
-        return;
-      }
-
-      const adaptedEvent: AdaptedEvent = this.mapEvent(event, EventTypes.ENTER);
-
-      this.onPointerMoveOver(adaptedEvent);
-    });
-
-    this.view.addEventListener('pointerleave', (event: PointerEvent): void => {
-      if (event.pointerType === PointerType.TOUCH) {
-        return;
-      }
-
-      const adaptedEvent: AdaptedEvent = this.mapEvent(event, EventTypes.LEAVE);
-
-      this.onPointerMoveOut(adaptedEvent);
-    });
-
-    this.view.addEventListener(
-      'lostpointercapture',
-      (event: PointerEvent): void => {
-        const adaptedEvent: AdaptedEvent = this.mapEvent(
-          event,
-          EventTypes.CANCEL
-        );
-
-        if (this.trackedPointers.has(adaptedEvent.pointerId)) {
-          // in some cases the `pointerup` event is not fired, but `lostpointercapture` is
-          // we simulate the `pointercancel` event here to make sure the gesture handler stops tracking it
-          this.onPointerCancel(adaptedEvent);
-
-          this.activePointersCounter = 0;
-          this.trackedPointers.clear();
-        }
-      }
-    );
-  }
-
-  protected mapEvent(event: PointerEvent, eventType: EventTypes): AdaptedEvent {
-    return {
-      x: event.clientX,
-      y: event.clientY,
-      offsetX: event.offsetX,
-      offsetY: event.offsetY,
-      pointerId: event.pointerId,
-      eventType: eventType,
-      pointerType: event.pointerType as PointerType,
-      buttons: event.buttons,
-      time: event.timeStamp,
-    };
-  }
-
-  public resetManager(): void {
-    super.resetManager();
-    this.trackedPointers.clear();
-  }
-}

package/src/web/tools/TouchEventManager.ts

@@ -1,167 +0,0 @@
-import {
-  AdaptedEvent,
-  EventTypes,
-  MouseButtons,
-  PointerType,
-  TouchEventType,
-} from '../interfaces';
-import EventManager from './EventManager';
-import { isPointerInBounds } from '../utils';
-
-export default class TouchEventManager extends EventManager<HTMLElement> {
-  public setListeners(): void {
-    this.view.addEventListener('touchstart', (event: TouchEvent) => {
-      for (let i = 0; i < event.changedTouches.length; ++i) {
-        const adaptedEvent: AdaptedEvent = this.mapEvent(
-          event,
-          EventTypes.DOWN,
-          i,
-          TouchEventType.DOWN
-        );
-
-        // Here we skip stylus, because in case of anything different than touch we want to handle it by using PointerEvents
-        // If we leave stylus to send touch events, handlers will receive every action twice
-        if (
-          !isPointerInBounds(this.view, {
-            x: adaptedEvent.x,
-            y: adaptedEvent.y,
-          }) ||
-          //@ts-ignore touchType field does exist
-          event.changedTouches[i].touchType === 'stylus'
-        ) {
-          continue;
-        }
-
-        this.markAsInBounds(adaptedEvent.pointerId);
-
-        if (++this.activePointersCounter > 1) {
-          adaptedEvent.eventType = EventTypes.ADDITIONAL_POINTER_DOWN;
-          this.onPointerAdd(adaptedEvent);
-        } else {
-          this.onPointerDown(adaptedEvent);
-        }
-      }
-    });
-
-    this.view.addEventListener('touchmove', (event: TouchEvent) => {
-      for (let i = 0; i < event.changedTouches.length; ++i) {
-        const adaptedEvent: AdaptedEvent = this.mapEvent(
-          event,
-          EventTypes.MOVE,
-          i,
-          TouchEventType.MOVE
-        );
-        //@ts-ignore touchType field does exist
-        if (event.changedTouches[i].touchType === 'stylus') {
-          continue;
-        }
-
-        const inBounds: boolean = isPointerInBounds(this.view, {
-          x: adaptedEvent.x,
-          y: adaptedEvent.y,
-        });
-
-        const pointerIndex: number = this.pointersInBounds.indexOf(
-          adaptedEvent.pointerId
-        );
-
-        if (inBounds) {
-          if (pointerIndex < 0) {
-            adaptedEvent.eventType = EventTypes.ENTER;
-            this.onPointerEnter(adaptedEvent);
-            this.markAsInBounds(adaptedEvent.pointerId);
-          } else {
-            this.onPointerMove(adaptedEvent);
-          }
-        } else {
-          if (pointerIndex >= 0) {
-            adaptedEvent.eventType = EventTypes.LEAVE;
-            this.onPointerLeave(adaptedEvent);
-            this.markAsOutOfBounds(adaptedEvent.pointerId);
-          } else {
-            this.onPointerOutOfBounds(adaptedEvent);
-          }
-        }
-      }
-    });
-
-    this.view.addEventListener('touchend', (event: TouchEvent) => {
-      for (let i = 0; i < event.changedTouches.length; ++i) {
-        // When we call reset on gesture handlers, it also resets their event managers
-        // In some handlers (like RotationGestureHandler) reset is called before all pointers leave view
-        // This means, that activePointersCounter will be set to 0, while there are still remaining pointers on view
-        // Removing them will end in activePointersCounter going below 0, therefore handlers won't behave properly
-        if (this.activePointersCounter === 0) {
-          break;
-        }
-
-        //@ts-ignore touchType field does exist
-        if (event.changedTouches[i].touchType === 'stylus') {
-          continue;
-        }
-
-        const adaptedEvent: AdaptedEvent = this.mapEvent(
-          event,
-          EventTypes.UP,
-          i,
-          TouchEventType.UP
-        );
-
-        this.markAsOutOfBounds(adaptedEvent.pointerId);
-
-        if (--this.activePointersCounter > 0) {
-          adaptedEvent.eventType = EventTypes.ADDITIONAL_POINTER_UP;
-          this.onPointerRemove(adaptedEvent);
-        } else {
-          this.onPointerUp(adaptedEvent);
-        }
-      }
-    });
-
-    this.view.addEventListener('touchcancel', (event: TouchEvent) => {
-      for (let i = 0; i < event.changedTouches.length; ++i) {
-        const adaptedEvent: AdaptedEvent = this.mapEvent(
-          event,
-          EventTypes.CANCEL,
-          i,
-          TouchEventType.CANCELLED
-        );
-
-        //@ts-ignore touchType field does exist
-        if (event.changedTouches[i].touchType === 'stylus') {
-          continue;
-        }
-
-        this.onPointerCancel(adaptedEvent);
-        this.markAsOutOfBounds(adaptedEvent.pointerId);
-        this.activePointersCounter = 0;
-      }
-    });
-  }
-
-  protected mapEvent(
-    event: TouchEvent,
-    eventType: EventTypes,
-    index: number,
-    touchEventType: TouchEventType
-  ): AdaptedEvent {
-    const rect = this.view.getBoundingClientRect();
-    const clientX = event.changedTouches[index].clientX;
-    const clientY = event.changedTouches[index].clientY;
-
-    return {
-      x: clientX,
-      y: clientY,
-      offsetX: clientX - rect.left,
-      offsetY: clientY - rect.top,
-      pointerId: event.changedTouches[index].identifier,
-      eventType: eventType,
-      pointerType: PointerType.TOUCH,
-      buttons: MouseButtons.NONE,
-      time: event.timeStamp,
-      allTouches: event.touches,
-      changedTouches: event.changedTouches,
-      touchEventType: touchEventType,
-    };
-  }
-}

package/src/web/utils.ts

@@ -1,8 +0,0 @@
-export function isPointerInBounds(
-  view: HTMLElement,
-  { x, y }: { x: number; y: number }
-): boolean {
-  const rect: DOMRect = view.getBoundingClientRect();
-
-  return x >= rect.left && x <= rect.right && y >= rect.top && y <= rect.bottom;
-}

package/src/web_hammer/DiscreteGestureHandler.ts

@@ -1,82 +0,0 @@
-/* eslint-disable eslint-comments/no-unlimited-disable */
-/* eslint-disable */
-import GestureHandler from './GestureHandler';
-import { TEST_MAX_IF_NOT_NAN } from './utils';
-
-abstract class DiscreteGestureHandler extends GestureHandler {
-  get isDiscrete() {
-    return true;
-  }
-
-  get shouldEnableGestureOnSetup() {
-    return true;
-  }
-
-  shouldFailUnderCustomCriteria(
-    { x, y, deltaX, deltaY }: any,
-    { maxDeltaX, maxDeltaY, maxDistSq, shouldCancelWhenOutside }: any
-  ) {
-    if (shouldCancelWhenOutside) {
-      if (!this.isPointInView({ x, y })) {
-        return true;
-      }
-    }
-    return (
-      TEST_MAX_IF_NOT_NAN(Math.abs(deltaX), maxDeltaX) ||
-      TEST_MAX_IF_NOT_NAN(Math.abs(deltaY), maxDeltaY) ||
-      TEST_MAX_IF_NOT_NAN(
-        Math.abs(deltaY * deltaY + deltaX * deltaX),
-        maxDistSq
-      )
-    );
-  }
-
-  transformNativeEvent({ center: { x, y } }: any) {
-    // @ts-ignore FIXME(TS)
-    const rect = this.view!.getBoundingClientRect();
-
-    return {
-      absoluteX: x,
-      absoluteY: y,
-      x: x - rect.left,
-      y: y - rect.top,
-    };
-  }
-
-  isGestureEnabledForEvent(
-    {
-      minPointers,
-      maxPointers,
-      maxDeltaX,
-      maxDeltaY,
-      maxDistSq,
-      shouldCancelWhenOutside,
-    }: any,
-    _recognizer: any,
-    { maxPointers: pointerLength, center, deltaX, deltaY }: any
-  ) {
-    const validPointerCount =
-      pointerLength >= minPointers && pointerLength <= maxPointers;
-
-    if (
-      this.shouldFailUnderCustomCriteria(
-        { ...center, deltaX, deltaY },
-        {
-          maxDeltaX,
-          maxDeltaY,
-          maxDistSq,
-          shouldCancelWhenOutside,
-        }
-      ) ||
-      // A user probably won't land a multi-pointer tap on the first tick (so we cannot just cancel each time)
-      // but if the gesture is running and the user adds or subtracts another pointer then it should fail.
-      (!validPointerCount && this.isGestureRunning)
-    ) {
-      return { failed: true };
-    }
-
-    return { success: validPointerCount };
-  }
-}
-
-export default DiscreteGestureHandler;

package/src/web_hammer/DraggingGestureHandler.ts

@@ -1,34 +0,0 @@
-/* eslint-disable eslint-comments/no-unlimited-disable */
-/* eslint-disable */
-import GestureHandler, { HammerInputExt } from './GestureHandler';
-import { PixelRatio } from 'react-native';
-
-abstract class DraggingGestureHandler extends GestureHandler {
-  get shouldEnableGestureOnSetup() {
-    return true;
-  }
-
-  transformNativeEvent({
-    deltaX,
-    deltaY,
-    velocityX,
-    velocityY,
-    center: { x, y },
-  }: HammerInputExt) {
-    // @ts-ignore FIXME(TS)
-    const rect = this.view!.getBoundingClientRect();
-    const ratio = PixelRatio.get();
-    return {
-      translationX: deltaX - (this.__initialX || 0),
-      translationY: deltaY - (this.__initialY || 0),
-      absoluteX: x,
-      absoluteY: y,
-      velocityX: velocityX * ratio,
-      velocityY: velocityY * ratio,
-      x: x - rect.left,
-      y: y - rect.top,
-    };
-  }
-}
-
-export default DraggingGestureHandler;

package/src/web_hammer/Errors.ts

@@ -1,7 +0,0 @@
-export class GesturePropError extends Error {
-  constructor(name: string, value: unknown, expectedType: string) {
-    super(
-      `Invalid property \`${name}: ${value}\` expected \`${expectedType}\``
-    );
-  }
-}

package/src/web_hammer/FlingGestureHandler.ts

@@ -1,134 +0,0 @@
-/* eslint-disable eslint-comments/no-unlimited-disable */
-/* eslint-disable */
-import Hammer from '@egjs/hammerjs';
-
-import { Direction } from './constants';
-import { GesturePropError } from './Errors';
-import DraggingGestureHandler from './DraggingGestureHandler';
-import { isnan } from './utils';
-import { HammerInputExt } from './GestureHandler';
-
-class FlingGestureHandler extends DraggingGestureHandler {
-  get name() {
-    return 'swipe';
-  }
-
-  get NativeGestureClass() {
-    return Hammer.Swipe;
-  }
-
-  onGestureActivated(event: HammerInputExt) {
-    this.sendEvent({
-      ...event,
-      eventType: Hammer.INPUT_MOVE,
-      isFinal: false,
-      isFirst: true,
-    });
-    this.isGestureRunning = false;
-    this.hasGestureFailed = false;
-    this.sendEvent({
-      ...event,
-      eventType: Hammer.INPUT_END,
-      isFinal: true,
-    });
-  }
-
-  onRawEvent(ev: HammerInputExt) {
-    super.onRawEvent(ev);
-    if (this.hasGestureFailed) {
-      return;
-    }
-    // Hammer doesn't send a `cancel` event for taps.
-    // Manually fail the event.
-    if (ev.isFinal) {
-      setTimeout(() => {
-        if (this.isGestureRunning) {
-          this.cancelEvent(ev);
-        }
-      });
-    } else if (!this.hasGestureFailed && !this.isGestureRunning) {
-      // Tap Gesture start event
-      const gesture = this.hammer!.get(this.name);
-      // @ts-ignore FIXME(TS)
-      if (gesture.options.enable(gesture, ev)) {
-        this.onStart(ev);
-        this.sendEvent(ev);
-      }
-    }
-  }
-
-  getHammerConfig() {
-    return {
-      // @ts-ignore FIXME(TS)
-      pointers: this.config.numberOfPointers,
-      direction: this.getDirection(),
-    };
-  }
-
-  getTargetDirections(direction: number) {
-    const directions = [];
-    if (direction & Direction.RIGHT) {
-      directions.push(Hammer.DIRECTION_RIGHT);
-    }
-    if (direction & Direction.LEFT) {
-      directions.push(Hammer.DIRECTION_LEFT);
-    }
-    if (direction & Direction.UP) {
-      directions.push(Hammer.DIRECTION_UP);
-    }
-    if (direction & Direction.DOWN) {
-      directions.push(Hammer.DIRECTION_DOWN);
-    }
-    // const hammerDirection = directions.reduce((a, b) => a | b, 0);
-    return directions;
-  }
-
-  getDirection() {
-    // @ts-ignore FIXME(TS)
-    const { direction } = this.getConfig();
-
-    let directions = [];
-    if (direction & Direction.RIGHT) {
-      directions.push(Hammer.DIRECTION_HORIZONTAL);
-    }
-    if (direction & Direction.LEFT) {
-      directions.push(Hammer.DIRECTION_HORIZONTAL);
-    }
-    if (direction & Direction.UP) {
-      directions.push(Hammer.DIRECTION_VERTICAL);
-    }
-    if (direction & Direction.DOWN) {
-      directions.push(Hammer.DIRECTION_VERTICAL);
-    }
-    directions = [...new Set(directions)];
-
-    if (directions.length === 0) return Hammer.DIRECTION_NONE;
-    if (directions.length === 1) return directions[0];
-    return Hammer.DIRECTION_ALL;
-  }
-
-  isGestureEnabledForEvent(
-    { numberOfPointers }: any,
-    _recognizer: any,
-    { maxPointers: pointerLength }: any
-  ) {
-    const validPointerCount = pointerLength === numberOfPointers;
-    if (!validPointerCount && this.isGestureRunning) {
-      return { failed: true };
-    }
-    return { success: validPointerCount };
-  }
-
-  updateGestureConfig({ numberOfPointers = 1, direction, ...props }: any) {
-    if (isnan(direction) || typeof direction !== 'number') {
-      throw new GesturePropError('direction', direction, 'number');
-    }
-    return super.updateGestureConfig({
-      numberOfPointers,
-      direction,
-      ...props,
-    });
-  }
-}
-
-export default FlingGestureHandler;