@nativescript-community/ui-drawer 0.0.29 → 0.0.33

package/pnpm-global/5/node_modules/@nativescript-community/gesturehandler/gestures_override.d.ts

@@ -1,27 +0,0 @@
-import { View } from '@nativescript/core';
-import { GestureEventData, GestureTypes } from '@nativescript/core/ui/gestures';
-export declare function observe(target: View, type: GestureTypes, callback: (args: GestureEventData) => void, context?: any): GesturesObserver;
-export declare class GesturesObserver {
-    private _callback;
-    private _target;
-    private _context;
-    type: GestureTypes;
-    private nObserver?;
-    get callback(): (args: GestureEventData) => void;
-    get target(): View & {
-        _gestureHandlers?: any;
-    };
-    get context(): any;
-    constructor(target: View, callback: (args: GestureEventData) => void, context: any);
-    disconnect(): void;
-    private _notifyTouch;
-    private _eventData;
-    private _onTargetLoaded;
-    private _onTargetUnloaded;
-    observe(type: GestureTypes): void;
-    private _detach;
-    private onGestureStateChange;
-    private onGestureTouchChange;
-    private _attach;
-    androidOnTouchEvent(motionEvent: android.view.MotionEvent): void;
-}

package/pnpm-global/5/node_modules/@nativescript-community/gesturehandler/gestures_override.js

@@ -1,263 +0,0 @@
-import { GestureTypes, GesturesObserver as NGesturesObserver, TouchAction, toString as gestureToString } from '@nativescript/core/ui/gestures';
-import { layout } from '@nativescript/core/utils/utils';
-import { Manager } from './gesturehandler';
-import { GestureHandlerStateEvent, GestureHandlerTouchEvent, GestureState, HandlerType } from './gesturehandler.common';
-export function observe(target, type, callback, context) {
-    const observer = new GesturesObserver(target, callback, context);
-    observer.observe(type);
-    return observer;
-}
-let TAG = 0;
-export class GesturesObserver {
-    constructor(target, callback, context) {
-        this._target = target;
-        if (!target['TAP_HANDLER_TAG']) {
-            target['TAP_HANDLER_TAG'] = TAG++;
-        }
-        if (!target['LONGPRESS_HANDLER_TAG']) {
-            target['LONGPRESS_HANDLER_TAG'] = TAG++;
-        }
-        if (!target['DOUBLE_TAP_HANDLER_TAG']) {
-            target['DOUBLE_TAP_HANDLER_TAG'] = TAG++;
-        }
-        this._callback = callback;
-        this._context = context;
-    }
-    get callback() {
-        return this._callback;
-    }
-    get target() {
-        return this._target;
-    }
-    get context() {
-        return this._context;
-    }
-    disconnect() {
-        this._detach();
-        if (this.target) {
-            this.target.off('loaded', this._onTargetLoaded);
-            this.target.off('unloaded', this._onTargetUnloaded);
-            this._onTargetLoaded = null;
-            this._onTargetUnloaded = null;
-        }
-        if (this.target) {
-            const list = this.target.getGestureObservers(this.type);
-            if (list && list.length > 0) {
-                for (let i = 0; i < list.length; i++) {
-                    if (list[i].callback === this.callback) {
-                        break;
-                    }
-                }
-                list.length = 0;
-                if (this.target._gestureHandlers && this.target._gestureHandlers[this.type]) {
-                    this.target._gestureHandlers[this.type].detachFromView();
-                    delete this.target._gestureHandlers[this.type];
-                }
-            }
-        }
-        if (this.nObserver) {
-            this.nObserver.disconnect();
-            this.nObserver = null;
-        }
-        this._target = null;
-        this._callback = null;
-        this._context = null;
-    }
-    observe(type) {
-        if (this.target) {
-            this.type = type;
-            this._onTargetLoaded = (args) => {
-                this._attach(this.target, type);
-            };
-            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() {
-        this._notifyTouch = false;
-        this._eventData = null;
-    }
-    onGestureStateChange(type, triggerOnstate = -1) {
-        return (event) => {
-            if (triggerOnstate !== -1 && event.data.state !== triggerOnstate) {
-                return;
-            }
-            if (this.callback) {
-                this.callback.call(this._context, Object.assign(Object.assign({ eventName: gestureToString(type), object: event.data.view, type }, event.data), event.data.extraData));
-            }
-        };
-    }
-    onGestureTouchChange(type) {
-        return (event) => {
-            if (this.callback && event.data.state === GestureState.ACTIVE) {
-                this.callback.call(this._context, Object.assign(Object.assign({ eventName: gestureToString(type), object: event.data.view, type }, event.data), event.data.extraData));
-            }
-        };
-    }
-    _attach(target, type) {
-        if (type & GestureTypes.touch) {
-            this._notifyTouch = true;
-        }
-        const manager = Manager.getInstance();
-        if (!target._gestureHandlers) {
-            target._gestureHandlers = {};
-        }
-        let gestureHandler = target._gestureHandlers[type];
-        if (type & GestureTypes.tap) {
-            if (!gestureHandler) {
-                gestureHandler = manager.createGestureHandler(HandlerType.TAP, target['TAP_HANDLER_TAG'], {
-                    waitFor: [target['LONGPRESS_HANDLER_TAG'], target['DOUBLE_TAP_HANDLER_TAG']],
-                });
-                gestureHandler.attachToView(target);
-                target._gestureHandlers[type] = gestureHandler;
-            }
-            gestureHandler.on(GestureHandlerStateEvent, this.onGestureStateChange(GestureTypes.tap, GestureState.ACTIVE), this);
-        }
-        if (type & GestureTypes.longPress) {
-            if (!gestureHandler) {
-                gestureHandler = manager.createGestureHandler(HandlerType.LONG_PRESS, target['LONGPRESS_HANDLER_TAG']);
-                gestureHandler.attachToView(target);
-                target._gestureHandlers[type] = gestureHandler;
-            }
-            gestureHandler.on(GestureHandlerStateEvent, this.onGestureStateChange(GestureTypes.longPress, GestureState.ACTIVE), this);
-        }
-        if (type & GestureTypes.doubleTap) {
-            if (!gestureHandler) {
-                gestureHandler = manager.createGestureHandler(HandlerType.TAP, target['DOUBLE_TAP_HANDLER_TAG'], {
-                    numberOfTaps: 2,
-                });
-                gestureHandler.attachToView(target);
-                target._gestureHandlers[type] = gestureHandler;
-            }
-            gestureHandler.on(GestureHandlerStateEvent, this.onGestureStateChange(GestureTypes.doubleTap), this);
-        }
-        if (type & GestureTypes.pinch) {
-            if (!gestureHandler) {
-                gestureHandler = manager.createGestureHandler(HandlerType.PINCH, TAG++);
-                gestureHandler.attachToView(target);
-                target._gestureHandlers[type] = gestureHandler;
-            }
-            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++);
-                gestureHandler.attachToView(target);
-                target._gestureHandlers[type] = gestureHandler;
-            }
-            gestureHandler.on(GestureHandlerStateEvent, this.onGestureStateChange(GestureTypes.swipe), this);
-        }
-        if (type & GestureTypes.pan) {
-            if (!gestureHandler) {
-                gestureHandler = manager.createGestureHandler(HandlerType.PAN, TAG++, {});
-                gestureHandler.attachToView(target);
-                target._gestureHandlers[type] = gestureHandler;
-            }
-            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++, {});
-                gestureHandler.attachToView(target);
-                target._gestureHandlers[type] = gestureHandler;
-            }
-            gestureHandler.on(GestureHandlerStateEvent, this.onGestureStateChange(GestureTypes.rotation), this);
-            gestureHandler.on(GestureHandlerTouchEvent, this.onGestureTouchChange(GestureTypes.rotation), this);
-        }
-        if (type & GestureTypes.touch && global.isIOS) {
-            const nObserver = new NGesturesObserver(target, this.callback, this.context);
-            nObserver.observe(type);
-            this.nObserver = nObserver;
-        }
-    }
-    androidOnTouchEvent(motionEvent) {
-        if (this._notifyTouch) {
-            if (!this._eventData) {
-                this._eventData = new TouchGestureEventData();
-            }
-            this._eventData.prepare(this.target, motionEvent);
-            _executeCallback(this, this._eventData);
-        }
-    }
-}
-class Pointer {
-    constructor(id, event) {
-        this.event = event;
-        this.ios = undefined;
-        this.android = id;
-    }
-    getX() {
-        return this.event.getX(this.android) / layout.getDisplayDensity();
-    }
-    getY() {
-        return this.event.getY(this.android) / layout.getDisplayDensity();
-    }
-}
-class TouchGestureEventData {
-    constructor() {
-        this.eventName = gestureToString(GestureTypes.touch);
-        this.type = GestureTypes.touch;
-        this.ios = undefined;
-    }
-    prepare(view, e) {
-        this.view = view;
-        this.object = view;
-        this.android = e;
-        this.action = this.getActionType(e);
-        this._activePointers = undefined;
-        this._allPointers = undefined;
-    }
-    getPointerCount() {
-        return this.android.getPointerCount();
-    }
-    getActivePointers() {
-        if (!this._activePointers) {
-            this._activePointers = [new Pointer(this.android.getActionIndex(), this.android)];
-        }
-        return this._activePointers;
-    }
-    getAllPointers() {
-        if (!this._allPointers) {
-            this._allPointers = [];
-            for (let i = 0; i < this.getPointerCount(); i++) {
-                this._allPointers.push(new Pointer(i, this.android));
-            }
-        }
-        return this._allPointers;
-    }
-    getX() {
-        return this.getActivePointers()[0].getX();
-    }
-    getY() {
-        return this.getActivePointers()[0].getY();
-    }
-    getActionType(e) {
-        switch (e.getActionMasked()) {
-            case android.view.MotionEvent.ACTION_DOWN:
-            case android.view.MotionEvent.ACTION_POINTER_DOWN:
-                return TouchAction.down;
-            case android.view.MotionEvent.ACTION_MOVE:
-                return TouchAction.move;
-            case android.view.MotionEvent.ACTION_UP:
-            case android.view.MotionEvent.ACTION_POINTER_UP:
-                return TouchAction.up;
-            case android.view.MotionEvent.ACTION_CANCEL:
-                return TouchAction.cancel;
-        }
-        return '';
-    }
-}
-function _executeCallback(observer, args) {
-    if (observer && observer.callback) {
-        observer.callback.call(observer._context, args);
-    }
-}
-//# sourceMappingURL=gestures_override.js.map

package/pnpm-global/5/node_modules/@nativescript-community/gesturehandler/package.json

@@ -1,39 +0,0 @@
-{
-    "name": "@nativescript-community/gesturehandler",
-    "version": "0.1.41",
-    "description": "Declarative API exposing platform native touch and gesture system to NativeScript.",
-    "main": "gesturehandler",
-    "sideEffects": false,
-    "typings": "gesturehandler.d.ts",
-    "nativescript": {
-        "platforms": {
-            "android": "6.2.1",
-            "ios": "6.2.1"
-        }
-    },
-    "keywords": [
-        "NativeScript",
-        "JavaScript",
-        "iOS",
-        "Android",
-        "Vue",
-        "preview|https://raw.githubusercontent.com/nativescript-community/gesturehandler/master/images/demo.gif"
-    ],
-    "author": {
-        "name": "Martin Guillon",
-        "email": "martin.guillon@akylas.fr"
-    },
-    "bugs": {
-        "url": "https://github.com/nativescript-community/gesturehandler/issues"
-    },
-    "license": "Apache-2.0",
-    "repository": {
-        "type": "git",
-        "url": "https://github.com/nativescript-community/gesturehandler"
-    },
-    "bootstrapper": "nativescript-plugin-seed",
-    "dependencies": {
-        "@nativescript-community/observable": "^2.0.8"
-    },
-    "gitHead": "670c68d7f27a5213f2af8bf20850fd06dc2fafe1"
-}

package/pnpm-global/5/node_modules/@nativescript-community/gesturehandler/platforms/android/AndroidManifest.xml

@@ -1,2 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<manifest xmlns:android="http://schemas.android.com/apk/res/android" package="com.swmansion.gesturehandler"/>

package/pnpm-global/5/node_modules/@nativescript-community/gesturehandler/platforms/android/include.gradle

@@ -1,9 +0,0 @@
-dependencies {
-    compile(name:'widgets-release', ext:'aar')
-    implementation "androidx.annotation:annotation:1.1.0"
-}
-repositories {
-    flatDir {
-        dirs '../../../node_modules/@nativescript/core/platforms/android'
-    }
-}

package/pnpm-global/5/node_modules/@nativescript-community/gesturehandler/platforms/android/java/com/nativescript/gesturehandler/GestureHandlerInteractionController.java

@@ -1,79 +0,0 @@
-package com.nativescript.gesturehandler;
-
-import android.content.Context;
-import android.view.ViewGroup;
-import android.os.IBinder;
-import android.view.View;
-import android.view.KeyEvent;
-import android.util.AttributeSet;
-import android.view.inputmethod.InputMethodManager;
-import android.util.Log;
-
-import com.swmansion.gesturehandler.GestureHandler;
-
-import java.util.HashMap;
-
-public class GestureHandlerInteractionController implements com.swmansion.gesturehandler.GestureHandlerInteractionController {
-    private HashMap<Number, int[]> mWaitForRelations = new HashMap();
-    private HashMap<Number, int[]> mSimultaneousRelations = new HashMap();
-
-    public GestureHandlerInteractionController() {
-        super();
-    }
-
-    public void dropRelationsForHandlerWithTag(int handlerTag) {
-        mWaitForRelations.remove(handlerTag);
-        mSimultaneousRelations.remove(handlerTag);
-    }
-
-    public void configureInteractions(com.swmansion.gesturehandler.GestureHandler handler, int[] waitFor,
-            int[] simultaneousHandlers) {
-        handler.setInteractionController(this);
-        if (waitFor != null) {
-            mWaitForRelations.put(handler.getTag(), waitFor);
-        }
-        if (simultaneousHandlers != null) {
-            mSimultaneousRelations.put(handler.getTag(), simultaneousHandlers);
-        }
-    }
-
-    public boolean shouldWaitForHandlerFailure(GestureHandler handler, GestureHandler otherHandler) {
-        int[] waitForTags = mWaitForRelations.get(handler.getTag());
-        if (waitForTags != null) {
-            for (int i = 0; i < waitForTags.length; i++) {
-                if (waitForTags[i] == otherHandler.getTag()) {
-                    return true;
-                }
-            }
-        }
-        return false;
-    }
-
-    public boolean shouldRequireHandlerToWaitForFailure(GestureHandler handler, GestureHandler otherHandler) {
-        return false;
-    }
-
-    public boolean shouldHandlerBeCancelledBy(GestureHandler handler, GestureHandler otherHandler) {
-        return false;
-    }
-
-    public boolean shouldRecognizeSimultaneously(GestureHandler handler, GestureHandler otherHandler) {
-        int[] simultHandlerTags = mSimultaneousRelations.get(handler.getTag());
-        if (GestureHandler.debug) {
-            Log.d("JS", "GestureHandlerInteractionController shouldRecognizeSimultaneously " + handler + " " + otherHandler + " " + simultHandlerTags);
-        }
-        if (simultHandlerTags != null) {
-            for (int i = 0; i < simultHandlerTags.length; i++) {
-                if (simultHandlerTags[i] == otherHandler.getTag()) {
-                    return true;
-                }
-            }
-        }
-        return false;
-    }
-
-    public void reset() {
-        mWaitForRelations.clear();
-        mSimultaneousRelations.clear();
-    }
-}

package/pnpm-global/5/node_modules/@nativescript-community/gesturehandler/platforms/android/java/com/nativescript/gesturehandler/PageLayout.java

@@ -1,169 +0,0 @@
-package com.nativescript.gesturehandler;
-
-import android.content.Context;
-import android.view.MotionEvent;
-import android.view.View;
-import android.view.ViewGroup;
-import android.util.Log;
-
-import org.nativescript.widgets.ItemSpec;
-import org.nativescript.widgets.GridUnitType;
-
-import com.swmansion.gesturehandler.GestureHandlerOrchestrator;
-import com.swmansion.gesturehandler.GestureHandlerRegistryImpl;
-import com.swmansion.gesturehandler.PointerEventsConfig;
-import com.swmansion.gesturehandler.GestureHandler;
-import com.swmansion.gesturehandler.ViewConfigurationHelper;
-
-public class PageLayout extends org.nativescript.widgets.GridLayout {
-    public PageLayout(Context context) {
-        super(context);
-        addRow(new ItemSpec(1, GridUnitType.auto));
-        addRow(new ItemSpec(1, GridUnitType.star));
-    }
-    private final static int GESTURE_HANDLER_TAG = -12345;
-
-    private GestureHandlerOrchestrator mOrchestrator;
-    private GestureHandlerRegistryImpl mRegistry;
-    private ViewConfigurationHelper configurationHelper;
-    RootViewGestureHandler rootGestureHandler;
-
-    private boolean mShouldIntercept = false;
-    private boolean mPassingTouch = false;
-    private boolean mDispatchToOrchestra = true;
-
-    public void setShouldIntercept(boolean value) {
-        if (GestureHandler.debug) {
-            Log.d("JS", "PageLayout setShouldIntercept " + value);
-        }
-        this.mShouldIntercept = value;
-    }
-
-    public void setPassingTouch(boolean value) {
-        this.mPassingTouch = value;
-    }
-
-    public void setDispatchToOrchestra(boolean value) {
-        if (GestureHandler.debug) {
-            Log.d("JS", "PageLayout setDispatchToOrchestra " + value);
-        }
-        this.mDispatchToOrchestra = value;
-    }
-
-    public GestureHandlerRegistryImpl registry() {
-        return this.mRegistry;
-    }
-    // requestDisallowInterceptTouchEvent(disallowIntercept) {
-    //     console.log('requestDisallowInterceptTouchEvent');
-    //     if (this.mGestureRootHelper != null) {
-    //         this.mGestureRootHelper.requestDisallowInterceptTouchEvent(disallowIntercept);
-    //     }
-    //     super.requestDisallowInterceptTouchEvent(disallowIntercept);
-    // }
-
-    // dispatchTouchEvent(ev) {
-    //     if (this.mGestureRootHelper != null && this.mGestureRootHelper.dispatchTouchEvent(ev)) {
-    //         return true;
-    //     }
-    //     return super.dispatchTouchEvent(ev);
-    // }
-    public void tryCancelAllHandlers() {
-        if (GestureHandler.debug) {
-            Log.d("JS", "PageLayout tryCancelAllHandlers ");
-        }
-        // In order to cancel handlers we activate handler that is hooked to the root view
-        if (this.rootGestureHandler != null && this.rootGestureHandler.getState() == com.swmansion.gesturehandler.GestureHandler.STATE_BEGAN) {
-            // Try activate main JS handler
-            this.rootGestureHandler.activate();
-            this.rootGestureHandler.end();
-        }
-    }
-
-    public void requestDisallowInterceptTouchEvent(boolean disallowIntercept) {
-        if (GestureHandler.debug) {
-            Log.d("JS", "PageLayout requestDisallowInterceptTouchEvent " + disallowIntercept + " " + this.mPassingTouch);
-        }
-        // If this method gets called it means that some native view is attempting to grab lock for
-        // touch event delivery. In that case we cancel all gesture recognizers
-        if (this.mOrchestrator != null && !this.mPassingTouch) {
-            // if we are in the process of delivering touch events via GH orchestrator, we don't want to
-            // treat it as a native gesture capturing the lock
-            this.tryCancelAllHandlers();
-        }
-        super.requestDisallowInterceptTouchEvent(disallowIntercept);
-    }
-
-    public boolean dispatchTouchEventToOrchestrator(MotionEvent ev) {
-        if (this.mOrchestrator != null) {
-            this.mPassingTouch = true;
-            this.mOrchestrator.onTouchEvent(ev);
-            this.mPassingTouch = false;
-        }
-        if (GestureHandler.debug) {
-            Log.d("JS", "PageLayout dispatchTouchEventToOrchestrator " + this.mShouldIntercept);
-        }
-        return this.mShouldIntercept;
-    }
-
-    public boolean dispatchTouchEvent(MotionEvent ev) {
-        if (GestureHandler.debug) {
-            Log.d("JS", "PageLayout dispatchTouchEvent " + this.mDispatchToOrchestra);
-        }
-        if (this.mDispatchToOrchestra && this.dispatchTouchEventToOrchestrator(ev)) {
-            return true;
-        }
-        final boolean handled = super.dispatchTouchEvent(ev);
-        if (GestureHandler.debug) {
-            Log.d("JS", "PageLayout dispatchTouchEvent to children " + handled);
-        }
-        // we need to always return true or gestures wont work on layouts because they don't handle touch so dispatchTouchEvent returns false
-        return true;
-    }
-
-    // onInterceptTouchEvent(ev: android.view.MotionEvent) {
-    //     return this.mShouldIntercept;
-    // }
-
-    // onTouchEvent(ev: android.view.MotionEvent) {
-    //     console.log('onTouchEvent', ev);
-    //     this.mOrchestrator.onTouchEvent(ev);
-    //     return super.onTouchEvent(ev);
-    // }
-
-    /**
-     * This method is used to enable root view to start processing touch events through the gesture
-     * handler library logic. Unless this method is called (which happens as a result of instantiating
-     * new gesture handler from JS) the root view component will just proxy all touch related methods
-     * to its superclass. Thus in the "disabled" state all touch related events will fallback to
-     * default behavior.
-     */
-    public void initialize() {
-        this.mRegistry = new com.swmansion.gesturehandler.GestureHandlerRegistryImpl();
-        this.configurationHelper = new com.swmansion.gesturehandler.ViewConfigurationHelper() {
-            public PointerEventsConfig getPointerEventsConfigForView(View view) {
-                return view.isEnabled() ? com.swmansion.gesturehandler.PointerEventsConfig.AUTO : com.swmansion.gesturehandler.PointerEventsConfig.NONE;
-            }
-
-            public boolean isViewClippingChildren(ViewGroup parent) {
-                return false;
-            }
-
-            public View getChildInDrawingOrderAtIndex(ViewGroup parent, int index) {
-                return parent.getChildAt(index);
-            }
-        };
-        this.mOrchestrator = new com.swmansion.gesturehandler.GestureHandlerOrchestrator(this, this.mRegistry, this.configurationHelper);
-        this.mOrchestrator.setMinimumAlphaForTraversal(0.01f);
-
-        this.rootGestureHandler = new RootViewGestureHandler();
-        this.rootGestureHandler.setTag(GESTURE_HANDLER_TAG);
-        this.mRegistry.registerHandler(this.rootGestureHandler);
-        this.mRegistry.attachHandlerToView(GESTURE_HANDLER_TAG, this);
-    }
-
-    public void tearDown() {
-        this.configurationHelper = null;
-        this.mOrchestrator = null;
-        this.mRegistry = null;
-    }
-}

package/pnpm-global/5/node_modules/@nativescript-community/gesturehandler/platforms/android/java/com/nativescript/gesturehandler/RootViewGestureHandler.java

@@ -1,45 +0,0 @@
-package com.nativescript.gesturehandler;
-
-import android.content.Context;
-import android.view.MotionEvent;
-import com.swmansion.gesturehandler.GestureHandler;
-import android.os.SystemClock;
-import android.view.View;
-import android.util.Log;
-
-public class RootViewGestureHandler extends GestureHandler {
-    private static final String TAG = "RootViewGestureHandler";
-    public RootViewGestureHandler() {
-        super();
-    }
-
-    public PageLayout getView() {
-        return (PageLayout)super.getView();
-    }
-    protected void onHandle(MotionEvent event) {
-        final int currentState = getState();
-        if (currentState == GestureHandler.STATE_UNDETERMINED) {
-            begin();
-            getView().setShouldIntercept(false);
-        }
-        if (event.getActionMasked() == MotionEvent.ACTION_UP) {
-            end();
-        }
-    }
-
-    protected void onCancel() {
-        if (GestureHandler.debug) {
-            Log.d("JS", "RootViewGestureHandler onCancel");
-        }
-        getView().setShouldIntercept(true);
-        final long time = SystemClock.uptimeMillis();
-        final MotionEvent event = MotionEvent.obtain(time, time, MotionEvent.ACTION_CANCEL, 0, 0, 0);
-        event.setAction(MotionEvent.ACTION_CANCEL);
-        getView().setDispatchToOrchestra(false);
-        getView().dispatchTouchEvent(event);
-        getView().setDispatchToOrchestra(true);
-    }
-    // public boolean shouldRecognizeSimultaneously(GestureHandler handler) {
-    //     return true;
-    // }
-}

package/pnpm-global/5/node_modules/@nativescript-community/gesturehandler/platforms/android/java/com/swmansion/gesturehandler/BaseGestureHandlerInteractionController.java

@@ -1,19 +0,0 @@
-package com.swmansion.gesturehandler;
-
-public abstract class BaseGestureHandlerInteractionController implements GestureHandlerInteractionController {
-
-  @Override
-  public boolean shouldWaitForHandlerFailure(GestureHandler handler, GestureHandler otherHandler) {
-    return false;
-  }
-
-  @Override
-  public boolean shouldRequireHandlerToWaitForFailure(GestureHandler handler, GestureHandler otherHandler) {
-    return false;
-  }
-
-  @Override
-  public boolean shouldRecognizeSimultaneously(GestureHandler handler, GestureHandler otherHandler) {
-    return false;
-  }
-}