react-native-gesture-handler 2.27.0 → 2.27.1

package/lib/typescript/mountRegistry.js

@@ -0,0 +1,29 @@
+// eslint-disable-next-line @typescript-eslint/no-extraneous-class
+export class MountRegistry {
+    static mountListeners = new Set();
+    static unmountListeners = new Set();
+    static addMountListener(listener) {
+        this.mountListeners.add(listener);
+        return () => {
+            this.mountListeners.delete(listener);
+        };
+    }
+    static addUnmountListener(listener) {
+        this.unmountListeners.add(listener);
+        return () => {
+            this.unmountListeners.delete(listener);
+        };
+    }
+    static gestureHandlerWillMount(handler) {
+        this.mountListeners.forEach((listener) => listener(handler));
+    }
+    static gestureHandlerWillUnmount(handler) {
+        this.unmountListeners.forEach((listener) => listener(handler));
+    }
+    static gestureWillMount(gesture) {
+        this.mountListeners.forEach((listener) => listener(gesture));
+    }
+    static gestureWillUnmount(gesture) {
+        this.unmountListeners.forEach((listener) => listener(gesture));
+    }
+}

package/lib/typescript/specs/NativeRNGestureHandlerModule.d.ts

@@ -0,0 +1,14 @@
+import { TurboModule } from 'react-native';
+import { Double } from 'react-native/Libraries/Types/CodegenTypes';
+export interface Spec extends TurboModule {
+    handleSetJSResponder: (tag: Double, blockNativeResponder: boolean) => void;
+    handleClearJSResponder: () => void;
+    createGestureHandler: (handlerName: string, handlerTag: Double, config: Object) => void;
+    attachGestureHandler: (handlerTag: Double, newView: Double, actionType: Double) => void;
+    updateGestureHandler: (handlerTag: Double, newConfig: Object) => void;
+    dropGestureHandler: (handlerTag: Double) => void;
+    install: () => boolean;
+    flushOperations: () => void;
+}
+declare const _default: Spec;
+export default _default;

package/lib/typescript/specs/NativeRNGestureHandlerModule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NativeRNGestureHandlerModule.d.ts","sourceRoot":"","sources":["../../../src/specs/NativeRNGestureHandlerModule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuB,WAAW,EAAE,MAAM,cAAc,CAAC;AAChE,OAAO,EAAE,MAAM,EAAE,MAAM,2CAA2C,CAAC;AAEnE,MAAM,WAAW,IAAK,SAAQ,WAAW;IACvC,oBAAoB,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,oBAAoB,EAAE,OAAO,KAAK,IAAI,CAAC;IAC3E,sBAAsB,EAAE,MAAM,IAAI,CAAC;IACnC,oBAAoB,EAAE,CACpB,WAAW,EAAE,MAAM,EACnB,UAAU,EAAE,MAAM,EAGlB,MAAM,EAAE,MAAM,KACX,IAAI,CAAC;IACV,oBAAoB,EAAE,CACpB,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM,KACf,IAAI,CAAC;IAEV,oBAAoB,EAAE,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC;IACtE,kBAAkB,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,IAAI,CAAC;IACjD,OAAO,EAAE,MAAM,OAAO,CAAC;IACvB,eAAe,EAAE,MAAM,IAAI,CAAC;CAC7B;;AAED,wBAAgF"}

package/lib/typescript/specs/NativeRNGestureHandlerModule.js

@@ -0,0 +1,2 @@
+import { TurboModuleRegistry } from 'react-native';
+export default TurboModuleRegistry.getEnforcing('RNGestureHandlerModule');

package/lib/typescript/specs/RNGestureHandlerButtonNativeComponent.d.ts

@@ -0,0 +1,16 @@
+import type { Int32, WithDefault, Float } from 'react-native/Libraries/Types/CodegenTypes';
+import type { ViewProps, ColorValue } from 'react-native';
+interface NativeProps extends ViewProps {
+    exclusive?: WithDefault<boolean, true>;
+    foreground?: boolean;
+    borderless?: boolean;
+    enabled?: WithDefault<boolean, true>;
+    rippleColor?: ColorValue;
+    rippleRadius?: Int32;
+    touchSoundDisabled?: WithDefault<boolean, false>;
+    borderWidth?: Float;
+    borderColor?: ColorValue;
+    borderStyle?: WithDefault<string, 'solid'>;
+}
+declare const _default: import("react-native/Libraries/Utilities/codegenNativeComponent").NativeComponentType<NativeProps>;
+export default _default;

package/lib/typescript/specs/RNGestureHandlerButtonNativeComponent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RNGestureHandlerButtonNativeComponent.d.ts","sourceRoot":"","sources":["../../../src/specs/RNGestureHandlerButtonNativeComponent.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,KAAK,EACL,WAAW,EACX,KAAK,EACN,MAAM,2CAA2C,CAAC;AACnD,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE1D,UAAU,WAAY,SAAQ,SAAS;IACrC,SAAS,CAAC,EAAE,WAAW,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;IACvC,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,OAAO,CAAC,EAAE,WAAW,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;IACrC,WAAW,CAAC,EAAE,UAAU,CAAC;IACzB,YAAY,CAAC,EAAE,KAAK,CAAC;IACrB,kBAAkB,CAAC,EAAE,WAAW,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;IACjD,WAAW,CAAC,EAAE,KAAK,CAAC;IACpB,WAAW,CAAC,EAAE,UAAU,CAAC;IACzB,WAAW,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC5C;;AAED,wBAA6E"}

package/lib/typescript/specs/RNGestureHandlerButtonNativeComponent.js

@@ -0,0 +1,2 @@
+import codegenNativeComponent from 'react-native/Libraries/Utilities/codegenNativeComponent';
+export default codegenNativeComponent('RNGestureHandlerButton');

package/lib/typescript/specs/RNGestureHandlerRootViewNativeComponent.d.ts

@@ -0,0 +1,5 @@
+import type { ViewProps } from 'react-native';
+interface NativeProps extends ViewProps {
+}
+declare const _default: import("react-native/Libraries/Utilities/codegenNativeComponent").NativeComponentType<NativeProps>;
+export default _default;

package/lib/typescript/specs/RNGestureHandlerRootViewNativeComponent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RNGestureHandlerRootViewNativeComponent.d.ts","sourceRoot":"","sources":["../../../src/specs/RNGestureHandlerRootViewNativeComponent.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAE9C,UAAU,WAAY,SAAQ,SAAS;CAAG;;AAE1C,wBAA+E"}

package/lib/typescript/specs/RNGestureHandlerRootViewNativeComponent.js

@@ -0,0 +1,2 @@
+import codegenNativeComponent from 'react-native/Libraries/Utilities/codegenNativeComponent';
+export default codegenNativeComponent('RNGestureHandlerRootView');

package/lib/typescript/typeUtils.d.ts

@@ -0,0 +1 @@
+export type ValueOf<T> = T[keyof T];

package/lib/typescript/typeUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typeUtils.d.ts","sourceRoot":"","sources":["../../src/typeUtils.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC"}

package/lib/typescript/typeUtils.js

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

package/lib/typescript/utils.d.ts

@@ -0,0 +1,20 @@
+export declare function toArray<T>(object: T | T[]): T[];
+export type withPrevAndCurrentMapFn<T, Transformed> = (previous: Transformed | null, current: T) => Transformed;
+export declare function withPrevAndCurrent<T, Transformed>(array: T[], mapFn: withPrevAndCurrentMapFn<T, Transformed>): Transformed[];
+export declare function hasProperty(object: object, key: string): boolean;
+export declare function isTestEnv(): boolean;
+export declare function tagMessage(msg: string): string;
+export declare function isFabric(): boolean;
+export declare function isReact19(): boolean;
+export declare function isRemoteDebuggingEnabled(): boolean;
+/**
+ * Recursively compares two objects for deep equality.
+ *
+ * **Note:** This function does not support cyclic references.
+ *
+ * @param obj1 - The first object to compare.
+ * @param obj2 - The second object to compare.
+ * @returns `true` if the objects are deeply equal, `false` otherwise.
+ */
+export declare function deepEqual(obj1: any, obj2: any): boolean;
+export declare const INT32_MAX: number;

package/lib/typescript/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/utils.ts"],"names":[],"mappings":"AAEA,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,GAAG,CAAC,EAAE,GAAG,CAAC,EAAE,CAM/C;AAED,MAAM,MAAM,uBAAuB,CAAC,CAAC,EAAE,WAAW,IAAI,CACpD,QAAQ,EAAE,WAAW,GAAG,IAAI,EAC5B,OAAO,EAAE,CAAC,KACP,WAAW,CAAC;AACjB,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,WAAW,EAC/C,KAAK,EAAE,CAAC,EAAE,EACV,KAAK,EAAE,uBAAuB,CAAC,CAAC,EAAE,WAAW,CAAC,GAC7C,WAAW,EAAE,CAcf;AAED,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,WAEtD;AAED,wBAAgB,SAAS,IAAI,OAAO,CAGnC;AAED,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,UAErC;AAID,wBAAgB,QAAQ,IAAI,OAAO,CAGlC;AAED,wBAAgB,SAAS,YAExB;AAED,wBAAgB,wBAAwB,IAAI,OAAO,CAQlD;AAED;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,WA4B7C;AAED,eAAO,MAAM,SAAS,QAAc,CAAC"}

package/lib/typescript/utils.js

@@ -0,0 +1,80 @@
+import React from 'react';
+export function toArray(object) {
+    if (!Array.isArray(object)) {
+        return [object];
+    }
+    return object;
+}
+export function withPrevAndCurrent(array, mapFn) {
+    const previousArr = [null];
+    const currentArr = [...array];
+    const transformedArr = [];
+    currentArr.forEach((current, i) => {
+        // This type cast is fine and solves problem mentioned in https://github.com/software-mansion/react-native-gesture-handler/pull/2867 (namely that `previous` can be undefined).
+        // Unfortunately, linter on our CI does not allow this type of casting as it is unnecessary. To bypass that we use eslint-disable.
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
+        const previous = previousArr[i];
+        const transformed = mapFn(previous, current);
+        previousArr.push(transformed);
+        transformedArr.push(transformed);
+    });
+    return transformedArr;
+}
+export function hasProperty(object, key) {
+    return Object.prototype.hasOwnProperty.call(object, key);
+}
+export function isTestEnv() {
+    // @ts-ignore Do not use `@types/node` because it will prioritise Node types over RN types which breaks the types (ex. setTimeout) in React Native projects.
+    return hasProperty(global, 'process') && process.env.NODE_ENV === 'test';
+}
+export function tagMessage(msg) {
+    return `[react-native-gesture-handler] ${msg}`;
+}
+// Helper method to check whether Fabric is enabled, however global.nativeFabricUIManager
+// may not be initialized before the first render
+export function isFabric() {
+    // @ts-expect-error nativeFabricUIManager is not yet included in the RN types
+    return !!global?.nativeFabricUIManager;
+}
+export function isReact19() {
+    return React.version.startsWith('19.');
+}
+export function isRemoteDebuggingEnabled() {
+    // react-native-reanimated checks if in remote debugging in the same way
+    // @ts-ignore global is available but node types are not included
+    const localGlobal = global;
+    return ((!localGlobal.nativeCallSyncHook || !!localGlobal.__REMOTEDEV__) &&
+        !localGlobal.RN$Bridgeless);
+}
+/**
+ * Recursively compares two objects for deep equality.
+ *
+ * **Note:** This function does not support cyclic references.
+ *
+ * @param obj1 - The first object to compare.
+ * @param obj2 - The second object to compare.
+ * @returns `true` if the objects are deeply equal, `false` otherwise.
+ */
+export function deepEqual(obj1, obj2) {
+    if (obj1 === obj2) {
+        return true;
+    }
+    if (typeof obj1 !== 'object' ||
+        typeof obj2 !== 'object' ||
+        obj1 === null ||
+        obj2 === null) {
+        return false;
+    }
+    const keys1 = Object.keys(obj1);
+    const keys2 = Object.keys(obj2);
+    if (keys1.length !== keys2.length) {
+        return false;
+    }
+    for (const key of keys1) {
+        if (!keys2.includes(key) || !deepEqual(obj1[key], obj2[key])) {
+            return false;
+        }
+    }
+    return true;
+}
+export const INT32_MAX = 2 ** 31 - 1;

package/lib/typescript/web/Gestures.d.ts

@@ -0,0 +1,36 @@
+import PanGestureHandler from './handlers/PanGestureHandler';
+import TapGestureHandler from './handlers/TapGestureHandler';
+import LongPressGestureHandler from './handlers/LongPressGestureHandler';
+import PinchGestureHandler from './handlers/PinchGestureHandler';
+import RotationGestureHandler from './handlers/RotationGestureHandler';
+import FlingGestureHandler from './handlers/FlingGestureHandler';
+import NativeViewGestureHandler from './handlers/NativeViewGestureHandler';
+import ManualGestureHandler from './handlers/ManualGestureHandler';
+import HoverGestureHandler from './handlers/HoverGestureHandler';
+import HammerNativeViewGestureHandler from '../web_hammer/NativeViewGestureHandler';
+import HammerPanGestureHandler from '../web_hammer/PanGestureHandler';
+import HammerTapGestureHandler from '../web_hammer/TapGestureHandler';
+import HammerLongPressGestureHandler from '../web_hammer/LongPressGestureHandler';
+import HammerPinchGestureHandler from '../web_hammer/PinchGestureHandler';
+import HammerRotationGestureHandler from '../web_hammer/RotationGestureHandler';
+import HammerFlingGestureHandler from '../web_hammer/FlingGestureHandler';
+export declare const Gestures: {
+    NativeViewGestureHandler: typeof NativeViewGestureHandler;
+    PanGestureHandler: typeof PanGestureHandler;
+    TapGestureHandler: typeof TapGestureHandler;
+    LongPressGestureHandler: typeof LongPressGestureHandler;
+    PinchGestureHandler: typeof PinchGestureHandler;
+    RotationGestureHandler: typeof RotationGestureHandler;
+    FlingGestureHandler: typeof FlingGestureHandler;
+    ManualGestureHandler: typeof ManualGestureHandler;
+    HoverGestureHandler: typeof HoverGestureHandler;
+};
+export declare const HammerGestures: {
+    NativeViewGestureHandler: typeof HammerNativeViewGestureHandler;
+    PanGestureHandler: typeof HammerPanGestureHandler;
+    TapGestureHandler: typeof HammerTapGestureHandler;
+    LongPressGestureHandler: typeof HammerLongPressGestureHandler;
+    PinchGestureHandler: typeof HammerPinchGestureHandler;
+    RotationGestureHandler: typeof HammerRotationGestureHandler;
+    FlingGestureHandler: typeof HammerFlingGestureHandler;
+};

package/lib/typescript/web/Gestures.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Gestures.d.ts","sourceRoot":"","sources":["../../../src/web/Gestures.ts"],"names":[],"mappings":"AACA,OAAO,iBAAiB,MAAM,8BAA8B,CAAC;AAC7D,OAAO,iBAAiB,MAAM,8BAA8B,CAAC;AAC7D,OAAO,uBAAuB,MAAM,oCAAoC,CAAC;AACzE,OAAO,mBAAmB,MAAM,gCAAgC,CAAC;AACjE,OAAO,sBAAsB,MAAM,mCAAmC,CAAC;AACvE,OAAO,mBAAmB,MAAM,gCAAgC,CAAC;AACjE,OAAO,wBAAwB,MAAM,qCAAqC,CAAC;AAC3E,OAAO,oBAAoB,MAAM,iCAAiC,CAAC;AACnE,OAAO,mBAAmB,MAAM,gCAAgC,CAAC;AAGjE,OAAO,8BAA8B,MAAM,wCAAwC,CAAC;AACpF,OAAO,uBAAuB,MAAM,iCAAiC,CAAC;AACtE,OAAO,uBAAuB,MAAM,iCAAiC,CAAC;AACtE,OAAO,6BAA6B,MAAM,uCAAuC,CAAC;AAClF,OAAO,yBAAyB,MAAM,mCAAmC,CAAC;AAC1E,OAAO,4BAA4B,MAAM,sCAAsC,CAAC;AAChF,OAAO,yBAAyB,MAAM,mCAAmC,CAAC;AAE1E,eAAO,MAAM,QAAQ;;;;;;;;;;CAUpB,CAAC;AAEF,eAAO,MAAM,cAAc;;;;;;;;CAQ1B,CAAC"}

package/lib/typescript/web/Gestures.js

@@ -0,0 +1,38 @@
+// Gesture Handlers
+import PanGestureHandler from './handlers/PanGestureHandler';
+import TapGestureHandler from './handlers/TapGestureHandler';
+import LongPressGestureHandler from './handlers/LongPressGestureHandler';
+import PinchGestureHandler from './handlers/PinchGestureHandler';
+import RotationGestureHandler from './handlers/RotationGestureHandler';
+import FlingGestureHandler from './handlers/FlingGestureHandler';
+import NativeViewGestureHandler from './handlers/NativeViewGestureHandler';
+import ManualGestureHandler from './handlers/ManualGestureHandler';
+import HoverGestureHandler from './handlers/HoverGestureHandler';
+// Hammer Handlers
+import HammerNativeViewGestureHandler from '../web_hammer/NativeViewGestureHandler';
+import HammerPanGestureHandler from '../web_hammer/PanGestureHandler';
+import HammerTapGestureHandler from '../web_hammer/TapGestureHandler';
+import HammerLongPressGestureHandler from '../web_hammer/LongPressGestureHandler';
+import HammerPinchGestureHandler from '../web_hammer/PinchGestureHandler';
+import HammerRotationGestureHandler from '../web_hammer/RotationGestureHandler';
+import HammerFlingGestureHandler from '../web_hammer/FlingGestureHandler';
+export const Gestures = {
+    NativeViewGestureHandler,
+    PanGestureHandler,
+    TapGestureHandler,
+    LongPressGestureHandler,
+    PinchGestureHandler,
+    RotationGestureHandler,
+    FlingGestureHandler,
+    ManualGestureHandler,
+    HoverGestureHandler,
+};
+export const HammerGestures = {
+    NativeViewGestureHandler: HammerNativeViewGestureHandler,
+    PanGestureHandler: HammerPanGestureHandler,
+    TapGestureHandler: HammerTapGestureHandler,
+    LongPressGestureHandler: HammerLongPressGestureHandler,
+    PinchGestureHandler: HammerPinchGestureHandler,
+    RotationGestureHandler: HammerRotationGestureHandler,
+    FlingGestureHandler: HammerFlingGestureHandler,
+};

package/lib/typescript/web/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const DEFAULT_TOUCH_SLOP = 15;
+export declare const MINIMAL_RECOGNIZABLE_MAGNITUDE = 0.1;

package/lib/typescript/web/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/web/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,kBAAkB,KAAK,CAAC;AACrC,eAAO,MAAM,8BAA8B,MAAM,CAAC"}

package/lib/typescript/web/constants.js

@@ -0,0 +1,2 @@
+export const DEFAULT_TOUCH_SLOP = 15;
+export const MINIMAL_RECOGNIZABLE_MAGNITUDE = 0.1;

package/lib/typescript/web/detectors/RotationGestureDetector.d.ts

@@ -0,0 +1,30 @@
+import { AdaptedEvent } from '../interfaces';
+import PointerTracker from '../tools/PointerTracker';
+export interface RotationGestureListener {
+    onRotationBegin: (detector: RotationGestureDetector) => boolean;
+    onRotation: (detector: RotationGestureDetector) => boolean;
+    onRotationEnd: (detector: RotationGestureDetector) => void;
+}
+export default class RotationGestureDetector implements RotationGestureListener {
+    onRotationBegin: (detector: RotationGestureDetector) => boolean;
+    onRotation: (detector: RotationGestureDetector) => boolean;
+    onRotationEnd: (detector: RotationGestureDetector) => void;
+    private currentTime;
+    private previousTime;
+    private previousAngle;
+    private _rotation;
+    private _anchorX;
+    private _anchorY;
+    private isInProgress;
+    private keyPointers;
+    constructor(callbacks: RotationGestureListener);
+    private updateCurrent;
+    private finish;
+    private setKeyPointers;
+    onTouchEvent(event: AdaptedEvent, tracker: PointerTracker): boolean;
+    reset(): void;
+    get anchorX(): number;
+    get anchorY(): number;
+    get rotation(): number;
+    get timeDelta(): number;
+}

package/lib/typescript/web/detectors/RotationGestureDetector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RotationGestureDetector.d.ts","sourceRoot":"","sources":["../../../../src/web/detectors/RotationGestureDetector.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAc,MAAM,eAAe,CAAC;AACzD,OAAO,cAAc,MAAM,yBAAyB,CAAC;AAErD,MAAM,WAAW,uBAAuB;IACtC,eAAe,EAAE,CAAC,QAAQ,EAAE,uBAAuB,KAAK,OAAO,CAAC;IAChE,UAAU,EAAE,CAAC,QAAQ,EAAE,uBAAuB,KAAK,OAAO,CAAC;IAC3D,aAAa,EAAE,CAAC,QAAQ,EAAE,uBAAuB,KAAK,IAAI,CAAC;CAC5D;AAED,MAAM,CAAC,OAAO,OAAO,uBACnB,YAAW,uBAAuB;IAElC,eAAe,EAAE,CAAC,QAAQ,EAAE,uBAAuB,KAAK,OAAO,CAAC;IAChE,UAAU,EAAE,CAAC,QAAQ,EAAE,uBAAuB,KAAK,OAAO,CAAC;IAC3D,aAAa,EAAE,CAAC,QAAQ,EAAE,uBAAuB,KAAK,IAAI,CAAC;IAE3D,OAAO,CAAC,WAAW,CAAK;IACxB,OAAO,CAAC,YAAY,CAAK;IAEzB,OAAO,CAAC,aAAa,CAAK;IAC1B,OAAO,CAAC,SAAS,CAAK;IAEtB,OAAO,CAAC,QAAQ,CAAK;IACrB,OAAO,CAAC,QAAQ,CAAK;IAErB,OAAO,CAAC,YAAY,CAAS;IAE7B,OAAO,CAAC,WAAW,CAAwB;gBAE/B,SAAS,EAAE,uBAAuB;IAM9C,OAAO,CAAC,aAAa;IAyCrB,OAAO,CAAC,MAAM;IAUd,OAAO,CAAC,cAAc;IAWf,YAAY,CAAC,KAAK,EAAE,YAAY,EAAE,OAAO,EAAE,cAAc,GAAG,OAAO;IAoDnE,KAAK,IAAI,IAAI;IAKpB,IAAW,OAAO,WAEjB;IAED,IAAW,OAAO,WAEjB;IAED,IAAW,QAAQ,WAElB;IAED,IAAW,SAAS,WAEnB;CACF"}

package/lib/typescript/web/detectors/RotationGestureDetector.js

@@ -0,0 +1,122 @@
+import { EventTypes } from '../interfaces';
+export default class RotationGestureDetector {
+    onRotationBegin;
+    onRotation;
+    onRotationEnd;
+    currentTime = 0;
+    previousTime = 0;
+    previousAngle = 0;
+    _rotation = 0;
+    _anchorX = 0;
+    _anchorY = 0;
+    isInProgress = false;
+    keyPointers = [NaN, NaN];
+    constructor(callbacks) {
+        this.onRotationBegin = callbacks.onRotationBegin;
+        this.onRotation = callbacks.onRotation;
+        this.onRotationEnd = callbacks.onRotationEnd;
+    }
+    updateCurrent(event, tracker) {
+        this.previousTime = this.currentTime;
+        this.currentTime = event.time;
+        const [firstPointerID, secondPointerID] = this.keyPointers;
+        const firstPointerCoords = tracker.getLastAbsoluteCoords(firstPointerID);
+        const secondPointerCoords = tracker.getLastAbsoluteCoords(secondPointerID);
+        if (!firstPointerCoords || !secondPointerCoords) {
+            return;
+        }
+        const vectorX = secondPointerCoords.x - firstPointerCoords.x;
+        const vectorY = secondPointerCoords.y - firstPointerCoords.y;
+        this._anchorX = (firstPointerCoords.x + secondPointerCoords.x) / 2;
+        this._anchorY = (firstPointerCoords.y + secondPointerCoords.y) / 2;
+        // Angle diff should be positive when rotating in clockwise direction
+        const angle = -Math.atan2(vectorY, vectorX);
+        this._rotation = Number.isNaN(this.previousAngle)
+            ? 0
+            : this.previousAngle - angle;
+        this.previousAngle = angle;
+        if (this.rotation > Math.PI) {
+            this._rotation -= Math.PI;
+        }
+        else if (this.rotation < -Math.PI) {
+            this._rotation += Math.PI;
+        }
+        if (this.rotation > Math.PI / 2) {
+            this._rotation -= Math.PI;
+        }
+        else if (this.rotation < -Math.PI / 2) {
+            this._rotation += Math.PI;
+        }
+    }
+    finish() {
+        if (!this.isInProgress) {
+            return;
+        }
+        this.isInProgress = false;
+        this.keyPointers = [NaN, NaN];
+        this.onRotationEnd(this);
+    }
+    setKeyPointers(tracker) {
+        if (this.keyPointers[0] && this.keyPointers[1]) {
+            return;
+        }
+        const pointerIDs = tracker.trackedPointers.keys();
+        this.keyPointers[0] = pointerIDs.next().value;
+        this.keyPointers[1] = pointerIDs.next().value;
+    }
+    onTouchEvent(event, tracker) {
+        switch (event.eventType) {
+            case EventTypes.DOWN:
+                this.isInProgress = false;
+                break;
+            case EventTypes.ADDITIONAL_POINTER_DOWN:
+                if (this.isInProgress) {
+                    break;
+                }
+                this.isInProgress = true;
+                this.previousTime = event.time;
+                this.previousAngle = NaN;
+                this.setKeyPointers(tracker);
+                this.updateCurrent(event, tracker);
+                this.onRotationBegin(this);
+                break;
+            case EventTypes.MOVE:
+                if (!this.isInProgress) {
+                    break;
+                }
+                this.updateCurrent(event, tracker);
+                this.onRotation(this);
+                break;
+            case EventTypes.ADDITIONAL_POINTER_UP:
+                if (!this.isInProgress) {
+                    break;
+                }
+                if (this.keyPointers.indexOf(event.pointerId) >= 0) {
+                    this.finish();
+                }
+                break;
+            case EventTypes.UP:
+                if (this.isInProgress) {
+                    this.finish();
+                }
+                break;
+        }
+        return true;
+    }
+    reset() {
+        this.keyPointers = [NaN, NaN];
+        this.isInProgress = false;
+    }
+    get anchorX() {
+        return this._anchorX;
+    }
+    get anchorY() {
+        return this._anchorY;
+    }
+    get rotation() {
+        return this._rotation;
+    }
+    get timeDelta() {
+        return this.currentTime + this.previousTime;
+    }
+}

package/lib/typescript/web/detectors/ScaleGestureDetector.d.ts

@@ -0,0 +1,29 @@
+import { AdaptedEvent } from '../interfaces';
+import PointerTracker from '../tools/PointerTracker';
+export interface ScaleGestureListener {
+    onScaleBegin: (detector: ScaleGestureDetector) => boolean;
+    onScale: (detector: ScaleGestureDetector) => boolean;
+    onScaleEnd: (detector: ScaleGestureDetector) => void;
+}
+export default class ScaleGestureDetector implements ScaleGestureListener {
+    onScaleBegin: (detector: ScaleGestureDetector) => boolean;
+    onScale: (detector: ScaleGestureDetector) => boolean;
+    onScaleEnd: (detector: ScaleGestureDetector) => void;
+    private _focusX;
+    private _focusY;
+    private _currentSpan;
+    private prevSpan;
+    private initialSpan;
+    private currentTime;
+    private prevTime;
+    private inProgress;
+    private spanSlop;
+    private minSpan;
+    constructor(callbacks: ScaleGestureListener);
+    onTouchEvent(event: AdaptedEvent, tracker: PointerTracker): boolean;
+    calculateScaleFactor(numOfPointers: number): number;
+    get currentSpan(): number;
+    get focusX(): number;
+    get focusY(): number;
+    get timeDelta(): number;
+}

package/lib/typescript/web/detectors/ScaleGestureDetector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ScaleGestureDetector.d.ts","sourceRoot":"","sources":["../../../../src/web/detectors/ScaleGestureDetector.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAc,MAAM,eAAe,CAAC;AAEzD,OAAO,cAAc,MAAM,yBAAyB,CAAC;AAErD,MAAM,WAAW,oBAAoB;IACnC,YAAY,EAAE,CAAC,QAAQ,EAAE,oBAAoB,KAAK,OAAO,CAAC;IAC1D,OAAO,EAAE,CAAC,QAAQ,EAAE,oBAAoB,KAAK,OAAO,CAAC;IACrD,UAAU,EAAE,CAAC,QAAQ,EAAE,oBAAoB,KAAK,IAAI,CAAC;CACtD;AAED,MAAM,CAAC,OAAO,OAAO,oBAAqB,YAAW,oBAAoB;IAChE,YAAY,EAAE,CAAC,QAAQ,EAAE,oBAAoB,KAAK,OAAO,CAAC;IAC1D,OAAO,EAAE,CAAC,QAAQ,EAAE,oBAAoB,KAAK,OAAO,CAAC;IACrD,UAAU,EAAE,CAAC,QAAQ,EAAE,oBAAoB,KAAK,IAAI,CAAC;IAE5D,OAAO,CAAC,OAAO,CAAU;IACzB,OAAO,CAAC,OAAO,CAAU;IAEzB,OAAO,CAAC,YAAY,CAAU;IAC9B,OAAO,CAAC,QAAQ,CAAU;IAC1B,OAAO,CAAC,WAAW,CAAU;IAE7B,OAAO,CAAC,WAAW,CAAU;IAC7B,OAAO,CAAC,QAAQ,CAAU;IAE1B,OAAO,CAAC,UAAU,CAAS;IAE3B,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,OAAO,CAAS;gBAEZ,SAAS,EAAE,oBAAoB;IASpC,YAAY,CAAC,KAAK,EAAE,YAAY,EAAE,OAAO,EAAE,cAAc,GAAG,OAAO;IA2GnE,oBAAoB,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM;IAQ1D,IAAW,WAAW,WAErB;IAED,IAAW,MAAM,WAEhB;IAED,IAAW,MAAM,WAEhB;IAED,IAAW,SAAS,WAEnB;CACF"}

package/lib/typescript/web/detectors/ScaleGestureDetector.js

@@ -0,0 +1,117 @@
+import { DEFAULT_TOUCH_SLOP } from '../constants';
+import { EventTypes } from '../interfaces';
+export default class ScaleGestureDetector {
+    onScaleBegin;
+    onScale;
+    onScaleEnd;
+    _focusX;
+    _focusY;
+    _currentSpan;
+    prevSpan;
+    initialSpan;
+    currentTime;
+    prevTime;
+    inProgress = false;
+    spanSlop;
+    minSpan;
+    constructor(callbacks) {
+        this.onScaleBegin = callbacks.onScaleBegin;
+        this.onScale = callbacks.onScale;
+        this.onScaleEnd = callbacks.onScaleEnd;
+        this.spanSlop = DEFAULT_TOUCH_SLOP * 2;
+        this.minSpan = 0;
+    }
+    onTouchEvent(event, tracker) {
+        this.currentTime = event.time;
+        const action = event.eventType;
+        const numOfPointers = tracker.trackedPointersCount;
+        const streamComplete = action === EventTypes.UP ||
+            action === EventTypes.ADDITIONAL_POINTER_UP ||
+            action === EventTypes.CANCEL;
+        if (action === EventTypes.DOWN || streamComplete) {
+            if (this.inProgress) {
+                this.onScaleEnd(this);
+                this.inProgress = false;
+                this.initialSpan = 0;
+            }
+            if (streamComplete) {
+                return true;
+            }
+        }
+        const configChanged = action === EventTypes.DOWN ||
+            action === EventTypes.ADDITIONAL_POINTER_UP ||
+            action === EventTypes.ADDITIONAL_POINTER_DOWN;
+        const pointerUp = action === EventTypes.ADDITIONAL_POINTER_UP;
+        const ignoredPointer = pointerUp
+            ? event.pointerId
+            : undefined;
+        // Determine focal point
+        const div = pointerUp ? numOfPointers - 1 : numOfPointers;
+        const coordsSum = tracker.getAbsoluteCoordsSum();
+        const focusX = coordsSum.x / div;
+        const focusY = coordsSum.y / div;
+        // Determine average deviation from focal point
+        let devSumX = 0;
+        let devSumY = 0;
+        tracker.trackedPointers.forEach((value, key) => {
+            if (key === ignoredPointer) {
+                return;
+            }
+            devSumX += Math.abs(value.abosoluteCoords.x - focusX);
+            devSumY += Math.abs(value.abosoluteCoords.y - focusY);
+        });
+        const devX = devSumX / div;
+        const devY = devSumY / div;
+        const spanX = devX * 2;
+        const spanY = devY * 2;
+        const span = Math.hypot(spanX, spanY);
+        // Begin/end events
+        const wasInProgress = this.inProgress;
+        this._focusX = focusX;
+        this._focusY = focusY;
+        if (this.inProgress && (span < this.minSpan || configChanged)) {
+            this.onScaleEnd(this);
+            this.inProgress = false;
+            this.initialSpan = span;
+        }
+        if (configChanged) {
+            this.initialSpan = this.prevSpan = this._currentSpan = span;
+        }
+        if (!this.inProgress &&
+            span >= this.minSpan &&
+            (wasInProgress || Math.abs(span - this.initialSpan) > this.spanSlop)) {
+            this.prevSpan = this._currentSpan = span;
+            this.prevTime = this.currentTime;
+            this.inProgress = this.onScaleBegin(this);
+        }
+        // Handle motion
+        if (action !== EventTypes.MOVE) {
+            return true;
+        }
+        this._currentSpan = span;
+        if (this.inProgress && !this.onScale(this)) {
+            return true;
+        }
+        this.prevSpan = this.currentSpan;
+        this.prevTime = this.currentTime;
+        return true;
+    }
+    calculateScaleFactor(numOfPointers) {
+        if (numOfPointers < 2) {
+            return 1;
+        }
+        return this.prevSpan > 0 ? this.currentSpan / this.prevSpan : 1;
+    }
+    get currentSpan() {
+        return this._currentSpan;
+    }
+    get focusX() {
+        return this._focusX;
+    }
+    get focusY() {
+        return this._focusY;
+    }
+    get timeDelta() {
+        return this.currentTime - this.prevTime;
+    }
+}

package/lib/typescript/web/handlers/FlingGestureHandler.d.ts

@@ -0,0 +1,26 @@
+import { AdaptedEvent, Config } from '../interfaces';
+import GestureHandler from './GestureHandler';
+export default class FlingGestureHandler extends GestureHandler {
+    private numberOfPointersRequired;
+    private direction;
+    private maxDurationMs;
+    private minVelocity;
+    private delayTimeout;
+    private maxNumberOfPointersSimultaneously;
+    private keyPointer;
+    updateGestureConfig({ enabled, ...props }: Config): void;
+    private startFling;
+    private tryEndFling;
+    private endFling;
+    protected onPointerDown(event: AdaptedEvent): void;
+    protected onPointerAdd(event: AdaptedEvent): void;
+    private newPointerAction;
+    private pointerMoveAction;
+    protected onPointerMove(event: AdaptedEvent): void;
+    protected onPointerOutOfBounds(event: AdaptedEvent): void;
+    protected onPointerUp(event: AdaptedEvent): void;
+    protected onPointerRemove(event: AdaptedEvent): void;
+    private onUp;
+    activate(force?: boolean): void;
+    protected resetConfig(): void;
+}

package/lib/typescript/web/handlers/FlingGestureHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FlingGestureHandler.d.ts","sourceRoot":"","sources":["../../../../src/web/handlers/FlingGestureHandler.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAErD,OAAO,cAAc,MAAM,kBAAkB,CAAC;AAa9C,MAAM,CAAC,OAAO,OAAO,mBAAoB,SAAQ,cAAc;IAC7D,OAAO,CAAC,wBAAwB,CAAsC;IACtE,OAAO,CAAC,SAAS,CAAiC;IAElD,OAAO,CAAC,aAAa,CAA2B;IAChD,OAAO,CAAC,WAAW,CAAwB;IAC3C,OAAO,CAAC,YAAY,CAAU;IAE9B,OAAO,CAAC,iCAAiC,CAAK;IAC9C,OAAO,CAAC,UAAU,CAAO;IAElB,mBAAmB,CAAC,EAAE,OAAc,EAAE,GAAG,KAAK,EAAE,EAAE,MAAM,GAAG,IAAI;IAYtE,OAAO,CAAC,UAAU;IAQlB,OAAO,CAAC,WAAW;IAoDnB,OAAO,CAAC,QAAQ;IAMhB,SAAS,CAAC,aAAa,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI;IAclD,SAAS,CAAC,YAAY,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI;IAMjD,OAAO,CAAC,gBAAgB;IAmBxB,OAAO,CAAC,iBAAiB;IAUzB,SAAS,CAAC,aAAa,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI;IAKlD,SAAS,CAAC,oBAAoB,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI;IAKzD,SAAS,CAAC,WAAW,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI;IAOhD,SAAS,CAAC,eAAe,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI;IAKpD,OAAO,CAAC,IAAI;IAQL,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,GAAG,IAAI;IAKtC,SAAS,CAAC,WAAW,IAAI,IAAI;CAK9B"}