@nativescript-community/gesturehandler 0.2.0 → 2.0.0

package/{gestures_override.js → .history/src/gesturehandler/gestures_override_20220328170816.ts}

@@ -1,17 +1,42 @@
-import { View } from '@nativescript/core';
-import { GestureStateTypes, GestureTypes, GesturesObserver as NGesturesObserver, SwipeDirection, TouchAction, toString as gestureToString } from '@nativescript/core/ui/gestures';
+import { EventData, View } from '@nativescript/core';
+import { GestureEventData, GestureStateTypes, GestureTypes, GesturesObserver as NGesturesObserver, SwipeDirection, TouchAction, toString as gestureToString } from '@nativescript/core/ui/gestures';
 import { layout } from '@nativescript/core/utils/utils';
 import { Handler, Manager } from './gesturehandler';
-import { GestureHandlerStateEvent, GestureHandlerTouchEvent, GestureState, HandlerType, ROOT_GESTURE_HANDLER_TAG } from './gesturehandler.common';
-export function observe(target, type, callback, context) {
+import { GestureHandlerStateEvent, GestureHandlerTouchEvent, GestureState, GestureStateEventData, HandlerType, ROOT_GESTURE_HANDLER_TAG } from './gesturehandler.common';
+
+export function observe(target: View, type: GestureTypes, callback: (args: GestureEventData) => void, context?: any): GesturesObserver {
     const observer = new GesturesObserver(target, callback, context);
     observer.observe(type);
     return observer;
 }
+
 let TAG = 0;
 export class GesturesObserver {
-    constructor(target, callback, context) {
-        this._eventData = {};
+    private _callback: (args: GestureEventData) => void;
+    private _target: View & {
+        _gestureHandlers?: any;
+    };
+    private _context: any;
+
+    public type: GestureTypes;
+
+    private nObserver?: NGesturesObserver;
+
+    //@ts-ignore
+    public get callback(): (args: GestureEventData) => void {
+        return this._callback;
+    }
+
+    public get target() {
+        return this._target;
+    }
+
+    //@ts-ignore
+    public get context() {
+        return this._context;
+    }
+
+    constructor(target: View, callback: (args: GestureEventData) => void, context: any) {
         this._target = target;
         if (!target['TAP_HANDLER_TAG']) {
             target['TAP_HANDLER_TAG'] = TAG++;
@@ -31,24 +56,20 @@ export class GesturesObserver {
         this._callback = callback;
         this._context = context;
     }
-    get callback() {
-        return this._callback;
-    }
-    get target() {
-        return this._target;
-    }
-    get context() {
-        return this._context;
-    }
-    disconnect() {
+
+    public disconnect() {
         console.log('disconnect');
         this._detach();
+
         if (this.target) {
             this.target.off('loaded', this._onTargetLoaded);
             this.target.off('unloaded', this._onTargetUnloaded);
+
             this._onTargetLoaded = null;
             this._onTargetUnloaded = null;
         }
+        // clears target, context and callback references
+        // remove gesture observer from map
         if (this.target) {
             const list = this.target.getGestureObservers(this.type);
             if (list && list.length > 0) {
@@ -58,7 +79,7 @@ export class GesturesObserver {
                     }
                 }
                 list.length = 0;
-                this.target._gestureObservers[this.type].disconnect();
+
                 delete this.target._gestureObservers[this.type];
                 if (this.target._gestureHandlers && this.target._gestureHandlers[this.type]) {
                     delete this.target._gestureHandlers[this.type];
@@ -73,7 +94,15 @@ export class GesturesObserver {
         this._callback = null;
         this._context = null;
     }
-    observe(type) {
+    private _notifyTouch: boolean;
+
+    private gestureHandler: Handler<any, any>;
+    private _eventData: { [k: number]: CommonGestureEventData | TouchGestureEventData } = {};
+
+    private _onTargetLoaded: (data: EventData) => void;
+    private _onTargetUnloaded: (data: EventData) => void;
+
+    public observe(type: GestureTypes) {
         if (this.target) {
             this.type = type;
             this._onTargetLoaded = (args) => {
@@ -82,14 +111,17 @@ export class GesturesObserver {
             this._onTargetUnloaded = (args) => {
                 this._detach();
             };
+
             this.target.on('loaded', this._onTargetLoaded);
             this.target.on('unloaded', this._onTargetUnloaded);
+
             if (this.target.isLoaded) {
                 this._attach(this.target, type);
             }
         }
     }
-    _detach() {
+
+    private _detach() {
         if (this.gestureHandler) {
             this.gestureHandler.detachFromView(this.target);
             this.gestureHandler = null;
@@ -98,9 +130,10 @@ export class GesturesObserver {
         this._notifyTouch = false;
         this._eventData = {};
     }
-    emitEvent(type, event) {
+
+    private emitEvent(type: GestureTypes, event: GestureStateEventData) {
         if (this.callback) {
-            let eventData = this._eventData[type];
+            let eventData = this._eventData[type] as CommonGestureEventData;
             if (!eventData) {
                 switch (type) {
                     case GestureTypes.pan:
@@ -119,24 +152,36 @@ export class GesturesObserver {
             }
             eventData.prepare(this.target, event.data);
             _executeCallback(this, eventData);
+            // this.callback.call(this._context, {
+            //     eventName: gestureToString(type),
+            //     object: event.data.view,
+            //     type,
+            //     ...event.data,
+            //     ...event.data.extraData,
+            // });
         }
     }
-    onGestureStateChange(type, triggerOnstate = -1) {
-        return (event) => {
+    private onGestureStateChange(type: GestureTypes, triggerOnstate = -1) {
+        return (event: GestureStateEventData) => {
             if (triggerOnstate !== -1 && event.data.state !== triggerOnstate) {
                 return;
             }
             this.emitEvent(type, event);
         };
     }
-    onGestureTouchChange(type) {
-        return (event) => {
+    private onGestureTouchChange(type: GestureTypes) {
+        return (event: GestureStateEventData) => {
             if (event.data.state === GestureState.ACTIVE) {
                 this.emitEvent(type, event);
             }
         };
     }
-    _attach(target, type) {
+    private _attach(
+        target: View & {
+            _gestureHandlers?: any;
+        },
+        type: GestureTypes
+    ) {
         this._detach();
         if (type & GestureTypes.touch) {
             this._notifyTouch = true;
@@ -146,6 +191,7 @@ export class GesturesObserver {
             target._gestureHandlers = {};
         }
         let gestureHandler = target._gestureHandlers[type];
+
         if (type & GestureTypes.tap) {
             if (!gestureHandler) {
                 gestureHandler = manager.createGestureHandler(HandlerType.TAP, target['TAP_HANDLER_TAG'], {
@@ -178,6 +224,7 @@ export class GesturesObserver {
             }
             gestureHandler.on(GestureHandlerStateEvent, this.onGestureStateChange(GestureTypes.doubleTap), this);
         }
+
         if (type & GestureTypes.pinch) {
             if (!gestureHandler) {
                 gestureHandler = manager.createGestureHandler(HandlerType.PINCH, target['PINCH_HANDLER_TAG'], {
@@ -189,6 +236,7 @@ export class GesturesObserver {
             gestureHandler.on(GestureHandlerStateEvent, this.onGestureStateChange(GestureTypes.pinch), this);
             gestureHandler.on(GestureHandlerTouchEvent, this.onGestureTouchChange(GestureTypes.pinch), this);
         }
+
         if (type & GestureTypes.swipe) {
             if (!gestureHandler) {
                 gestureHandler = manager.createGestureHandler(HandlerType.FLING, TAG++, {
@@ -199,6 +247,7 @@ export class GesturesObserver {
             }
             gestureHandler.on(GestureHandlerStateEvent, this.onGestureStateChange(GestureTypes.swipe), this);
         }
+
         if (type & GestureTypes.pan) {
             if (!gestureHandler) {
                 gestureHandler = manager.createGestureHandler(HandlerType.PAN, target['PAN_HANDLER_TAG'], {
@@ -210,6 +259,7 @@ export class GesturesObserver {
             gestureHandler.on(GestureHandlerStateEvent, this.onGestureStateChange(GestureTypes.pan), this);
             gestureHandler.on(GestureHandlerTouchEvent, this.onGestureTouchChange(GestureTypes.pan), this);
         }
+
         if (type & GestureTypes.rotation) {
             if (!gestureHandler) {
                 gestureHandler = manager.createGestureHandler(HandlerType.ROTATION, TAG++, {
@@ -222,13 +272,15 @@ export class GesturesObserver {
             gestureHandler.on(GestureHandlerTouchEvent, this.onGestureTouchChange(GestureTypes.rotation), this);
         }
         if (type & GestureTypes.touch && global.isIOS) {
+            // let s not reimplement it for touch
             const nObserver = new NGesturesObserver(target, this.callback, this.context);
             nObserver.observe(type);
             this.nObserver = nObserver;
         }
         this.gestureHandler = gestureHandler;
     }
-    androidOnTouchEvent(motionEvent) {
+
+    public androidOnTouchEvent(motionEvent: android.view.MotionEvent) {
         if (this._notifyTouch) {
             let eventData = this._eventData[GestureTypes.touch];
             if (!eventData) {
@@ -239,38 +291,68 @@ export class GesturesObserver {
         }
     }
 }
-class Pointer {
-    constructor(id, event) {
-        this.event = event;
-        this.ios = undefined;
+
+class Pointer implements Pointer {
+    public android: number;
+    public ios: any = undefined;
+
+    constructor(id: number, private event: android.view.MotionEvent) {
         this.android = id;
     }
-    getX() {
+
+    getX(): number {
         return this.event.getX(this.android) / layout.getDisplayDensity();
     }
-    getY() {
+
+    getY(): number {
         return this.event.getY(this.android) / layout.getDisplayDensity();
     }
 }
 class GesturePointer {
-    constructor(index, x, y) {
-        this.x = x;
-        this.y = y;
+    android: number;
+    ios: number;
+    private event: any;
+    constructor(index: number, private x, private y) {
         this.android = index;
     }
-    getX() {
+
+    getX(): number {
         return this.x;
     }
-    getY() {
+
+    getY(): number {
         return this.y;
     }
 }
-class CommonGestureEventData {
-    constructor(type) {
+
+class CommonGestureEventData implements GestureEventData {
+    ios;
+    android;
+    eventName: string;
+    type: GestureTypes;
+    view: View;
+    object: any;
+    eventData: {
+        state: GestureState;
+        ios?: any; // native View
+        android?: any; // native View
+        view?: View; // native View
+        extraData: {
+            numberOfPointers: number;
+            [k: string]: number | string;
+        };
+    };
+    state: GestureStateTypes;
+
+    private _activePointers: GesturePointer[];
+    private _allPointers: GesturePointer[];
+
+    constructor(type: GestureTypes) {
         this.eventName = gestureToString(type);
         this.type = type;
     }
-    prepare(view, eventData) {
+
+    public prepare(view: View, eventData) {
         this.view = view;
         this.object = view;
         this._activePointers = undefined;
@@ -292,19 +374,24 @@ class CommonGestureEventData {
                 break;
         }
     }
+
     get extraData() {
         return this.eventData.extraData;
     }
-    getPointerCount() {
+
+    getPointerCount(): number {
         return this.extraData.numberOfPointers;
     }
+
     getActivePointers() {
+        // Only one active pointer in Android
         if (!this._activePointers) {
             const positions = this.extraData.positions;
             this._activePointers = [new GesturePointer(0, positions[0], positions[1])];
         }
         return this._activePointers;
     }
+
     getAllPointers() {
         if (!this._allPointers) {
             this._allPointers = [];
@@ -315,13 +402,16 @@ class CommonGestureEventData {
         }
         return this._allPointers;
     }
-    getX() {
-        return this.extraData.x;
+
+    getX(): number {
+        return this.extraData.x as number;
     }
-    getY() {
-        return this.extraData.y;
+
+    getY(): number {
+        return this.extraData.y as number;
     }
-    getActionType(e) {
+
+    private getActionType(e: android.view.MotionEvent): string {
         switch (e.getActionMasked()) {
             case android.view.MotionEvent.ACTION_DOWN:
             case android.view.MotionEvent.ACTION_POINTER_DOWN:
@@ -334,16 +424,24 @@ class CommonGestureEventData {
             case android.view.MotionEvent.ACTION_CANCEL:
                 return TouchAction.cancel;
         }
+
         return '';
     }
 }
 class TouchGestureEventData {
-    constructor() {
-        this.eventName = gestureToString(GestureTypes.touch);
-        this.type = GestureTypes.touch;
-        this.ios = undefined;
-    }
-    prepare(view, e) {
+    eventName: string = gestureToString(GestureTypes.touch);
+    type: GestureTypes = GestureTypes.touch;
+    ios: any = undefined;
+    action: string;
+    view: View;
+    android: android.view.MotionEvent;
+    object: any;
+    state: GestureStateTypes;
+
+    private _activePointers: Pointer[];
+    private _allPointers: Pointer[];
+
+    public prepare(view: View, e: android.view.MotionEvent) {
         this.view = view;
         this.object = view;
         this.android = e;
@@ -351,16 +449,20 @@ class TouchGestureEventData {
         this._activePointers = undefined;
         this._allPointers = undefined;
     }
-    getPointerCount() {
+
+    getPointerCount(): number {
         return this.android.getPointerCount();
     }
-    getActivePointers() {
+
+    getActivePointers(): Pointer[] {
+        // Only one active pointer in Android
         if (!this._activePointers) {
             this._activePointers = [new Pointer(this.android.getActionIndex(), this.android)];
         }
         return this._activePointers;
     }
-    getAllPointers() {
+
+    getAllPointers(): Pointer[] {
         if (!this._allPointers) {
             this._allPointers = [];
             for (let i = 0; i < this.getPointerCount(); i++) {
@@ -369,13 +471,16 @@ class TouchGestureEventData {
         }
         return this._allPointers;
     }
-    getX() {
+
+    getX(): number {
         return this.getActivePointers()[0].getX();
     }
-    getY() {
+
+    getY(): number {
         return this.getActivePointers()[0].getY();
     }
-    getActionType(e) {
+
+    private getActionType(e: android.view.MotionEvent): string {
         switch (e.getActionMasked()) {
             case android.view.MotionEvent.ACTION_DOWN:
             case android.view.MotionEvent.ACTION_POINTER_DOWN:
@@ -388,15 +493,17 @@ class TouchGestureEventData {
             case android.view.MotionEvent.ACTION_CANCEL:
                 return TouchAction.cancel;
         }
+
         return '';
     }
 }
-function _getSwipeDirection(direction) {
+
+function _getSwipeDirection(direction: string): SwipeDirection {
     return SwipeDirection[direction];
 }
 class SwipeGestureEventData extends CommonGestureEventData {
     get direction() {
-        return _getSwipeDirection(this.extraData.direction);
+        return _getSwipeDirection(this.extraData.direction as string);
     }
 }
 class PanGestureEventData extends CommonGestureEventData {
@@ -418,9 +525,9 @@ class PinchGestureEventData extends CommonGestureEventData {
         return this.eventData.extraData.scale;
     }
 }
-function _executeCallback(observer, args) {
+
+function _executeCallback(observer: GesturesObserver, args: GestureEventData) {
     if (observer && observer.callback) {
-        observer.callback.call(observer._context, args);
+        observer.callback.call((observer as any)._context, args);
     }
 }
-//# sourceMappingURL=gestures_override.js.map