react-native-gesture-handler 1.10.1 → 2.1.0

package/dist/src/handlers/gestureHandlers.js

@@ -1,247 +0,0 @@
-// Previous types exported gesture handlers as classes which creates an interface and variable, both named the same as class.
-// Without those types, we'd introduce breaking change, forcing users to prefix every handler type specification with typeof
-// e.g. React.createRef<TapGestureHandler> -> React.createRef<typeof TapGestureHandler>.
-// See https://www.typescriptlang.org/docs/handbook/classes.html#constructor-functions for reference.
-import * as React from 'react';
-import createHandler from './createHandler';
-import PlatformConstants from '../PlatformConstants';
-export const baseProps = [
-    'id',
-    'enabled',
-    'minPointers',
-    'waitFor',
-    'simultaneousHandlers',
-    'shouldCancelWhenOutside',
-    'hitSlop',
-    'onBegan',
-    'onFailed',
-    'onCancelled',
-    'onActivated',
-    'onEnded',
-    'onGestureEvent',
-    'onHandlerStateChange',
-];
-// eslint-disable-next-line @typescript-eslint/no-redeclare -- backward compatibility; see description on the top of this file
-export const TapGestureHandler = createHandler({
-    name: 'TapGestureHandler',
-    allowedProps: [
-        ...baseProps,
-        'maxDurationMs',
-        'maxDelayMs',
-        'numberOfTaps',
-        'maxDeltaX',
-        'maxDeltaY',
-        'maxDist',
-        'minPointers',
-    ],
-    config: {},
-});
-// eslint-disable-next-line @typescript-eslint/no-redeclare -- backward compatibility; see description on the top of this file
-export const FlingGestureHandler = createHandler({
-    name: 'FlingGestureHandler',
-    allowedProps: [...baseProps, 'numberOfPointers', 'direction'],
-    config: {},
-});
-class ForceTouchFallback extends React.Component {
-    componentDidMount() {
-        console.warn('ForceTouchGestureHandler is not available on this platform. Please use ForceTouchGestureHandler.forceTouchAvailable to conditionally render other components that would provide a fallback behavior specific to your usecase');
-    }
-    render() {
-        return this.props.children;
-    }
-}
-ForceTouchFallback.forceTouchAvailable = false;
-// eslint-disable-next-line @typescript-eslint/no-redeclare -- backward compatibility; see description on the top of this file
-export const ForceTouchGestureHandler = PlatformConstants?.forceTouchAvailable
-    ? createHandler({
-        name: 'ForceTouchGestureHandler',
-        allowedProps: [
-            ...baseProps,
-            'minForce',
-            'maxForce',
-            'feedbackOnActivation',
-        ],
-        config: {},
-    })
-    : ForceTouchFallback;
-ForceTouchGestureHandler.forceTouchAvailable =
-    PlatformConstants?.forceTouchAvailable || false;
-// eslint-disable-next-line @typescript-eslint/no-redeclare -- backward compatibility; see description on the top of this file
-export const LongPressGestureHandler = createHandler({
-    name: 'LongPressGestureHandler',
-    allowedProps: [...baseProps, 'minDurationMs', 'maxDist'],
-    config: {},
-});
-function validatePanGestureHandlerProps(props) {
-    if (props.minDeltaX && props.activeOffsetX) {
-        throw new Error(`It's not supported use minDeltaX with activeOffsetXStart or activeOffsetXEnd`);
-    }
-    if (props.maxDeltaX && props.failOffsetX) {
-        throw new Error(`It's not supported use minDeltaX with activeOffsetXStart or activeOffsetXEnd`);
-    }
-    if (props.minDeltaY && props.activeOffsetY) {
-        throw new Error(`It's not supported use minDeltaX with activeOffsetYStart or activeOffsetYEnd`);
-    }
-    if (props.maxDeltaY && props.failOffsetY) {
-        throw new Error(`It's not supported use minDeltaX with activeOffsetYStart or activeOffsetYEnd`);
-    }
-    if (Array.isArray(props.activeOffsetX) &&
-        (props.activeOffsetX[0] > 0 || props.activeOffsetX[1] < 0)) {
-        throw new Error(`First element of activeOffsetX should be negative, a the second one should be positive`);
-    }
-    if (Array.isArray(props.activeOffsetY) &&
-        (props.activeOffsetY[0] > 0 || props.activeOffsetY[1] < 0)) {
-        throw new Error(`First element of activeOffsetY should be negative, a the second one should be positive`);
-    }
-    if (Array.isArray(props.failOffsetX) &&
-        (props.failOffsetX[0] > 0 || props.failOffsetX[1] < 0)) {
-        throw new Error(`First element of failOffsetX should be negative, a the second one should be positive`);
-    }
-    if (Array.isArray(props.failOffsetY) &&
-        (props.failOffsetY[0] > 0 || props.failOffsetY[1] < 0)) {
-        throw new Error(`First element of failOffsetY should be negative, a the second one should be positive`);
-    }
-}
-function transformPanGestureHandlerProps(props) {
-    const res = { ...props };
-    if (props.minDeltaX !== undefined) {
-        delete res.minDeltaX;
-        res.activeOffsetXStart = -props.minDeltaX;
-        res.activeOffsetXEnd = props.minDeltaX;
-    }
-    if (props.maxDeltaX !== undefined) {
-        delete res.maxDeltaX;
-        res.failOffsetXStart = -props.maxDeltaX;
-        res.failOffsetXEnd = props.maxDeltaX;
-    }
-    if (props.minOffsetX !== undefined) {
-        delete res.minOffsetX;
-        if (props.minOffsetX < 0) {
-            res.activeOffsetXStart = props.minOffsetX;
-        }
-        else {
-            res.activeOffsetXEnd = props.minOffsetX;
-        }
-    }
-    if (props.minDeltaY !== undefined) {
-        delete res.minDeltaY;
-        res.activeOffsetYStart = -props.minDeltaY;
-        res.activeOffsetYEnd = props.minDeltaY;
-    }
-    if (props.maxDeltaY !== undefined) {
-        delete res.maxDeltaY;
-        res.failOffsetYStart = -props.maxDeltaY;
-        res.failOffsetYEnd = props.maxDeltaY;
-    }
-    if (props.minOffsetY !== undefined) {
-        delete res.minOffsetY;
-        if (props.minOffsetY < 0) {
-            res.activeOffsetYStart = props.minOffsetY;
-        }
-        else {
-            res.activeOffsetYEnd = props.minOffsetY;
-        }
-    }
-    if (props.activeOffsetX !== undefined) {
-        delete res.activeOffsetX;
-        if (Array.isArray(props.activeOffsetX)) {
-            res.activeOffsetXStart = props.activeOffsetX[0];
-            res.activeOffsetXEnd = props.activeOffsetX[1];
-        }
-        else if (props.activeOffsetX < 0) {
-            res.activeOffsetXStart = props.activeOffsetX;
-        }
-        else {
-            res.activeOffsetXEnd = props.activeOffsetX;
-        }
-    }
-    if (props.activeOffsetY !== undefined) {
-        delete res.activeOffsetY;
-        if (Array.isArray(props.activeOffsetY)) {
-            res.activeOffsetYStart = props.activeOffsetY[0];
-            res.activeOffsetYEnd = props.activeOffsetY[1];
-        }
-        else if (props.activeOffsetY < 0) {
-            res.activeOffsetYStart = props.activeOffsetY;
-        }
-        else {
-            res.activeOffsetYEnd = props.activeOffsetY;
-        }
-    }
-    if (props.failOffsetX !== undefined) {
-        delete res.failOffsetX;
-        if (Array.isArray(props.failOffsetX)) {
-            res.failOffsetXStart = props.failOffsetX[0];
-            res.failOffsetXEnd = props.failOffsetX[1];
-        }
-        else if (props.failOffsetX < 0) {
-            res.failOffsetXStart = props.failOffsetX;
-        }
-        else {
-            res.failOffsetXEnd = props.failOffsetX;
-        }
-    }
-    if (props.failOffsetY !== undefined) {
-        delete res.failOffsetY;
-        if (Array.isArray(props.failOffsetY)) {
-            res.failOffsetYStart = props.failOffsetY[0];
-            res.failOffsetYEnd = props.failOffsetY[1];
-        }
-        else if (props.failOffsetY < 0) {
-            res.failOffsetYStart = props.failOffsetY;
-        }
-        else {
-            res.failOffsetYEnd = props.failOffsetY;
-        }
-    }
-    return res;
-}
-function managePanProps(props) {
-    if (__DEV__) {
-        validatePanGestureHandlerProps(props);
-    }
-    return transformPanGestureHandlerProps(props);
-}
-// eslint-disable-next-line @typescript-eslint/no-redeclare -- backward compatibility; see description on the top of this file
-export const PanGestureHandler = createHandler({
-    name: 'PanGestureHandler',
-    allowedProps: [
-        ...baseProps,
-        'activeOffsetY',
-        'activeOffsetX',
-        'failOffsetY',
-        'failOffsetX',
-        'minDist',
-        'minVelocity',
-        'minVelocityX',
-        'minVelocityY',
-        'minPointers',
-        'maxPointers',
-        'avgTouches',
-        'enableTrackpadTwoFingerGesture',
-    ],
-    config: {},
-    transformProps: managePanProps,
-    customNativeProps: [
-        'activeOffsetYStart',
-        'activeOffsetYEnd',
-        'activeOffsetXStart',
-        'activeOffsetXEnd',
-        'failOffsetYStart',
-        'failOffsetYEnd',
-        'failOffsetXStart',
-        'failOffsetXEnd',
-    ],
-});
-// eslint-disable-next-line @typescript-eslint/no-redeclare -- backward compatibility; see description on the top of this file
-export const PinchGestureHandler = createHandler({
-    name: 'PinchGestureHandler',
-    allowedProps: baseProps,
-    config: {},
-});
-// eslint-disable-next-line @typescript-eslint/no-redeclare -- backward compatibility; see description on the top of this file
-export const RotationGestureHandler = createHandler({
-    name: 'RotationGestureHandler',
-    allowedProps: baseProps,
-    config: {},
-});

package/dist/src/typeUtils.js

@@ -1 +0,0 @@
-export {};

package/dist/src/web/DiscreteGestureHandler.js

@@ -1,48 +0,0 @@
-/* eslint-disable eslint-comments/no-unlimited-disable */
-/* eslint-disable */
-import GestureHandler from './GestureHandler';
-import { TEST_MAX_IF_NOT_NAN } from './utils';
-class DiscreteGestureHandler extends GestureHandler {
-    get isDiscrete() {
-        return true;
-    }
-    get shouldEnableGestureOnSetup() {
-        return true;
-    }
-    shouldFailUnderCustomCriteria({ x, y, deltaX, deltaY }, { maxDeltaX, maxDeltaY, maxDistSq, shouldCancelWhenOutside }) {
-        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 } }) {
-        // @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, }, _recognizer, { maxPointers: pointerLength, center, deltaX, deltaY }) {
-        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/dist/src/web/DraggingGestureHandler.js

@@ -1,25 +0,0 @@
-/* eslint-disable eslint-comments/no-unlimited-disable */
-/* eslint-disable */
-import GestureHandler from './GestureHandler';
-import { PixelRatio } from 'react-native';
-class DraggingGestureHandler extends GestureHandler {
-    get shouldEnableGestureOnSetup() {
-        return true;
-    }
-    transformNativeEvent({ deltaX, deltaY, velocityX, velocityY, center: { x, y }, }) {
-        // @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/dist/src/web/Errors.js

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

package/dist/src/web/FlingGestureHandler.js

@@ -1,119 +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';
-class FlingGestureHandler extends DraggingGestureHandler {
-    get name() {
-        return 'swipe';
-    }
-    get NativeGestureClass() {
-        return Hammer.Swipe;
-    }
-    onGestureActivated(event) {
-        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) {
-        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) {
-        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 }, _recognizer, { maxPointers: pointerLength }) {
-        const validPointerCount = pointerLength === numberOfPointers;
-        if (!validPointerCount && this.isGestureRunning) {
-            return { failed: true };
-        }
-        return { success: validPointerCount };
-    }
-    updateGestureConfig({ numberOfPointers = 1, direction, ...props }) {
-        if (isnan(direction) || typeof direction !== 'number') {
-            throw new GesturePropError('direction', direction, 'number');
-        }
-        return super.updateGestureConfig({
-            numberOfPointers,
-            direction,
-            ...props,
-        });
-    }
-}
-export default FlingGestureHandler;