react-native-gesture-handler/lib/typescript/web/handlers/GestureHandler.d.ts

Declarative API exposing native platform touch and gesture system to React Native

import { ActionType } from '../../ActionType';
import type { ActiveCursor, TouchAction, UserSelect } from '../../handlers/gestureHandlerCommon';
import { MouseButton } from '../../handlers/gestureHandlerCommon';
import { PointerType } from '../../PointerType';
import { State } from '../../State';
import type { HandlerData, SingleGestureName } from '../../v3/types';
import type { AdaptedEvent, Config, PropsRef } from '../interfaces';
import type EventManager from '../tools/EventManager';
import type { GestureHandlerDelegate } from '../tools/GestureHandlerDelegate';
import PointerTracker from '../tools/PointerTracker';
import type IGestureHandler from './IGestureHandler';
export default abstract class GestureHandler implements IGestureHandler {
    private _name;
    private lastSentState;
    private _state;
    private _shouldCancelWhenOutside;
    private _enabled;
    private viewRef;
    private propsRef;
    protected actionType: ActionType | null;
    private forAnimated;
    private forReanimated;
    private _handlerTag;
    private _testID?;
    private hitSlop?;
    private manualActivation;
    private mouseButton?;
    private needsPointerData;
    private _tracker;
    private _enableContextMenu;
    private _activeCursor?;
    private _touchAction?;
    private _userSelect?;
    private _activationIndex;
    private _awaiting;
    private _active;
    private _attached;
    private _shouldResetProgress;
    private _pointerType;
    private _delegate;
    constructor(delegate: GestureHandlerDelegate<unknown, IGestureHandler>);
    protected init(viewRef: number, propsRef: React.RefObject<PropsRef>, actionType: ActionType): void;
    usesNativeOrVirtualDetector(): boolean;
    detach(): 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;
    shouldBeginWithRecordedHandlers(_recorded: IGestureHandler[]): boolean;
    shouldAttachGestureToChildView(): 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;
    protected shouldSuppressActiveUpdate(_handlerData: HandlerData<unknown>): boolean;
    private transformEventData;
    private transformStateChangeEvent;
    private transformUpdateEvent;
    private transformTouchEvent;
    private cancelTouches;
    private ensurePropsRef;
    private ensureViewRef;
    protected transformNativeEvent(): Record<string, unknown>;
    private maybeUpdateEnabled;
    setGestureConfig(config: Config): void;
    updateGestureConfig(config: Partial<Config>): 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 testID(): string | undefined;
    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 | null;
    get pointerType(): PointerType;
    get active(): boolean;
    protected set active(value: boolean);
    get awaiting(): boolean;
    protected set awaiting(value: boolean);
    get attached(): boolean;
    protected set attached(value: boolean);
    get activationIndex(): number;
    protected set activationIndex(value: number);
    get shouldResetProgress(): boolean;
    protected set shouldResetProgress(value: boolean);
    get enableContextMenu(): boolean;
    protected set enableContextMenu(value: boolean);
    get activeCursor(): ActiveCursor | undefined;
    get touchAction(): TouchAction | undefined;
    get userSelect(): UserSelect | undefined;
    get name(): SingleGestureName;
    protected set name(value: SingleGestureName);
    /**
     * Whether the handler represents a continuous gesture rather than a discrete one.
     */
    readonly isContinuous: boolean;
    getTrackedPointersID(): number[];
    private isFinished;
}
//# sourceMappingURL=GestureHandler.d.ts.map