@nativescript-community/gesturehandler 0.2.2 → 2.0.0

package/.history/src/gesturehandler.common_20220328144621.ts

@@ -0,0 +1,325 @@
+/* eslint-disable no-redeclare */
+// import { launchEvent } from '@nativescript/core/application';
+// console.log(launchEvent);
+// console.log('gestures common', global.NativeScriptHasInitGlobal);
+
+import Observable from '@nativescript-community/observable';
+import { EventData, GridLayout } from '@nativescript/core';
+import { CssProperty, Property, Style, View, booleanConverter } from '@nativescript/core/ui';
+import {
+    FlingGestureHandler,
+    FlingGestureHandlerOptions,
+    ForceTouchGestureHandler,
+    ForceTouchGestureHandlerOptions,
+    Handler,
+    LongPressGestureHandler,
+    LongPressGestureHandlerOptions,
+    Manager,
+    NativePropertyOptions,
+    NativeViewGestureHandler,
+    NativeViewGestureHandlerOptions,
+    PanGestureHandler,
+    PanGestureHandlerOptions,
+    PinchGestureHandler,
+    PinchGestureHandlerOptions,
+    RotationGestureHandler,
+    RotationGestureHandlerOptions,
+    TapGestureHandler,
+    TapGestureHandlerOptions,
+} from './gesturehandler';
+
+export const GestureHandlerStateEvent = 'GestureHandlerStateEvent';
+export const GestureHandlerTouchEvent = 'GestureHandlerTouchEvent';
+export const ROOT_GESTURE_HANDLER_TAG = -12345;
+
+export enum HandlerType {
+    PAN = 'pan',
+    TAP = 'tap',
+    FLING = 'fling',
+    LONG_PRESS = 'longPress',
+    NATIVE_VIEW = 'nativeView',
+    PINCH = 'pinch',
+    ROTATION = 'rotation',
+    FORCE_TOUCH = 'forceTouch',
+}
+
+export interface OptionsTypeMap {
+    [HandlerType.TAP]: TapGestureHandlerOptions;
+    [HandlerType.LONG_PRESS]: LongPressGestureHandlerOptions;
+    [HandlerType.PINCH]: PinchGestureHandlerOptions;
+    [HandlerType.FLING]: FlingGestureHandlerOptions;
+    [HandlerType.PAN]: PanGestureHandlerOptions;
+    [HandlerType.ROTATION]: RotationGestureHandlerOptions;
+    [HandlerType.NATIVE_VIEW]: NativeViewGestureHandlerOptions;
+    [HandlerType.FORCE_TOUCH]: ForceTouchGestureHandlerOptions;
+}
+export interface TypeMap {
+    [HandlerType.TAP]: TapGestureHandler;
+    [HandlerType.LONG_PRESS]: LongPressGestureHandler;
+    [HandlerType.PINCH]: PinchGestureHandler;
+    [HandlerType.FLING]: FlingGestureHandler;
+    [HandlerType.PAN]: PanGestureHandler;
+    [HandlerType.ROTATION]: RotationGestureHandler;
+    [HandlerType.NATIVE_VIEW]: NativeViewGestureHandler;
+    [HandlerType.FORCE_TOUCH]: ForceTouchGestureHandler;
+}
+
+function createGetter(key: string, options: NativePropertyOptions) {
+    // console.log('createGetter', key, options);
+    const nativeGetterName = ((global.isAndroid ? options.android : options.ios) || options).nativeGetterName || 'get' + key.charAt(0).toUpperCase() + key.slice(1);
+    const converter = options.converter;
+    return function () {
+        let result;
+        // console.log('getter', key, nativeGetterName);
+        if (this.native && this.native[nativeGetterName]) {
+            result = this.native[nativeGetterName]();
+        } else {
+            result = this.options[key] || options.defaultValue;
+        }
+        result = converter && converter.fromNative ? converter.fromNative.call(this, result, key) : result;
+        // console.log('getter', key, options, nativeGetterName, !!getConverter, result);
+        return result;
+    };
+}
+function createSetter(key, options: NativePropertyOptions) {
+    const nativeSetterName = ((global.isAndroid ? options.android : options.ios) || options).nativeSetterName || 'set' + key.charAt(0).toUpperCase() + key.slice(1);
+    return function (newVal) {
+        this.options[key] = newVal;
+        if (this.native && this.native[nativeSetterName]) {
+            const actualVal = options.converter && options.converter.toNative ? options.converter.toNative.call(this, newVal, key) : newVal;
+            (this.native[nativeSetterName] as Function).call(this.native, actualVal);
+        }
+    };
+}
+
+function nativePropertyGenerator(target: Object, key: string, options?: NativePropertyOptions) {
+    Object.defineProperty(target, key, {
+        get: createGetter(key, options),
+        set: createSetter(key, options),
+        enumerable: true,
+        configurable: true,
+    });
+}
+export function nativeProperty(target: any, k?, desc?: PropertyDescriptor): any;
+export function nativeProperty(options: NativePropertyOptions): (target: any, k?, desc?: PropertyDescriptor) => any;
+export function nativeProperty(...args) {
+    if (args.length === 1) {
+        /// this must be a factory
+        return function (target: any, key?: string, descriptor?: PropertyDescriptor) {
+            return nativePropertyGenerator(target, key, args[0] || {});
+        };
+    } else {
+        const options = typeof args[1] === 'string' ? undefined : args[0];
+        const startIndex = !!options ? 1 : 0;
+        return nativePropertyGenerator(args[startIndex], args[startIndex + 1], options || {});
+    }
+}
+export abstract class BaseNative<T, U extends {}> extends Observable {
+    constructor(public options?: U, native?: T) {
+        super();
+        if (native) {
+            this.native = native;
+        }
+    }
+    native: T;
+    initNativeView(native: T, options: U) {
+        for (const key in options) {
+            (this as any)[key] = options[key];
+        }
+    }
+    disposeNativeView() {
+        this.native = null;
+    }
+    getNative = () => {
+        if (!this.native) {
+            this.native = this.createNative(this.options);
+            this.initNativeView(this.native, this.options);
+        }
+        return this.native;
+    };
+    abstract createNative(options: U): T;
+}
+
+export abstract class ManagerBase extends Observable {
+    abstract createGestureHandler<T extends HandlerType>(handlerName: T, handlerTag: number, config?: OptionsTypeMap[T]): TypeMap[T];
+}
+
+export enum GestureState {
+    UNDETERMINED,
+    FAILED,
+    BEGAN,
+    CANCELLED,
+    ACTIVE,
+    END,
+}
+
+export interface GestureStateEventData extends EventData {
+    object: Handler<any, any>;
+    data: {
+        state: GestureState;
+        prevState: GestureState;
+        ios?: any; // native View
+        android?: any; // native View
+        view: View;
+        extraData: {
+            [k: string]: number;
+        };
+    };
+}
+export interface GestureTouchEventData extends EventData {
+    object: Handler<any, any>;
+    data: {
+        state: GestureState;
+        ios?: any; // native View
+        android?: any; // native View
+        view?: View; // native View
+        extraData: {
+            [k: string]: number;
+        };
+    };
+}
+
+export class BaseGestureRootView extends GridLayout {}
+
+export function applyMixins(
+    derivedCtor: any,
+    baseCtors: any[],
+    options?: {
+        after?: boolean;
+        override?: boolean;
+        omit?: (string | symbol)[];
+    }
+) {
+    const omits = options && options.omit ? options.omit : [];
+    baseCtors.forEach((baseCtor) => {
+        Object.getOwnPropertyNames(baseCtor.prototype).forEach((name) => {
+            if (omits.indexOf(name) !== -1) {
+                return;
+            }
+            const descriptor = Object.getOwnPropertyDescriptor(baseCtor.prototype, name);
+
+            if (name === 'constructor') return;
+            if (descriptor && (!descriptor.writable || !descriptor.configurable || descriptor.get || descriptor.set)) {
+                Object.defineProperty(derivedCtor.prototype, name, descriptor);
+            } else {
+                const oldImpl = derivedCtor.prototype[name];
+                if (!oldImpl) {
+                    derivedCtor.prototype[name] = baseCtor.prototype[name];
+                } else {
+                    derivedCtor.prototype[name] = function (...args) {
+                        if (options) {
+                            if (!!options.override) {
+                                return baseCtor.prototype[name].apply(this, args);
+                            } else if (!!options.after) {
+                                oldImpl.apply(this, args);
+                                return baseCtor.prototype[name].apply(this, args);
+                            } else {
+                                baseCtor.prototype[name].apply(this, args);
+                                return oldImpl.apply(this, args);
+                            }
+                        } else {
+                            baseCtor.prototype[name].apply(this, args);
+                            return oldImpl.apply(this, args);
+                        }
+                    };
+                }
+            }
+        });
+        Object.getOwnPropertySymbols(baseCtor.prototype).forEach((symbol) => {
+            if (omits.indexOf(symbol) !== -1) {
+                return;
+            }
+            const oldImpl: Function = derivedCtor.prototype[symbol];
+            if (!oldImpl) {
+                derivedCtor.prototype[symbol] = baseCtor.prototype[symbol];
+            } else {
+                derivedCtor.prototype[symbol] = function (...args) {
+                    if (options) {
+                        if (!!options.override) {
+                            return baseCtor.prototype[symbol].apply(this, args);
+                        } else if (!!options.after) {
+                            oldImpl.apply(this, args);
+                            return baseCtor.prototype[symbol].apply(this, args);
+                        } else {
+                            baseCtor.prototype[symbol].apply(this, args);
+                            return oldImpl.apply(this, args);
+                        }
+                    } else {
+                        baseCtor.prototype[symbol].apply(this, args);
+                        return oldImpl.apply(this, args);
+                    }
+                };
+            }
+        });
+    });
+}
+
+export const exclusiveTouchProperty = new CssProperty<Style, boolean>({
+    name: 'exclusiveTouch',
+    cssName: 'exclusive-touch',
+    defaultValue: false,
+    valueConverter: booleanConverter,
+});
+
+export const ViewInitEvent = 'ViewInitEvent';
+export const ViewDisposeEvent = 'ViewDisposeEvent';
+
+let NATIVE_GESTURE_TAG = 74000;
+class ViewGestureExtended extends View {
+    exclusiveTouchGestureHandler: NativeViewGestureHandler;
+
+    set exclusiveTouch(value) {
+        this.style['exclusiveTouch'] = value;
+    }
+    get exclusiveTouch() {
+        return this.style['exclusiveTouch'];
+    }
+    initNativeView() {
+        if (this.nativeView) {
+            this.nativeView.nsView = new WeakRef(this);
+        }
+        this.notify({ eventName: ViewInitEvent, object: this });
+    }
+    disposeNativeView() {
+        if (this.nativeView) {
+            this.nativeView.nsView = null;
+        }
+        if (this.exclusiveTouchGestureHandler) {
+            this.exclusiveTouchGestureHandler.detachFromView();
+            this.exclusiveTouchGestureHandler = null;
+        }
+        this.notify({ eventName: ViewDisposeEvent, object: this });
+    }
+    [exclusiveTouchProperty.setNative](value: boolean) {
+        // console.log('exclusiveTouchProperty', this, value);
+        if (value) {
+            if (!this.exclusiveTouchGestureHandler) {
+                const gestureHandler = Manager.getInstance().createGestureHandler(HandlerType.NATIVE_VIEW, NATIVE_GESTURE_TAG++, {
+                    disallowInterruption: true,
+                    shouldActivateOnStart: false,
+                    shouldCancelWhenOutside: false,
+                });
+                this.exclusiveTouchGestureHandler = gestureHandler as any;
+            }
+            this.exclusiveTouchGestureHandler.attachToView(this);
+        } else if (this.exclusiveTouchGestureHandler) {
+            this.exclusiveTouchGestureHandler.detachFromView();
+        }
+    }
+}
+
+exclusiveTouchProperty.register(Style);
+
+let installed = false;
+export function overrideViewBase() {
+    const NSView = require('@nativescript/core/ui/core/view').View;
+    applyMixins(NSView, [ViewGestureExtended]);
+}
+
+export function install(overrideNGestures?: boolean) {
+    if (installed) {
+        return;
+    }
+    installed = true;
+    overrideViewBase();
+}

package/.history/src/gesturehandler.d_20210422150412.ts

@@ -0,0 +1,154 @@
+/* eslint-disable no-redeclare */
+import { Observable } from '@nativescript/core/data/observable';
+import { View } from '@nativescript/core';
+import { HandlerType, OptionsTypeMap, TypeMap } from './gesturehandler.common';
+
+export { GestureState, GestureHandlerStateEvent, GestureHandlerTouchEvent, GestureStateEventData, GestureTouchEventData, HandlerType } from './gesturehandler.common';
+// export * from './gesturehandler.ios';
+
+export enum FlingDirection {
+    DIRECTION_LEFT,
+    DIRECTION_UP,
+    DIRECTION_DOWN,
+    DIRECTION_RIGHT,
+}
+
+export abstract class BaseNative<T, U extends {}> extends Observable {
+    options?: U;
+    native: T;
+    constructor(options?: U, native?: T);
+    initNativeView(native: T, options: U): void;
+    getNative(): T;
+    log(...args);
+}
+export interface NativePropertyOptions {
+    converter?: {
+        fromNative: Function;
+        toNative: Function;
+    };
+    defaultValue?: any;
+    nativeGetterName?: string;
+    nativeSetterName?: string;
+    getConverter?: Function;
+    ios?: {
+        nativeGetterName?: string;
+        nativeSetterName?: string;
+    };
+    android?: {
+        nativeGetterName?: string;
+        nativeSetterName?: string;
+    };
+}
+
+export declare function nativeProperty(target: any, k?, desc?: PropertyDescriptor): any;
+export declare function nativeProperty(options: NativePropertyOptions): (target: any, k?, desc?: PropertyDescriptor) => any;
+export declare function nativeProperty(...args);
+
+export interface HandlerOptions {
+    [k: string]: any;
+    enabled?: boolean;
+    shouldCancelWhenOutside?: boolean;
+    waitFor?: number[];
+    simultaneousHandlers?: number[];
+    /**
+     * optional property to access the View nativeView
+     *
+     * @memberof HandlerOptions
+     */
+    nativeGetterKey?: string;
+}
+export abstract class Handler<T, U extends HandlerOptions> extends BaseNative<T, U> {
+    enabled: boolean;
+    shouldCancelWhenOutside: boolean;
+    setTag(tag: number);
+    getTag(): number;
+    getView(): View;
+    cancel();
+    attachToView(view: View);
+    detachFromView(view?: View);
+}
+export interface TapGestureHandlerOptions extends HandlerOptions {
+    numberOfTaps?: number;
+    maxDurationMs?: number;
+    maxDelayMs?: number;
+    maxDeltaX?: number;
+    maxDeltaY?: number;
+    maxDist?: number;
+    minPointers?: number;
+}
+
+export class TapGestureHandler extends Handler<any, TapGestureHandlerOptions> {
+    numberOfTaps: number;
+    maxDurationMs: number;
+    maxDelayMs: number;
+    maxDeltaX: number;
+    maxDeltaY: number;
+    maxDist: number;
+    minPointers: number;
+}
+export interface PanGestureHandlerOptions extends HandlerOptions {
+    minDist?: number;
+    activeOffsetXStart?: number;
+    activeOffsetXEnd?: number;
+    failOffsetXStart?: number;
+    failOffsetXEnd?: number;
+    activeOffsetYStart?: number;
+    activeOffsetYEnd?: number;
+    failOffsetYStart?: number;
+    failOffsetYEnd?: number;
+}
+
+export class PanGestureHandler extends Handler<any, PanGestureHandlerOptions> {
+    minDist: number;
+    activeOffsetXStart: number;
+    activeOffsetXEnd: number;
+    failOffsetXStart: number;
+    failOffsetXEnd: number;
+    activeOffsetYStart: number;
+    activeOffsetYEnd: number;
+    failOffsetYStart: number;
+    failOffsetYEnd: number;
+}
+export interface NativeViewGestureHandlerOptions extends HandlerOptions {
+    shouldActivateOnStart?: boolean;
+    disallowInterruption?: boolean;
+}
+export class NativeViewGestureHandler extends Handler<any, NativeViewGestureHandlerOptions> {
+    shouldActivateOnStart: boolean;
+    disallowInterruption: boolean;
+}
+export interface LongPressGestureHandlerOptions extends HandlerOptions {
+    maxDist?: number;
+    minDurationMs?: number;
+}
+export class LongPressGestureHandler extends Handler<any, LongPressGestureHandlerOptions> {
+    maxDist: number;
+    minDurationMs: number;
+}
+export interface FlingGestureHandlerOptions extends HandlerOptions {
+    numberOfPointers?: number;
+    direction?: number;
+}
+export class FlingGestureHandler extends Handler<any, FlingGestureHandlerOptions> {
+    numberOfPointers: number;
+    direction: number;
+}
+export interface PinchGestureHandlerOptions extends HandlerOptions {}
+export class PinchGestureHandler extends Handler<any, PinchGestureHandlerOptions> {}
+export interface RotationGestureHandlerOptions extends HandlerOptions {}
+export class RotationGestureHandler extends Handler<any, RotationGestureHandlerOptions> {}
+
+export interface ForceTouchGestureHandlerOptions extends HandlerOptions {
+    minForce?: number;
+    maxForce?: number;
+}
+export class ForceTouchGestureHandler extends Handler<any, ForceTouchGestureHandlerOptions> {
+    minForce: number;
+    maxForce: number;
+}
+
+export class Manager extends Observable {
+    static getInstance(): Manager;
+    createGestureHandler<T extends HandlerType>(handlerName: T, handlerTag: number, config?: OptionsTypeMap[T]): TypeMap[T];
+}
+export function install(overrideNGestures?: boolean);