react-native-gesture-handler 2.25.0 → 2.27.0

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

@@ -1,103 +0,0 @@
-/// <reference types="react" />
-import { State } from '../../State';
-import { Config, AdaptedEvent } from '../interfaces';
-import EventManager from '../tools/EventManager';
-import PointerTracker from '../tools/PointerTracker';
-import IGestureHandler from './IGestureHandler';
-import { MouseButton } from '../../handlers/gestureHandlerCommon';
-import { PointerType } from '../../PointerType';
-import { GestureHandlerDelegate } from '../tools/GestureHandlerDelegate';
-export default abstract class GestureHandler implements IGestureHandler {
-    private lastSentState;
-    private _state;
-    private _shouldCancelWhenOutside;
-    protected hasCustomActivationCriteria: boolean;
-    private _enabled;
-    private viewRef;
-    private propsRef;
-    private _handlerTag;
-    private _config;
-    private _tracker;
-    private _activationIndex;
-    private _awaiting;
-    private _active;
-    private _shouldResetProgress;
-    private _pointerType;
-    private _delegate;
-    constructor(delegate: GestureHandlerDelegate<unknown, IGestureHandler>);
-    protected init(viewRef: number, propsRef: React.RefObject<unknown>): void;
-    attachEventManager(manager: EventManager<unknown>): void;
-    protected onCancel(): void;
-    protected onReset(): void;
-    protected resetProgress(): void;
-    reset(): void;
-    moveToState(newState: State, sendIfDisabled?: boolean): void;
-    protected onStateChange(_newState: State, _oldState: State): void;
-    begin(): void;
-    /**
-     * @param {boolean} sendIfDisabled - Used when handler becomes disabled. With this flag orchestrator will be forced to send fail event
-     */
-    fail(sendIfDisabled?: boolean): void;
-    /**
-     * @param {boolean} sendIfDisabled - Used when handler becomes disabled. With this flag orchestrator will be forced to send cancel event
-     */
-    cancel(sendIfDisabled?: boolean): void;
-    activate(force?: boolean): void;
-    end(): void;
-    getShouldResetProgress(): boolean;
-    setShouldResetProgress(value: boolean): void;
-    shouldWaitForHandlerFailure(handler: IGestureHandler): boolean;
-    shouldRequireToWaitForFailure(handler: IGestureHandler): boolean;
-    shouldRecognizeSimultaneously(handler: IGestureHandler): boolean;
-    shouldBeCancelledByOther(handler: IGestureHandler): boolean;
-    protected onPointerDown(event: AdaptedEvent): void;
-    protected onPointerAdd(event: AdaptedEvent): void;
-    protected onPointerUp(event: AdaptedEvent): void;
-    protected onPointerRemove(event: AdaptedEvent): void;
-    protected onPointerMove(event: AdaptedEvent): void;
-    protected onPointerLeave(event: AdaptedEvent): void;
-    protected onPointerEnter(event: AdaptedEvent): void;
-    protected onPointerCancel(event: AdaptedEvent): void;
-    protected onPointerOutOfBounds(event: AdaptedEvent): void;
-    protected onPointerMoveOver(_event: AdaptedEvent): void;
-    protected onPointerMoveOut(_event: AdaptedEvent): void;
-    protected onWheel(_event: AdaptedEvent): void;
-    protected tryToSendMoveEvent(out: boolean, event: AdaptedEvent): void;
-    protected tryToSendTouchEvent(event: AdaptedEvent): void;
-    sendTouchEvent(event: AdaptedEvent): void;
-    sendEvent: (newState: State, oldState: State) => void;
-    private transformEventData;
-    private transformTouchEvent;
-    private cancelTouches;
-    protected transformNativeEvent(): Record<string, unknown>;
-    updateGestureConfig({ enabled, ...props }: Config): void;
-    protected checkCustomActivationCriteria(criterias: string[]): void;
-    private validateHitSlops;
-    private checkHitSlop;
-    isButtonInConfig(mouseButton: MouseButton | undefined): number | true | undefined;
-    protected resetConfig(): void;
-    onDestroy(): void;
-    get handlerTag(): number;
-    set handlerTag(value: number);
-    get config(): Config;
-    get delegate(): GestureHandlerDelegate<unknown, IGestureHandler>;
-    get tracker(): PointerTracker;
-    get state(): State;
-    protected set state(value: State);
-    get shouldCancelWhenOutside(): boolean;
-    protected set shouldCancelWhenOutside(value: boolean);
-    get enabled(): boolean;
-    protected set enabled(value: boolean);
-    get pointerType(): PointerType;
-    protected set pointerType(value: PointerType);
-    get active(): boolean;
-    protected set active(value: boolean);
-    get awaiting(): boolean;
-    protected set awaiting(value: boolean);
-    get activationIndex(): number;
-    protected set activationIndex(value: number);
-    get shouldResetProgress(): boolean;
-    protected set shouldResetProgress(value: boolean);
-    getTrackedPointersID(): number[];
-    private isFinished;
-}

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

@@ -1,10 +0,0 @@
-import { AdaptedEvent } from '../interfaces';
-import GestureHandler from './GestureHandler';
-export default class HoverGestureHandler extends GestureHandler {
-    private stylusData;
-    protected transformNativeEvent(): Record<string, unknown>;
-    protected onPointerMoveOver(event: AdaptedEvent): void;
-    protected onPointerMoveOut(event: AdaptedEvent): void;
-    protected onPointerMove(event: AdaptedEvent): void;
-    protected onPointerCancel(event: AdaptedEvent): void;
-}

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

@@ -1,37 +0,0 @@
-import type { PointerType } from '../../PointerType';
-import type { MouseButton } from '../../handlers/gestureHandlerCommon';
-import type { State } from '../../State';
-import type { Config } from '../interfaces';
-import type EventManager from '../tools/EventManager';
-import type { GestureHandlerDelegate } from '../tools/GestureHandlerDelegate';
-import type PointerTracker from '../tools/PointerTracker';
-export default interface IGestureHandler {
-    active: boolean;
-    activationIndex: number;
-    awaiting: boolean;
-    handlerTag: number;
-    readonly config: Config;
-    readonly delegate: GestureHandlerDelegate<unknown, this>;
-    readonly tracker: PointerTracker;
-    state: State;
-    shouldCancelWhenOutside: boolean;
-    shouldResetProgress: boolean;
-    enabled: boolean;
-    pointerType: PointerType;
-    attachEventManager: (manager: EventManager<unknown>) => void;
-    isButtonInConfig: (mouseButton: MouseButton | undefined) => boolean | number | undefined;
-    getTrackedPointersID: () => number[];
-    begin: () => void;
-    activate: (force: boolean) => void;
-    end: () => void;
-    fail: () => void;
-    cancel: () => void;
-    reset: () => void;
-    shouldWaitForHandlerFailure: (handler: IGestureHandler) => boolean;
-    shouldRequireToWaitForFailure: (handler: IGestureHandler) => boolean;
-    shouldRecognizeSimultaneously: (handler: IGestureHandler) => boolean;
-    shouldBeCancelledByOther: (handler: IGestureHandler) => boolean;
-    sendEvent: (newState: State, oldState: State) => void;
-    updateGestureConfig: (config: Config) => void;
-    isButton?: () => boolean;
-}

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

@@ -1,31 +0,0 @@
-/// <reference types="react" />
-import { State } from '../../State';
-import { AdaptedEvent, Config } from '../interfaces';
-import GestureHandler from './GestureHandler';
-export default class LongPressGestureHandler extends GestureHandler {
-    private minDurationMs;
-    private defaultMaxDistSq;
-    private maxDistSq;
-    private numberOfPointers;
-    private startX;
-    private startY;
-    private startTime;
-    private previousTime;
-    private activationTimeout;
-    init(ref: number, propsRef: React.RefObject<unknown>): void;
-    protected transformNativeEvent(): {
-        duration: number;
-    };
-    updateGestureConfig({ enabled, ...props }: Config): void;
-    protected resetConfig(): void;
-    protected onStateChange(_newState: State, _oldState: State): void;
-    protected onPointerDown(event: AdaptedEvent): void;
-    protected onPointerAdd(event: AdaptedEvent): void;
-    protected onPointerMove(event: AdaptedEvent): void;
-    protected onPointerOutOfBounds(event: AdaptedEvent): void;
-    protected onPointerUp(event: AdaptedEvent): void;
-    protected onPointerRemove(event: AdaptedEvent): void;
-    private tryBegin;
-    private tryActivate;
-    private checkDistanceFail;
-}

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

@@ -1,10 +0,0 @@
-import { AdaptedEvent } from '../interfaces';
-import GestureHandler from './GestureHandler';
-export default class ManualGestureHandler extends GestureHandler {
-    protected onPointerDown(event: AdaptedEvent): void;
-    protected onPointerAdd(event: AdaptedEvent): void;
-    protected onPointerMove(event: AdaptedEvent): void;
-    protected onPointerOutOfBounds(event: AdaptedEvent): void;
-    protected onPointerUp(event: AdaptedEvent): void;
-    protected onPointerRemove(event: AdaptedEvent): void;
-}

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

@@ -1,26 +0,0 @@
-/// <reference types="react" />
-import { AdaptedEvent, Config } from '../interfaces';
-import GestureHandler from './GestureHandler';
-export default class NativeViewGestureHandler extends GestureHandler {
-    private buttonRole;
-    private shouldActivateOnStart;
-    private disallowInterruption;
-    private startX;
-    private startY;
-    private minDistSq;
-    init(ref: number, propsRef: React.RefObject<unknown>): void;
-    updateGestureConfig({ enabled, ...props }: Config): void;
-    private restoreViewStyles;
-    protected onPointerDown(event: AdaptedEvent): void;
-    protected onPointerAdd(event: AdaptedEvent): void;
-    private newPointerAction;
-    protected onPointerMove(event: AdaptedEvent): void;
-    protected onPointerLeave(): void;
-    protected onPointerUp(event: AdaptedEvent): void;
-    protected onPointerRemove(event: AdaptedEvent): void;
-    private onUp;
-    shouldRecognizeSimultaneously(handler: GestureHandler): boolean;
-    shouldBeCancelledByOther(_handler: GestureHandler): boolean;
-    disallowsInterruption(): boolean;
-    isButton(): boolean;
-}

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

@@ -1,61 +0,0 @@
-import { AdaptedEvent, Config, StylusData } from '../interfaces';
-import GestureHandler from './GestureHandler';
-export default class PanGestureHandler extends GestureHandler {
-    private readonly customActivationProperties;
-    velocityX: number;
-    velocityY: number;
-    private minDistSq;
-    private activeOffsetXStart;
-    private activeOffsetXEnd;
-    private failOffsetXStart;
-    private failOffsetXEnd;
-    private activeOffsetYStart;
-    private activeOffsetYEnd;
-    private failOffsetYStart;
-    private failOffsetYEnd;
-    private minVelocityX;
-    private minVelocityY;
-    private minVelocitySq;
-    private minPointers;
-    private maxPointers;
-    private startX;
-    private startY;
-    private offsetX;
-    private offsetY;
-    private lastX;
-    private lastY;
-    private stylusData;
-    private activateAfterLongPress;
-    private activationTimeout;
-    private enableTrackpadTwoFingerGesture;
-    private endWheelTimeout;
-    private wheelDevice;
-    updateGestureConfig({ enabled, ...props }: Config): void;
-    protected resetConfig(): void;
-    protected transformNativeEvent(): {
-        translationX: number;
-        translationY: number;
-        velocityX: number;
-        velocityY: number;
-        stylusData: StylusData | undefined;
-    };
-    private getTranslationX;
-    private getTranslationY;
-    private clearActivationTimeout;
-    protected onPointerDown(event: AdaptedEvent): void;
-    protected onPointerAdd(event: AdaptedEvent): void;
-    protected onPointerUp(event: AdaptedEvent): void;
-    protected onPointerRemove(event: AdaptedEvent): void;
-    protected onPointerMove(event: AdaptedEvent): void;
-    protected onPointerOutOfBounds(event: AdaptedEvent): void;
-    private scheduleWheelEnd;
-    protected onWheel(event: AdaptedEvent): void;
-    private shouldActivate;
-    private shouldFail;
-    private tryBegin;
-    private checkBegan;
-    activate(force?: boolean): void;
-    protected onCancel(): void;
-    protected onReset(): void;
-    protected resetProgress(): void;
-}

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

@@ -1,28 +0,0 @@
-/// <reference types="react" />
-import { AdaptedEvent } from '../interfaces';
-import GestureHandler from './GestureHandler';
-export default class PinchGestureHandler extends GestureHandler {
-    private scale;
-    private velocity;
-    private startingSpan;
-    private spanSlop;
-    private scaleDetectorListener;
-    private scaleGestureDetector;
-    init(ref: number, propsRef: React.RefObject<unknown>): void;
-    protected transformNativeEvent(): {
-        focalX: number;
-        focalY: number;
-        velocity: number;
-        scale: number;
-    };
-    protected onPointerDown(event: AdaptedEvent): void;
-    protected onPointerAdd(event: AdaptedEvent): void;
-    protected onPointerUp(event: AdaptedEvent): void;
-    protected onPointerRemove(event: AdaptedEvent): void;
-    protected onPointerMove(event: AdaptedEvent): void;
-    protected onPointerOutOfBounds(event: AdaptedEvent): void;
-    private tryBegin;
-    activate(force?: boolean): void;
-    protected onReset(): void;
-    protected resetProgress(): void;
-}

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

@@ -1,28 +0,0 @@
-/// <reference types="react" />
-import { AdaptedEvent } from '../interfaces';
-import GestureHandler from './GestureHandler';
-export default class RotationGestureHandler extends GestureHandler {
-    private rotation;
-    private velocity;
-    private cachedAnchorX;
-    private cachedAnchorY;
-    private rotationGestureListener;
-    private rotationGestureDetector;
-    init(ref: number, propsRef: React.RefObject<unknown>): void;
-    protected transformNativeEvent(): {
-        rotation: number;
-        anchorX: number;
-        anchorY: number;
-        velocity: number;
-    };
-    getAnchorX(): number;
-    getAnchorY(): number;
-    protected onPointerDown(event: AdaptedEvent): void;
-    protected onPointerAdd(event: AdaptedEvent): void;
-    protected onPointerMove(event: AdaptedEvent): void;
-    protected onPointerOutOfBounds(event: AdaptedEvent): void;
-    protected onPointerUp(event: AdaptedEvent): void;
-    protected onPointerRemove(event: AdaptedEvent): void;
-    protected tryBegin(): void;
-    protected onReset(): void;
-}

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

@@ -1,38 +0,0 @@
-import { AdaptedEvent, Config } from '../interfaces';
-import GestureHandler from './GestureHandler';
-export default class TapGestureHandler extends GestureHandler {
-    private maxDeltaX;
-    private maxDeltaY;
-    private maxDistSq;
-    private maxDurationMs;
-    private maxDelayMs;
-    private numberOfTaps;
-    private minNumberOfPointers;
-    private currentMaxNumberOfPointers;
-    private startX;
-    private startY;
-    private offsetX;
-    private offsetY;
-    private lastX;
-    private lastY;
-    private waitTimeout;
-    private delayTimeout;
-    private tapsSoFar;
-    updateGestureConfig({ enabled, ...props }: Config): void;
-    protected resetConfig(): void;
-    private clearTimeouts;
-    private startTap;
-    private endTap;
-    protected onPointerDown(event: AdaptedEvent): void;
-    protected onPointerAdd(event: AdaptedEvent): void;
-    protected onPointerUp(event: AdaptedEvent): void;
-    protected onPointerRemove(event: AdaptedEvent): void;
-    protected onPointerMove(event: AdaptedEvent): void;
-    protected onPointerOutOfBounds(event: AdaptedEvent): void;
-    private updateState;
-    private trySettingPosition;
-    private shouldFail;
-    activate(): void;
-    protected onCancel(): void;
-    protected resetProgress(): void;
-}

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

@@ -1,157 +0,0 @@
-import { UserSelect, ActiveCursor, MouseButton, TouchAction } from '../handlers/gestureHandlerCommon';
-import { Directions } from '../Directions';
-import { State } from '../State';
-import { PointerType } from '../PointerType';
-export interface HitSlop {
-    left?: number;
-    right?: number;
-    top?: number;
-    bottom?: number;
-    horizontal?: number;
-    vertical?: number;
-    width?: number;
-    height?: number;
-}
-export interface Handler {
-    handlerTag: number;
-}
-type ConfigArgs = number | boolean | HitSlop | UserSelect | TouchAction | ActiveCursor | Directions | Handler[] | null | undefined;
-export interface Config extends Record<string, ConfigArgs> {
-    enabled: boolean;
-    simultaneousHandlers?: Handler[] | null;
-    waitFor?: Handler[] | null;
-    blocksHandlers?: Handler[] | null;
-    hitSlop?: HitSlop;
-    shouldCancelWhenOutside?: boolean;
-    userSelect?: UserSelect;
-    activeCursor?: ActiveCursor;
-    mouseButton?: MouseButton;
-    enableContextMenu?: boolean;
-    touchAction?: TouchAction;
-    manualActivation?: boolean;
-    activateAfterLongPress?: number;
-    failOffsetXStart?: number;
-    failOffsetYStart?: number;
-    failOffsetXEnd?: number;
-    failOffsetYEnd?: number;
-    activeOffsetXStart?: number;
-    activeOffsetXEnd?: number;
-    activeOffsetYStart?: number;
-    activeOffsetYEnd?: number;
-    minPointers?: number;
-    maxPointers?: number;
-    minDist?: number;
-    minDistSq?: number;
-    minVelocity?: number;
-    minVelocityX?: number;
-    minVelocityY?: number;
-    minVelocitySq?: number;
-    maxDist?: number;
-    maxDistSq?: number;
-    numberOfPointers?: number;
-    minDurationMs?: number;
-    numberOfTaps?: number;
-    maxDurationMs?: number;
-    maxDelayMs?: number;
-    maxDeltaX?: number;
-    maxDeltaY?: number;
-    shouldActivateOnStart?: boolean;
-    disallowInterruption?: boolean;
-    direction?: Directions;
-    enableTrackpadTwoFingerGesture?: boolean;
-}
-type NativeEventArgs = number | State | boolean | undefined;
-interface NativeEvent extends Record<string, NativeEventArgs> {
-    numberOfPointers: number;
-    state: State;
-    pointerInside: boolean | undefined;
-    handlerTag: number;
-    target: number;
-    oldState?: State;
-    pointerType: PointerType;
-}
-export interface Point {
-    x: number;
-    y: number;
-}
-export interface PointerData {
-    id: number;
-    x: number;
-    y: number;
-    absoluteX: number;
-    absoluteY: number;
-}
-type TouchNativeArgs = number | State | TouchEventType | PointerData[];
-interface NativeTouchEvent extends Record<string, TouchNativeArgs> {
-    handlerTag: number;
-    state: State;
-    eventType: TouchEventType;
-    changedTouches: PointerData[];
-    allTouches: PointerData[];
-    numberOfTouches: number;
-    pointerType: PointerType;
-}
-export interface ResultEvent extends Record<string, NativeEvent | number> {
-    nativeEvent: NativeEvent;
-    timeStamp: number;
-}
-export interface ResultTouchEvent extends Record<string, NativeTouchEvent | number> {
-    nativeEvent: NativeTouchEvent;
-    timeStamp: number;
-}
-export interface PropsRef {
-    onGestureHandlerEvent: () => void;
-    onGestureHandlerStateChange: () => void;
-}
-export interface StylusData {
-    tiltX: number;
-    tiltY: number;
-    azimuthAngle: number;
-    altitudeAngle: number;
-    pressure: number;
-}
-export interface AdaptedEvent {
-    x: number;
-    y: number;
-    offsetX: number;
-    offsetY: number;
-    pointerId: number;
-    eventType: EventTypes;
-    pointerType: PointerType;
-    time: number;
-    button?: MouseButton;
-    stylusData?: StylusData;
-    wheelDeltaY?: number;
-}
-export declare enum EventTypes {
-    DOWN = 0,
-    ADDITIONAL_POINTER_DOWN = 1,
-    UP = 2,
-    ADDITIONAL_POINTER_UP = 3,
-    MOVE = 4,
-    ENTER = 5,
-    LEAVE = 6,
-    CANCEL = 7
-}
-export declare enum TouchEventType {
-    UNDETERMINED = 0,
-    DOWN = 1,
-    MOVE = 2,
-    UP = 3,
-    CANCELLED = 4
-}
-export declare enum WheelDevice {
-    UNDETERMINED = 0,
-    MOUSE = 1,
-    TOUCHPAD = 2
-}
-export type GestureHandlerRef = {
-    viewTag: GestureHandlerRef;
-    current: HTMLElement;
-};
-export type SVGRef = {
-    elementRef: {
-        current: SVGElement;
-    };
-};
-export {};

package/lib/typescript/web/tools/CircularBuffer.d.ts

@@ -1,11 +0,0 @@
-export default class CircularBuffer<T> {
-    private capacity;
-    private buffer;
-    private index;
-    private _size;
-    constructor(size: number);
-    push(element: T): void;
-    get(at: number): T;
-    clear(): void;
-    get size(): number;
-}

package/lib/typescript/web/tools/EventManager.d.ts

@@ -1,39 +0,0 @@
-import { AdaptedEvent, EventTypes } from '../interfaces';
-type PointerEventCallback = (event: AdaptedEvent) => void;
-export default abstract class EventManager<T> {
-    protected readonly view: T;
-    protected pointersInBounds: number[];
-    protected activePointersCounter: number;
-    constructor(view: T);
-    abstract registerListeners(): void;
-    abstract unregisterListeners(): void;
-    protected abstract mapEvent(event: Event, eventType: EventTypes): AdaptedEvent;
-    protected onPointerDown(_event: AdaptedEvent): void;
-    protected onPointerAdd(_event: AdaptedEvent): void;
-    protected onPointerUp(_event: AdaptedEvent): void;
-    protected onPointerRemove(_event: AdaptedEvent): void;
-    protected onPointerMove(_event: AdaptedEvent): void;
-    protected onPointerLeave(_event: AdaptedEvent): void;
-    protected onPointerEnter(_event: AdaptedEvent): void;
-    protected onPointerCancel(_event: AdaptedEvent): void;
-    protected onPointerOutOfBounds(_event: AdaptedEvent): void;
-    protected onPointerMoveOver(_event: AdaptedEvent): void;
-    protected onPointerMoveOut(_event: AdaptedEvent): void;
-    protected onWheel(_event: AdaptedEvent): void;
-    setOnPointerDown(callback: PointerEventCallback): void;
-    setOnPointerAdd(callback: PointerEventCallback): void;
-    setOnPointerUp(callback: PointerEventCallback): void;
-    setOnPointerRemove(callback: PointerEventCallback): void;
-    setOnPointerMove(callback: PointerEventCallback): void;
-    setOnPointerLeave(callback: PointerEventCallback): void;
-    setOnPointerEnter(callback: PointerEventCallback): void;
-    setOnPointerCancel(callback: PointerEventCallback): void;
-    setOnPointerOutOfBounds(callback: PointerEventCallback): void;
-    setOnPointerMoveOver(callback: PointerEventCallback): void;
-    setOnPointerMoveOut(callback: PointerEventCallback): void;
-    setOnWheel(callback: PointerEventCallback): void;
-    protected markAsInBounds(pointerId: number): void;
-    protected markAsOutOfBounds(pointerId: number): void;
-    resetManager(): void;
-}
-export {};

package/lib/typescript/web/tools/GestureHandlerDelegate.d.ts

@@ -1,24 +0,0 @@
-import { Config } from '../interfaces';
-export interface MeasureResult {
-    pageX: number;
-    pageY: number;
-    width: number;
-    height: number;
-}
-export interface GestureHandlerDelegate<TComponent, THandler> {
-    view: TComponent;
-    init(viewRef: number, handler: THandler): void;
-    isPointerInBounds({ x, y }: {
-        x: number;
-        y: number;
-    }): boolean;
-    measureView(): MeasureResult;
-    reset(): void;
-    onBegin(): void;
-    onActivate(): void;
-    onEnd(): void;
-    onCancel(): void;
-    onFail(): void;
-    onEnabledChange(enabled: boolean): void;
-    destroy(config: Config): void;
-}

package/lib/typescript/web/tools/GestureHandlerOrchestrator.d.ts

@@ -1,31 +0,0 @@
-import { State } from '../../State';
-import type IGestureHandler from '../handlers/IGestureHandler';
-export default class GestureHandlerOrchestrator {
-    private static _instance;
-    private gestureHandlers;
-    private awaitingHandlers;
-    private awaitingHandlersTags;
-    private handlingChangeSemaphore;
-    private activationIndex;
-    private constructor();
-    private scheduleFinishedHandlersCleanup;
-    private cleanHandler;
-    removeHandlerFromOrchestrator(handler: IGestureHandler): void;
-    private cleanupFinishedHandlers;
-    private hasOtherHandlerToWaitFor;
-    private shouldBeCancelledByFinishedHandler;
-    private tryActivate;
-    private shouldActivate;
-    private cleanupAwaitingHandlers;
-    onHandlerStateChange(handler: IGestureHandler, newState: State, oldState: State, sendIfDisabled?: boolean): void;
-    private makeActive;
-    private addAwaitingHandler;
-    recordHandlerIfNotPresent(handler: IGestureHandler): void;
-    private shouldHandlerWaitForOther;
-    private canRunSimultaneously;
-    private shouldHandlerBeCancelledBy;
-    private checkOverlap;
-    private isFinished;
-    cancelMouseAndPenGestures(currentHandler: IGestureHandler): void;
-    static get instance(): GestureHandlerOrchestrator;
-}