gesturx 1.0.0 → 1.2.0

package/README.md

@@ -1,3 +1,19 @@
 # gesturx
 
-Gesture recognizer using rxjs
+Modern multi touch gesture recognizer using rxjs.
+
+# Documentation
+
+Head over the [wiki](https://github.com/mbret/gesturx/wiki).
+
+# Demo
+
+[https://gesturx.vercel.app/](https://gesturx.vercel.app/)
+
+# License
+
+MIT
+
+# author
+
+[mbret](https://github.com/mbret)

package/dist/index.d.ts

@@ -0,0 +1,192 @@
+import { BehaviorSubject } from 'rxjs';
+import { Observable } from 'rxjs';
+
+export declare const createManager: ({ afterEventReceived, recognizers, }: {
+    recognizers: (TapRecognizer | PanRecognizer | SwipeRecognizer | RotateRecognizer | PinchRecognizer)[];
+    afterEventReceived?: (event: PointerEvent) => PointerEvent;
+}) => {
+    events$: Observable<PanEvent | SwipeEvent | TapEvent | RotateEvent | PinchEvent>;
+    initialize: (container: HTMLElement) => void;
+    recognizers: (PanRecognizer | SwipeRecognizer | TapRecognizer | RotateRecognizer | PinchRecognizer)[];
+};
+
+export declare type Manager = ReturnType<typeof createManager>;
+
+declare type Options = {
+    posThreshold?: number;
+};
+
+declare type Options_2 = {
+    /**
+     * The minimum velocity (px/ms) that the gesture has to obtain by the end event.
+     */
+    escapeVelocity?: number;
+    numInputs?: number;
+    maxRestTime?: number;
+    posThreshold?: number;
+};
+
+declare interface Options_3 extends RecognizerOptions {
+    multiTapThreshold?: number;
+    maximumPressTime?: number;
+    maxTaps?: number;
+    posThreshold?: number;
+}
+
+declare type Options_4 = {
+    posThreshold?: number;
+};
+
+declare type Options_5 = {
+    posThreshold?: number;
+};
+
+export declare interface PanEvent extends RecognizerEvent {
+    type: "panStart" | "panMove" | "panEnd";
+}
+
+export declare class PanRecognizer extends Recognizer<Options> {
+    protected options: Options;
+    events$: Observable<PanEvent>;
+    start$: Observable<PanEvent>;
+    end$: Observable<PanEvent>;
+    fingers$: Observable<number>;
+    constructor(options?: Options);
+}
+
+export declare interface PinchEvent extends RecognizerEvent {
+    type: "pinchStart" | "pinchMove" | "pinchEnd";
+    scale: number;
+    /**
+     * Distance between start and current
+     */
+    distance: number;
+    /**
+     * Delta distance between events
+     */
+    deltaDistance: number;
+    /**
+     * Delta scale between events
+     */
+    deltaDistanceScale: number;
+}
+
+export declare class PinchRecognizer extends Recognizer<Options_5> {
+    protected options: Options_5;
+    events$: Observable<PinchEvent>;
+    constructor(options?: Options_5);
+}
+
+declare class Recognizer<Options> {
+    protected config$: BehaviorSubject<RecognizerConfig<Options>>;
+    protected validConfig$: Observable<ValidRecognizerConfig<Options>>;
+    constructor(options: Options);
+    initialize(config: RecognizerConfig<Options>): void;
+    update(options: Options): void;
+}
+
+declare type RecognizerConfig<Options> = {
+    container?: HTMLElement;
+    afterEventReceived?: (event: PointerEvent) => PointerEvent;
+    options?: Options;
+};
+
+declare interface RecognizerEvent {
+    center: {
+        x: number;
+        y: number;
+    };
+    event: PointerEvent;
+    /**
+     * Contain the last known pointer event for each active fingers.
+     * It should contain a unique list, with n being the number of active fingers.
+     */
+    pointers: PointerEvent[];
+    /**
+     * Delay between the user action and the event recognition
+     */
+    delay: number;
+    deltaX: number;
+    deltaY: number;
+    /**
+     * @important
+     * Can be negative, 0, positive
+     */
+    velocityX: number;
+    /**
+     * @important
+     * Can be negative, 0, positive
+     */
+    velocityY: number;
+    startTime: number;
+    /**
+     * Angle delta (in degrees) between pointers between this event
+     * and the previous one.
+     *
+     * @important
+     * - Will only register a delta if the previous event and current event
+     *   have the same amount of fingers
+     */
+    deltaPointersAngle: number;
+    /**
+     * Average distance between all pointers
+     */
+    pointersAverageDistance: number;
+}
+
+declare interface RecognizerOptions {
+    failWith?: {
+        start$: Observable<unknown>;
+    }[];
+}
+
+export declare interface RotateEvent extends RecognizerEvent {
+    type: "rotate" | "rotateStart" | "rotateEnd";
+    /**
+     * Current rotation angle
+     */
+    angle: number;
+    /**
+     * Delta angle between events
+     */
+    deltaAngle: number;
+}
+
+export declare class RotateRecognizer extends Recognizer<Options_4> {
+    protected options: Options_4;
+    events$: Observable<RotateEvent>;
+    constructor(options?: Options_4);
+}
+
+export declare interface SwipeEvent extends RecognizerEvent {
+    type: "swipe";
+    /**
+     * Angle between first pointer and last one in degree
+     *
+     *             (-90)
+     * (+/-180) <-   |   -> (+/-0)
+     *             (+90)
+     */
+    angle: number;
+}
+
+export declare class SwipeRecognizer extends Recognizer<Options_2> {
+    protected options: Options_2;
+    events$: Observable<SwipeEvent>;
+    constructor(options?: Options_2);
+}
+
+export declare interface TapEvent extends RecognizerEvent {
+    type: "tap";
+    taps: number;
+}
+
+export declare class TapRecognizer extends Recognizer<Options_3> {
+    protected options: Options_3;
+    events$: Observable<TapEvent>;
+    constructor(options: Options_3);
+}
+
+declare type ValidRecognizerConfig<Options> = Required<Pick<RecognizerConfig<Options>, "container">> & RecognizerConfig<Options>;
+
+export { }