gesturx 1.6.0 → 1.7.1

package/dist/index.d.ts

@@ -12,11 +12,7 @@ declare type PanConfig = {
     numInputs?: number;
 };
 
-export declare interface PanEvent extends RecognizerEvent {
-    type: "panStart" | "panMove" | "panEnd";
-}
-
-declare interface PanEvent_2 extends RecognizerEvent {
+declare interface PanEvent extends RecognizerEvent {
     type: "panStart" | "panMove" | "panEnd";
 }
 
@@ -28,8 +24,8 @@ export declare class PanRecognizer extends Recognizer<PanRecognizerOptions, PanE
     update(config: RecognizerConfig<PanRecognizerOptions>): void;
 }
 
-declare interface PanRecognizerInterface extends Recognizer<PanRecognizerOptions, PanEvent_2> {
-    events$: Observable<PanEvent_2>;
+declare interface PanRecognizerInterface extends Recognizer<PanRecognizerOptions, PanEvent> {
+    events$: Observable<PanEvent>;
     update(options: RecognizerConfig<PanRecognizerOptions>): void;
 }
 
@@ -77,16 +73,14 @@ declare interface PinchRecognizerOptions {
 export declare class Recognizable<T extends Recognizer<any, any>[]> implements RecognizableInterface<T> {
     protected options: {
         recognizers: T;
-        afterEventReceived?: (event: PointerEvent) => PointerEvent;
-    };
+    } & RecognizerConfig<unknown>;
     events$: Observable<ObservedValueOf<T[number]["events$"]>>;
     recognizers: T;
     state$: Observable<RecognizableState>;
     constructor(options: {
         recognizers: T;
-        afterEventReceived?: (event: PointerEvent) => PointerEvent;
-    });
-    initialize(container: HTMLElement): void;
+    } & RecognizerConfig<unknown>);
+    update(options: RecognizerConfig<unknown>): void;
 }
 
 declare interface RecognizableInterface<T extends Recognizer<any, any>[]> {
@@ -108,12 +102,13 @@ declare interface RecognizableInterface<T extends Recognizer<any, any>[]> {
      */
     readonly state$: Observable<RecognizableState>;
     /**
-     * Initialize the instance with a given html element.
+     * Update the recognizable with given options.
      *
-     * You can only initialize one element per instance but you can
-     * change the element and call the method again if needed.
+     * The options are in fact passed down to all of the recognizers.
+     * Use it to initialize the container when you want to start
+     * listenin to gesture events.
      */
-    initialize(container: HTMLElement): void;
+    update(options: RecognizerConfig<unknown>): void;
 }
 
 declare type RecognizableState = {
@@ -132,7 +127,10 @@ export declare abstract class Recognizer<Options extends Record<any, any>, Event
     protected configSubject: BehaviorSubject<RecognizerConfig<Options> & {
         panConfig?: PanConfig | undefined;
     }>;
-    protected panEvent$: Observable<PanEvent>;
+    protected pan$: Observable<RecognizerPanEvent>;
+    protected panStart$: Observable<RecognizerEvent>;
+    protected panMove$: Observable<RecognizerEvent>;
+    protected panEnd$: Observable<RecognizerEvent>;
     protected pointerEvent$: Observable<PointerEvent>;
     protected pointerDown$: Observable<PointerEvent>;
     protected pointerUp$: Observable<PointerEvent>;
@@ -204,6 +202,10 @@ declare interface RecognizerEvent {
     pointersAverageDistance: number;
 }
 
+export declare interface RecognizerPanEvent extends RecognizerEvent {
+    type: "start" | "move" | "end";
+}
+
 declare interface RotateEvent extends RecognizerEvent {
     type: "rotateMove" | "rotateStart" | "rotateEnd";
     /**