react-native-gesture-handler 1.10.3 → 2.2.0

package/lib/commonjs/handlers/gestures/flingGesture.js

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FlingGesture = void 0;
+
+var _gesture = require("./gesture");
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+class FlingGesture extends _gesture.BaseGesture {
+  constructor() {
+    super();
+
+    _defineProperty(this, "config", {});
+
+    this.handlerName = 'FlingGestureHandler';
+  }
+
+  numberOfPointers(pointers) {
+    this.config.numberOfPointers = pointers;
+    return this;
+  }
+
+  direction(direction) {
+    this.config.direction = direction;
+    return this;
+  }
+
+}
+
+exports.FlingGesture = FlingGesture;
+//# sourceMappingURL=flingGesture.js.map

package/lib/commonjs/handlers/gestures/flingGesture.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["flingGesture.ts"],"names":["FlingGesture","BaseGesture","constructor","handlerName","numberOfPointers","pointers","config","direction"],"mappings":";;;;;;;AAAA;;;;AAMO,MAAMA,YAAN,SAA2BC,oBAA3B,CAAwE;AAG7EC,EAAAA,WAAW,GAAG;AACZ;;AADY,oCAF0C,EAE1C;;AAGZ,SAAKC,WAAL,GAAmB,qBAAnB;AACD;;AAEDC,EAAAA,gBAAgB,CAACC,QAAD,EAAmB;AACjC,SAAKC,MAAL,CAAYF,gBAAZ,GAA+BC,QAA/B;AACA,WAAO,IAAP;AACD;;AAEDE,EAAAA,SAAS,CAACA,SAAD,EAAoB;AAC3B,SAAKD,MAAL,CAAYC,SAAZ,GAAwBA,SAAxB;AACA,WAAO,IAAP;AACD;;AAjB4E","sourcesContent":["import { BaseGesture, BaseGestureConfig } from './gesture';\nimport {\n  FlingGestureConfig,\n  FlingGestureHandlerEventPayload,\n} from '../FlingGestureHandler';\n\nexport class FlingGesture extends BaseGesture<FlingGestureHandlerEventPayload> {\n  public config: BaseGestureConfig & FlingGestureConfig = {};\n\n  constructor() {\n    super();\n\n    this.handlerName = 'FlingGestureHandler';\n  }\n\n  numberOfPointers(pointers: number) {\n    this.config.numberOfPointers = pointers;\n    return this;\n  }\n\n  direction(direction: number) {\n    this.config.direction = direction;\n    return this;\n  }\n}\n\nexport type FlingGestureType = InstanceType<typeof FlingGesture>;\n"]}

package/lib/commonjs/handlers/gestures/forceTouchGesture.js

@@ -0,0 +1,65 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ForceTouchGesture = void 0;
+
+var _gesture = require("./gesture");
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function changeEventCalculator(current, previous) {
+  'worklet';
+
+  let changePayload;
+
+  if (previous === undefined) {
+    changePayload = {
+      forceChange: current.force
+    };
+  } else {
+    changePayload = {
+      forceChange: current.force - previous.force
+    };
+  }
+
+  return { ...current,
+    ...changePayload
+  };
+}
+
+class ForceTouchGesture extends _gesture.ContinousBaseGesture {
+  constructor() {
+    super();
+
+    _defineProperty(this, "config", {});
+
+    this.handlerName = 'ForceTouchGestureHandler';
+  }
+
+  minForce(force) {
+    this.config.minForce = force;
+    return this;
+  }
+
+  maxForce(force) {
+    this.config.maxForce = force;
+    return this;
+  }
+
+  feedbackOnActivation(value) {
+    this.config.feedbackOnActivation = value;
+    return this;
+  }
+
+  onChange(callback) {
+    // @ts-ignore TS being overprotective, ForceTouchGestureHandlerEventPayload is Record
+    this.handlers.changeEventCalculator = changeEventCalculator;
+    return super.onChange(callback);
+  }
+
+}
+
+exports.ForceTouchGesture = ForceTouchGesture;
+//# sourceMappingURL=forceTouchGesture.js.map

package/lib/commonjs/handlers/gestures/forceTouchGesture.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["forceTouchGesture.ts"],"names":["changeEventCalculator","current","previous","changePayload","undefined","forceChange","force","ForceTouchGesture","ContinousBaseGesture","constructor","handlerName","minForce","config","maxForce","feedbackOnActivation","value","onChange","callback","handlers"],"mappings":";;;;;;;AAAA;;;;AAWA,SAASA,qBAAT,CACEC,OADF,EAEEC,QAFF,EAGE;AACA;;AACA,MAAIC,aAAJ;;AACA,MAAID,QAAQ,KAAKE,SAAjB,EAA4B;AAC1BD,IAAAA,aAAa,GAAG;AACdE,MAAAA,WAAW,EAAEJ,OAAO,CAACK;AADP,KAAhB;AAGD,GAJD,MAIO;AACLH,IAAAA,aAAa,GAAG;AACdE,MAAAA,WAAW,EAAEJ,OAAO,CAACK,KAAR,GAAgBJ,QAAQ,CAACI;AADxB,KAAhB;AAGD;;AAED,SAAO,EAAE,GAAGL,OAAL;AAAc,OAAGE;AAAjB,GAAP;AACD;;AAEM,MAAMI,iBAAN,SAAgCC,6BAAhC,CAGL;AAGAC,EAAAA,WAAW,GAAG;AACZ;;AADY,oCAF+C,EAE/C;;AAGZ,SAAKC,WAAL,GAAmB,0BAAnB;AACD;;AAEDC,EAAAA,QAAQ,CAACL,KAAD,EAAgB;AACtB,SAAKM,MAAL,CAAYD,QAAZ,GAAuBL,KAAvB;AACA,WAAO,IAAP;AACD;;AAEDO,EAAAA,QAAQ,CAACP,KAAD,EAAgB;AACtB,SAAKM,MAAL,CAAYC,QAAZ,GAAuBP,KAAvB;AACA,WAAO,IAAP;AACD;;AAEDQ,EAAAA,oBAAoB,CAACC,KAAD,EAAiB;AACnC,SAAKH,MAAL,CAAYE,oBAAZ,GAAmCC,KAAnC;AACA,WAAO,IAAP;AACD;;AAEDC,EAAAA,QAAQ,CACNC,QADM,EASN;AACA;AACA,SAAKC,QAAL,CAAclB,qBAAd,GAAsCA,qBAAtC;AACA,WAAO,MAAMgB,QAAN,CAAeC,QAAf,CAAP;AACD;;AArCD","sourcesContent":["import { BaseGestureConfig, ContinousBaseGesture } from './gesture';\nimport {\n  ForceTouchGestureConfig,\n  ForceTouchGestureHandlerEventPayload,\n} from '../ForceTouchGestureHandler';\nimport { GestureUpdateEvent } from '../gestureHandlerCommon';\n\ntype ForceTouchGestureChangeEventPayload = {\n  forceChange: number;\n};\n\nfunction changeEventCalculator(\n  current: GestureUpdateEvent<ForceTouchGestureHandlerEventPayload>,\n  previous?: GestureUpdateEvent<ForceTouchGestureHandlerEventPayload>\n) {\n  'worklet';\n  let changePayload: ForceTouchGestureChangeEventPayload;\n  if (previous === undefined) {\n    changePayload = {\n      forceChange: current.force,\n    };\n  } else {\n    changePayload = {\n      forceChange: current.force - previous.force,\n    };\n  }\n\n  return { ...current, ...changePayload };\n}\n\nexport class ForceTouchGesture extends ContinousBaseGesture<\n  ForceTouchGestureHandlerEventPayload,\n  ForceTouchGestureChangeEventPayload\n> {\n  public config: BaseGestureConfig & ForceTouchGestureConfig = {};\n\n  constructor() {\n    super();\n\n    this.handlerName = 'ForceTouchGestureHandler';\n  }\n\n  minForce(force: number) {\n    this.config.minForce = force;\n    return this;\n  }\n\n  maxForce(force: number) {\n    this.config.maxForce = force;\n    return this;\n  }\n\n  feedbackOnActivation(value: boolean) {\n    this.config.feedbackOnActivation = value;\n    return this;\n  }\n\n  onChange(\n    callback: (\n      event: GestureUpdateEvent<\n        GestureUpdateEvent<\n          ForceTouchGestureHandlerEventPayload &\n            ForceTouchGestureChangeEventPayload\n        >\n      >\n    ) => void\n  ) {\n    // @ts-ignore TS being overprotective, ForceTouchGestureHandlerEventPayload is Record\n    this.handlers.changeEventCalculator = changeEventCalculator;\n    return super.onChange(callback);\n  }\n}\n\nexport type ForceTouchGestureType = InstanceType<typeof ForceTouchGesture>;\n"]}

package/lib/commonjs/handlers/gestures/gesture.js

@@ -0,0 +1,193 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ContinousBaseGesture = exports.BaseGesture = exports.Gesture = exports.CALLBACK_TYPE = void 0;
+
+var _handlersRegistry = require("../handlersRegistry");
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+const CALLBACK_TYPE = {
+  UNDEFINED: 0,
+  BEGAN: 1,
+  START: 2,
+  UPDATE: 3,
+  CHANGE: 4,
+  END: 5,
+  FINALIZE: 6,
+  TOUCHES_DOWN: 7,
+  TOUCHES_MOVE: 8,
+  TOUCHES_UP: 9,
+  TOUCHES_CANCELLED: 10
+}; // Allow using CALLBACK_TYPE as object and type
+// eslint-disable-next-line @typescript-eslint/no-redeclare
+
+exports.CALLBACK_TYPE = CALLBACK_TYPE;
+
+class Gesture {}
+
+exports.Gesture = Gesture;
+
+class BaseGesture extends Gesture {
+  constructor(...args) {
+    super(...args);
+
+    _defineProperty(this, "handlerTag", -1);
+
+    _defineProperty(this, "handlerName", '');
+
+    _defineProperty(this, "config", {});
+
+    _defineProperty(this, "handlers", {
+      handlerTag: -1,
+      isWorklet: [false, false, false, false]
+    });
+  }
+
+  addDependency(key, gesture) {
+    const value = this.config[key];
+    this.config[key] = value ? Array().concat(value, gesture) : [gesture];
+  }
+
+  withRef(ref) {
+    this.config.ref = ref;
+    return this;
+  } // eslint-disable-next-line @typescript-eslint/ban-types
+
+
+  isWorklet(callback) {
+    //@ts-ignore if callback is a worklet, the property will be available, if not then the check will return false
+    return callback.__workletHash !== undefined;
+  }
+
+  onBegin(callback) {
+    this.handlers.onBegin = callback;
+    this.handlers.isWorklet[CALLBACK_TYPE.BEGAN] = this.isWorklet(callback);
+    return this;
+  }
+
+  onStart(callback) {
+    this.handlers.onStart = callback;
+    this.handlers.isWorklet[CALLBACK_TYPE.START] = this.isWorklet(callback);
+    return this;
+  }
+
+  onEnd(callback) {
+    this.handlers.onEnd = callback; //@ts-ignore if callback is a worklet, the property will be available, if not then the check will return false
+
+    this.handlers.isWorklet[CALLBACK_TYPE.END] = this.isWorklet(callback);
+    return this;
+  }
+
+  onFinalize(callback) {
+    this.handlers.onFinalize = callback; //@ts-ignore if callback is a worklet, the property will be available, if not then the check will return false
+
+    this.handlers.isWorklet[CALLBACK_TYPE.FINALIZE] = this.isWorklet(callback);
+    return this;
+  }
+
+  onTouchesDown(callback) {
+    this.config.needsPointerData = true;
+    this.handlers.onTouchesDown = callback;
+    this.handlers.isWorklet[CALLBACK_TYPE.TOUCHES_DOWN] = this.isWorklet(callback);
+    return this;
+  }
+
+  onTouchesMove(callback) {
+    this.config.needsPointerData = true;
+    this.handlers.onTouchesMove = callback;
+    this.handlers.isWorklet[CALLBACK_TYPE.TOUCHES_MOVE] = this.isWorklet(callback);
+    return this;
+  }
+
+  onTouchesUp(callback) {
+    this.config.needsPointerData = true;
+    this.handlers.onTouchesUp = callback;
+    this.handlers.isWorklet[CALLBACK_TYPE.TOUCHES_UP] = this.isWorklet(callback);
+    return this;
+  }
+
+  onTouchesCancelled(callback) {
+    this.config.needsPointerData = true;
+    this.handlers.onTouchesCancelled = callback;
+    this.handlers.isWorklet[CALLBACK_TYPE.TOUCHES_CANCELLED] = this.isWorklet(callback);
+    return this;
+  }
+
+  enabled(enabled) {
+    this.config.enabled = enabled;
+    return this;
+  }
+
+  shouldCancelWhenOutside(value) {
+    this.config.shouldCancelWhenOutside = value;
+    return this;
+  }
+
+  hitSlop(hitSlop) {
+    this.config.hitSlop = hitSlop;
+    return this;
+  }
+
+  simultaneousWithExternalGesture(...gestures) {
+    for (const gesture of gestures) {
+      this.addDependency('simultaneousWith', gesture);
+    }
+
+    return this;
+  }
+
+  requireExternalGestureToFail(...gestures) {
+    for (const gesture of gestures) {
+      this.addDependency('requireToFail', gesture);
+    }
+
+    return this;
+  }
+
+  initialize() {
+    this.handlerTag = (0, _handlersRegistry.getNextHandlerTag)();
+    this.handlers = { ...this.handlers,
+      handlerTag: this.handlerTag
+    };
+
+    if (this.config.ref) {
+      this.config.ref.current = this;
+    }
+  }
+
+  toGestureArray() {
+    return [this];
+  } // eslint-disable-next-line @typescript-eslint/no-empty-function
+
+
+  prepare() {}
+
+}
+
+exports.BaseGesture = BaseGesture;
+
+class ContinousBaseGesture extends BaseGesture {
+  onUpdate(callback) {
+    this.handlers.onUpdate = callback;
+    this.handlers.isWorklet[CALLBACK_TYPE.UPDATE] = this.isWorklet(callback);
+    return this;
+  }
+
+  onChange(callback) {
+    this.handlers.onChange = callback;
+    this.handlers.isWorklet[CALLBACK_TYPE.CHANGE] = this.isWorklet(callback);
+    return this;
+  }
+
+  manualActivation(manualActivation) {
+    this.config.manualActivation = manualActivation;
+    return this;
+  }
+
+}
+
+exports.ContinousBaseGesture = ContinousBaseGesture;
+//# sourceMappingURL=gesture.js.map

package/lib/commonjs/handlers/gestures/gesture.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["gesture.ts"],"names":["CALLBACK_TYPE","UNDEFINED","BEGAN","START","UPDATE","CHANGE","END","FINALIZE","TOUCHES_DOWN","TOUCHES_MOVE","TOUCHES_UP","TOUCHES_CANCELLED","Gesture","BaseGesture","handlerTag","isWorklet","addDependency","key","gesture","value","config","Array","concat","withRef","ref","callback","__workletHash","undefined","onBegin","handlers","onStart","onEnd","onFinalize","onTouchesDown","needsPointerData","onTouchesMove","onTouchesUp","onTouchesCancelled","enabled","shouldCancelWhenOutside","hitSlop","simultaneousWithExternalGesture","gestures","requireExternalGestureToFail","initialize","current","toGestureArray","prepare","ContinousBaseGesture","onUpdate","onChange","manualActivation"],"mappings":"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","sourcesContent":["import { FlingGestureHandlerEventPayload } from '../FlingGestureHandler';\nimport { ForceTouchGestureHandlerEventPayload } from '../ForceTouchGestureHandler';\nimport {\n  HitSlop,\n  CommonGestureConfig,\n  GestureTouchEvent,\n  GestureStateChangeEvent,\n  GestureUpdateEvent,\n} from '../gestureHandlerCommon';\nimport { getNextHandlerTag } from '../handlersRegistry';\nimport { GestureStateManagerType } from './gestureStateManager';\nimport { LongPressGestureHandlerEventPayload } from '../LongPressGestureHandler';\nimport { PanGestureHandlerEventPayload } from '../PanGestureHandler';\nimport { PinchGestureHandlerEventPayload } from '../PinchGestureHandler';\nimport { RotationGestureHandlerEventPayload } from '../RotationGestureHandler';\nimport { TapGestureHandlerEventPayload } from '../TapGestureHandler';\nimport { NativeViewGestureHandlerPayload } from '../NativeViewGestureHandler';\n\nexport type GestureType =\n  | BaseGesture<Record<string, unknown>>\n  | BaseGesture<Record<string, never>>\n  | BaseGesture<TapGestureHandlerEventPayload>\n  | BaseGesture<PanGestureHandlerEventPayload>\n  | BaseGesture<LongPressGestureHandlerEventPayload>\n  | BaseGesture<RotationGestureHandlerEventPayload>\n  | BaseGesture<PinchGestureHandlerEventPayload>\n  | BaseGesture<FlingGestureHandlerEventPayload>\n  | BaseGesture<ForceTouchGestureHandlerEventPayload>\n  | BaseGesture<NativeViewGestureHandlerPayload>;\n\nexport type GestureRef =\n  | number\n  | GestureType\n  | React.RefObject<GestureType | undefined>\n  | React.RefObject<React.ComponentType | undefined>; // allow adding a ref to a gesture handler\nexport interface BaseGestureConfig\n  extends CommonGestureConfig,\n    Record<string, unknown> {\n  ref?: React.MutableRefObject<GestureType | undefined>;\n  requireToFail?: GestureRef[];\n  simultaneousWith?: GestureRef[];\n  needsPointerData?: boolean;\n  manualActivation?: boolean;\n}\n\ntype TouchEventHandlerType = (\n  event: GestureTouchEvent,\n  stateManager: GestureStateManagerType\n) => void;\n\nexport type HandlerCallbacks<EventPayloadT extends Record<string, unknown>> = {\n  handlerTag: number;\n  onBegin?: (event: GestureStateChangeEvent<EventPayloadT>) => void;\n  onStart?: (event: GestureStateChangeEvent<EventPayloadT>) => void;\n  onEnd?: (\n    event: GestureStateChangeEvent<EventPayloadT>,\n    success: boolean\n  ) => void;\n  onFinalize?: (\n    event: GestureStateChangeEvent<EventPayloadT>,\n    success: boolean\n  ) => void;\n  onUpdate?: (event: GestureUpdateEvent<EventPayloadT>) => void;\n  onChange?: (event: any) => void;\n  onTouchesDown?: TouchEventHandlerType;\n  onTouchesMove?: TouchEventHandlerType;\n  onTouchesUp?: TouchEventHandlerType;\n  onTouchesCancelled?: TouchEventHandlerType;\n  changeEventCalculator?: (\n    current: GestureUpdateEvent<Record<string, unknown>>,\n    previous?: GestureUpdateEvent<Record<string, unknown>>\n  ) => GestureUpdateEvent<Record<string, unknown>>;\n  isWorklet: boolean[];\n};\n\nexport const CALLBACK_TYPE = {\n  UNDEFINED: 0,\n  BEGAN: 1,\n  START: 2,\n  UPDATE: 3,\n  CHANGE: 4,\n  END: 5,\n  FINALIZE: 6,\n  TOUCHES_DOWN: 7,\n  TOUCHES_MOVE: 8,\n  TOUCHES_UP: 9,\n  TOUCHES_CANCELLED: 10,\n} as const;\n\n// Allow using CALLBACK_TYPE as object and type\n// eslint-disable-next-line @typescript-eslint/no-redeclare\nexport type CALLBACK_TYPE = typeof CALLBACK_TYPE[keyof typeof CALLBACK_TYPE];\n\nexport abstract class Gesture {\n  /**\n   * Return array of gestures, providing the same interface for creating and updating\n   * handlers, no matter which object was used to create gesture instance.\n   */\n  abstract toGestureArray(): GestureType[];\n\n  /**\n   * Assign handlerTag to the gesture instance and set ref.current (if a ref is set)\n   */\n  abstract initialize(): void;\n\n  /**\n   * Make sure that values of properties defining relations are arrays. Do any necessary\n   * preprocessing required to configure relations between handlers. Called just before\n   * updating the handler on the native side.\n   */\n  abstract prepare(): void;\n}\n\nexport abstract class BaseGesture<\n  EventPayloadT extends Record<string, unknown>\n> extends Gesture {\n  public handlerTag = -1;\n  public handlerName = '';\n  public config: BaseGestureConfig = {};\n  public handlers: HandlerCallbacks<EventPayloadT> = {\n    handlerTag: -1,\n    isWorklet: [false, false, false, false],\n  };\n\n  private addDependency(\n    key: 'simultaneousWith' | 'requireToFail',\n    gesture: Exclude<GestureRef, number>\n  ) {\n    const value = this.config[key];\n    this.config[key] = value\n      ? Array<GestureRef>().concat(value, gesture)\n      : [gesture];\n  }\n\n  withRef(ref: React.MutableRefObject<GestureType | undefined>) {\n    this.config.ref = ref;\n    return this;\n  }\n\n  // eslint-disable-next-line @typescript-eslint/ban-types\n  protected isWorklet(callback: Function) {\n    //@ts-ignore if callback is a worklet, the property will be available, if not then the check will return false\n    return callback.__workletHash !== undefined;\n  }\n\n  onBegin(callback: (event: GestureStateChangeEvent<EventPayloadT>) => void) {\n    this.handlers.onBegin = callback;\n    this.handlers.isWorklet[CALLBACK_TYPE.BEGAN] = this.isWorklet(callback);\n    return this;\n  }\n\n  onStart(callback: (event: GestureStateChangeEvent<EventPayloadT>) => void) {\n    this.handlers.onStart = callback;\n    this.handlers.isWorklet[CALLBACK_TYPE.START] = this.isWorklet(callback);\n    return this;\n  }\n\n  onEnd(\n    callback: (\n      event: GestureStateChangeEvent<EventPayloadT>,\n      success: boolean\n    ) => void\n  ) {\n    this.handlers.onEnd = callback;\n    //@ts-ignore if callback is a worklet, the property will be available, if not then the check will return false\n    this.handlers.isWorklet[CALLBACK_TYPE.END] = this.isWorklet(callback);\n    return this;\n  }\n\n  onFinalize(\n    callback: (\n      event: GestureStateChangeEvent<EventPayloadT>,\n      success: boolean\n    ) => void\n  ) {\n    this.handlers.onFinalize = callback;\n    //@ts-ignore if callback is a worklet, the property will be available, if not then the check will return false\n    this.handlers.isWorklet[CALLBACK_TYPE.FINALIZE] = this.isWorklet(callback);\n    return this;\n  }\n\n  onTouchesDown(callback: TouchEventHandlerType) {\n    this.config.needsPointerData = true;\n    this.handlers.onTouchesDown = callback;\n    this.handlers.isWorklet[CALLBACK_TYPE.TOUCHES_DOWN] = this.isWorklet(\n      callback\n    );\n\n    return this;\n  }\n\n  onTouchesMove(callback: TouchEventHandlerType) {\n    this.config.needsPointerData = true;\n    this.handlers.onTouchesMove = callback;\n    this.handlers.isWorklet[CALLBACK_TYPE.TOUCHES_MOVE] = this.isWorklet(\n      callback\n    );\n\n    return this;\n  }\n\n  onTouchesUp(callback: TouchEventHandlerType) {\n    this.config.needsPointerData = true;\n    this.handlers.onTouchesUp = callback;\n    this.handlers.isWorklet[CALLBACK_TYPE.TOUCHES_UP] = this.isWorklet(\n      callback\n    );\n\n    return this;\n  }\n\n  onTouchesCancelled(callback: TouchEventHandlerType) {\n    this.config.needsPointerData = true;\n    this.handlers.onTouchesCancelled = callback;\n    this.handlers.isWorklet[CALLBACK_TYPE.TOUCHES_CANCELLED] = this.isWorklet(\n      callback\n    );\n\n    return this;\n  }\n\n  enabled(enabled: boolean) {\n    this.config.enabled = enabled;\n    return this;\n  }\n\n  shouldCancelWhenOutside(value: boolean) {\n    this.config.shouldCancelWhenOutside = value;\n    return this;\n  }\n\n  hitSlop(hitSlop: HitSlop) {\n    this.config.hitSlop = hitSlop;\n    return this;\n  }\n\n  simultaneousWithExternalGesture(...gestures: Exclude<GestureRef, number>[]) {\n    for (const gesture of gestures) {\n      this.addDependency('simultaneousWith', gesture);\n    }\n    return this;\n  }\n\n  requireExternalGestureToFail(...gestures: Exclude<GestureRef, number>[]) {\n    for (const gesture of gestures) {\n      this.addDependency('requireToFail', gesture);\n    }\n    return this;\n  }\n\n  initialize() {\n    this.handlerTag = getNextHandlerTag();\n    this.handlers = { ...this.handlers, handlerTag: this.handlerTag };\n\n    if (this.config.ref) {\n      this.config.ref.current = this as GestureType;\n    }\n  }\n\n  toGestureArray(): GestureType[] {\n    return [this as GestureType];\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-empty-function\n  prepare() {}\n}\n\nexport abstract class ContinousBaseGesture<\n  EventPayloadT extends Record<string, unknown>,\n  EventChangePayloadT extends Record<string, unknown>\n> extends BaseGesture<EventPayloadT> {\n  onUpdate(callback: (event: GestureUpdateEvent<EventPayloadT>) => void) {\n    this.handlers.onUpdate = callback;\n    this.handlers.isWorklet[CALLBACK_TYPE.UPDATE] = this.isWorklet(callback);\n    return this;\n  }\n\n  onChange(\n    callback: (\n      event: GestureUpdateEvent<EventPayloadT & EventChangePayloadT>\n    ) => void\n  ) {\n    this.handlers.onChange = callback;\n    this.handlers.isWorklet[CALLBACK_TYPE.CHANGE] = this.isWorklet(callback);\n    return this;\n  }\n\n  manualActivation(manualActivation: boolean) {\n    this.config.manualActivation = manualActivation;\n    return this;\n  }\n}\n"]}

package/lib/commonjs/handlers/gestures/gestureComposition.js

@@ -0,0 +1,94 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ExclusiveGesture = exports.SimultaneousGesture = exports.ComposedGesture = void 0;
+
+var _gesture = require("./gesture");
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function extendRelation(currentRelation, extendWith) {
+  if (currentRelation === undefined) {
+    return [...extendWith];
+  } else {
+    return [...currentRelation, ...extendWith];
+  }
+}
+
+class ComposedGesture extends _gesture.Gesture {
+  constructor(...gestures) {
+    super();
+
+    _defineProperty(this, "gestures", []);
+
+    _defineProperty(this, "simultaneousGestures", []);
+
+    _defineProperty(this, "requireGesturesToFail", []);
+
+    this.gestures = gestures;
+  }
+
+  prepareSingleGesture(gesture, simultaneousGestures, requireGesturesToFail) {
+    if (gesture instanceof _gesture.BaseGesture) {
+      const newConfig = { ...gesture.config
+      };
+      newConfig.simultaneousWith = extendRelation(newConfig.simultaneousWith, simultaneousGestures);
+      newConfig.requireToFail = extendRelation(newConfig.requireToFail, requireGesturesToFail);
+      gesture.config = newConfig;
+    } else if (gesture instanceof ComposedGesture) {
+      gesture.simultaneousGestures = simultaneousGestures;
+      gesture.requireGesturesToFail = requireGesturesToFail;
+      gesture.prepare();
+    }
+  }
+
+  prepare() {
+    for (const gesture of this.gestures) {
+      this.prepareSingleGesture(gesture, this.simultaneousGestures, this.requireGesturesToFail);
+    }
+  }
+
+  initialize() {
+    for (const gesture of this.gestures) {
+      gesture.initialize();
+    }
+  }
+
+  toGestureArray() {
+    return this.gestures.flatMap(gesture => gesture.toGestureArray());
+  }
+
+}
+
+exports.ComposedGesture = ComposedGesture;
+
+class SimultaneousGesture extends ComposedGesture {
+  prepare() {
+    const simultaneousArray = this.gestures.flatMap(gesture => gesture.toGestureArray()).concat(this.simultaneousGestures);
+
+    for (const gesture of this.gestures) {
+      this.prepareSingleGesture(gesture, simultaneousArray, this.requireGesturesToFail);
+    }
+  }
+
+}
+
+exports.SimultaneousGesture = SimultaneousGesture;
+
+class ExclusiveGesture extends ComposedGesture {
+  prepare() {
+    const gestureArrays = this.gestures.map(gesture => gesture.toGestureArray());
+    let requireToFail = [];
+
+    for (let i = 0; i < this.gestures.length; i++) {
+      this.prepareSingleGesture(this.gestures[i], this.simultaneousGestures, this.requireGesturesToFail.concat(requireToFail));
+      requireToFail = requireToFail.concat(gestureArrays[i]);
+    }
+  }
+
+}
+
+exports.ExclusiveGesture = ExclusiveGesture;
+//# sourceMappingURL=gestureComposition.js.map

package/lib/commonjs/handlers/gestures/gestureComposition.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["gestureComposition.ts"],"names":["extendRelation","currentRelation","extendWith","undefined","ComposedGesture","Gesture","constructor","gestures","prepareSingleGesture","gesture","simultaneousGestures","requireGesturesToFail","BaseGesture","newConfig","config","simultaneousWith","requireToFail","prepare","initialize","toGestureArray","flatMap","SimultaneousGesture","simultaneousArray","concat","ExclusiveGesture","gestureArrays","map","i","length"],"mappings":"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","sourcesContent":["import { BaseGesture, Gesture, GestureRef, GestureType } from './gesture';\n\nfunction extendRelation(\n  currentRelation: GestureRef[] | undefined,\n  extendWith: GestureType[]\n) {\n  if (currentRelation === undefined) {\n    return [...extendWith];\n  } else {\n    return [...currentRelation, ...extendWith];\n  }\n}\n\nexport class ComposedGesture extends Gesture {\n  protected gestures: Gesture[] = [];\n  protected simultaneousGestures: GestureType[] = [];\n  protected requireGesturesToFail: GestureType[] = [];\n\n  constructor(...gestures: Gesture[]) {\n    super();\n    this.gestures = gestures;\n  }\n\n  protected prepareSingleGesture(\n    gesture: Gesture,\n    simultaneousGestures: GestureType[],\n    requireGesturesToFail: GestureType[]\n  ) {\n    if (gesture instanceof BaseGesture) {\n      const newConfig = { ...gesture.config };\n\n      newConfig.simultaneousWith = extendRelation(\n        newConfig.simultaneousWith,\n        simultaneousGestures\n      );\n      newConfig.requireToFail = extendRelation(\n        newConfig.requireToFail,\n        requireGesturesToFail\n      );\n\n      gesture.config = newConfig;\n    } else if (gesture instanceof ComposedGesture) {\n      gesture.simultaneousGestures = simultaneousGestures;\n      gesture.requireGesturesToFail = requireGesturesToFail;\n      gesture.prepare();\n    }\n  }\n\n  prepare() {\n    for (const gesture of this.gestures) {\n      this.prepareSingleGesture(\n        gesture,\n        this.simultaneousGestures,\n        this.requireGesturesToFail\n      );\n    }\n  }\n\n  initialize() {\n    for (const gesture of this.gestures) {\n      gesture.initialize();\n    }\n  }\n\n  toGestureArray(): GestureType[] {\n    return this.gestures.flatMap((gesture) => gesture.toGestureArray());\n  }\n}\n\nexport class SimultaneousGesture extends ComposedGesture {\n  prepare() {\n    const simultaneousArray = this.gestures\n      .flatMap((gesture) => gesture.toGestureArray())\n      .concat(this.simultaneousGestures);\n\n    for (const gesture of this.gestures) {\n      this.prepareSingleGesture(\n        gesture,\n        simultaneousArray,\n        this.requireGesturesToFail\n      );\n    }\n  }\n}\n\nexport class ExclusiveGesture extends ComposedGesture {\n  prepare() {\n    const gestureArrays = this.gestures.map((gesture) =>\n      gesture.toGestureArray()\n    );\n\n    let requireToFail: GestureType[] = [];\n\n    for (let i = 0; i < this.gestures.length; i++) {\n      this.prepareSingleGesture(\n        this.gestures[i],\n        this.simultaneousGestures,\n        this.requireGesturesToFail.concat(requireToFail)\n      );\n\n      requireToFail = requireToFail.concat(gestureArrays[i]);\n    }\n  }\n}\n\nexport type ComposedGestureType = InstanceType<typeof ComposedGesture>;\nexport type RaceGestureType = ComposedGestureType;\nexport type SimultaneousGestureType = InstanceType<typeof SimultaneousGesture>;\nexport type ExclusiveGestureType = InstanceType<typeof ExclusiveGesture>;\n"]}

package/lib/commonjs/handlers/gestures/gestureObjects.js

@@ -0,0 +1,85 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.GestureObjects = void 0;
+
+var _flingGesture = require("./flingGesture");
+
+var _forceTouchGesture = require("./forceTouchGesture");
+
+var _gestureComposition = require("./gestureComposition");
+
+var _longPressGesture = require("./longPressGesture");
+
+var _panGesture = require("./panGesture");
+
+var _pinchGesture = require("./pinchGesture");
+
+var _rotationGesture = require("./rotationGesture");
+
+var _tapGesture = require("./tapGesture");
+
+var _nativeGesture = require("./nativeGesture");
+
+var _manualGesture = require("./manualGesture");
+
+const GestureObjects = {
+  Tap: () => {
+    return new _tapGesture.TapGesture();
+  },
+  Pan: () => {
+    return new _panGesture.PanGesture();
+  },
+  Pinch: () => {
+    return new _pinchGesture.PinchGesture();
+  },
+  Rotation: () => {
+    return new _rotationGesture.RotationGesture();
+  },
+  Fling: () => {
+    return new _flingGesture.FlingGesture();
+  },
+  LongPress: () => {
+    return new _longPressGesture.LongPressGesture();
+  },
+  ForceTouch: () => {
+    return new _forceTouchGesture.ForceTouchGesture();
+  },
+  Native: () => {
+    return new _nativeGesture.NativeGesture();
+  },
+  Manual: () => {
+    return new _manualGesture.ManualGesture();
+  },
+
+  /**
+   * Builds a composed gesture consisting of gestures provided as parameters.
+   * The first one that becomes active cancels the rest of gestures.
+   */
+  Race: (...gestures) => {
+    return new _gestureComposition.ComposedGesture(...gestures);
+  },
+
+  /**
+   * Builds a composed gesture that allows all base gestures to run simultaneously.
+   */
+  Simultaneous(...gestures) {
+    return new _gestureComposition.SimultaneousGesture(...gestures);
+  },
+
+  /**
+   * Builds a composed gesture where only one of the provided gestures can become active.
+   * Priority is decided through the order of gestures: the first one has higher priority
+   * than the second one, second one has higher priority than the third one, and so on.
+   * For example, to make a gesture that recognizes both single and double tap you need
+   * to call Exclusive(doubleTap, singleTap).
+   */
+  Exclusive(...gestures) {
+    return new _gestureComposition.ExclusiveGesture(...gestures);
+  }
+
+};
+exports.GestureObjects = GestureObjects;
+//# sourceMappingURL=gestureObjects.js.map

package/lib/commonjs/handlers/gestures/gestureObjects.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["gestureObjects.ts"],"names":["GestureObjects","Tap","TapGesture","Pan","PanGesture","Pinch","PinchGesture","Rotation","RotationGesture","Fling","FlingGesture","LongPress","LongPressGesture","ForceTouch","ForceTouchGesture","Native","NativeGesture","Manual","ManualGesture","Race","gestures","ComposedGesture","Simultaneous","SimultaneousGesture","Exclusive","ExclusiveGesture"],"mappings":";;;;;;;AAAA;;AACA;;AAEA;;AAKA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AAEO,MAAMA,cAAc,GAAG;AAC5BC,EAAAA,GAAG,EAAE,MAAM;AACT,WAAO,IAAIC,sBAAJ,EAAP;AACD,GAH2B;AAK5BC,EAAAA,GAAG,EAAE,MAAM;AACT,WAAO,IAAIC,sBAAJ,EAAP;AACD,GAP2B;AAS5BC,EAAAA,KAAK,EAAE,MAAM;AACX,WAAO,IAAIC,0BAAJ,EAAP;AACD,GAX2B;AAa5BC,EAAAA,QAAQ,EAAE,MAAM;AACd,WAAO,IAAIC,gCAAJ,EAAP;AACD,GAf2B;AAiB5BC,EAAAA,KAAK,EAAE,MAAM;AACX,WAAO,IAAIC,0BAAJ,EAAP;AACD,GAnB2B;AAqB5BC,EAAAA,SAAS,EAAE,MAAM;AACf,WAAO,IAAIC,kCAAJ,EAAP;AACD,GAvB2B;AAyB5BC,EAAAA,UAAU,EAAE,MAAM;AAChB,WAAO,IAAIC,oCAAJ,EAAP;AACD,GA3B2B;AA6B5BC,EAAAA,MAAM,EAAE,MAAM;AACZ,WAAO,IAAIC,4BAAJ,EAAP;AACD,GA/B2B;AAiC5BC,EAAAA,MAAM,EAAE,MAAM;AACZ,WAAO,IAAIC,4BAAJ,EAAP;AACD,GAnC2B;;AAqC5B;AACF;AACA;AACA;AACEC,EAAAA,IAAI,EAAE,CAAC,GAAGC,QAAJ,KAA4B;AAChC,WAAO,IAAIC,mCAAJ,CAAoB,GAAGD,QAAvB,CAAP;AACD,GA3C2B;;AA6C5B;AACF;AACA;AACEE,EAAAA,YAAY,CAAC,GAAGF,QAAJ,EAAyB;AACnC,WAAO,IAAIG,uCAAJ,CAAwB,GAAGH,QAA3B,CAAP;AACD,GAlD2B;;AAoD5B;AACF;AACA;AACA;AACA;AACA;AACA;AACEI,EAAAA,SAAS,CAAC,GAAGJ,QAAJ,EAAyB;AAChC,WAAO,IAAIK,oCAAJ,CAAqB,GAAGL,QAAxB,CAAP;AACD;;AA7D2B,CAAvB","sourcesContent":["import { FlingGesture } from './flingGesture';\nimport { ForceTouchGesture } from './forceTouchGesture';\nimport { Gesture } from './gesture';\nimport {\n  ComposedGesture,\n  ExclusiveGesture,\n  SimultaneousGesture,\n} from './gestureComposition';\nimport { LongPressGesture } from './longPressGesture';\nimport { PanGesture } from './panGesture';\nimport { PinchGesture } from './pinchGesture';\nimport { RotationGesture } from './rotationGesture';\nimport { TapGesture } from './tapGesture';\nimport { NativeGesture } from './nativeGesture';\nimport { ManualGesture } from './manualGesture';\n\nexport const GestureObjects = {\n  Tap: () => {\n    return new TapGesture();\n  },\n\n  Pan: () => {\n    return new PanGesture();\n  },\n\n  Pinch: () => {\n    return new PinchGesture();\n  },\n\n  Rotation: () => {\n    return new RotationGesture();\n  },\n\n  Fling: () => {\n    return new FlingGesture();\n  },\n\n  LongPress: () => {\n    return new LongPressGesture();\n  },\n\n  ForceTouch: () => {\n    return new ForceTouchGesture();\n  },\n\n  Native: () => {\n    return new NativeGesture();\n  },\n\n  Manual: () => {\n    return new ManualGesture();\n  },\n\n  /**\n   * Builds a composed gesture consisting of gestures provided as parameters.\n   * The first one that becomes active cancels the rest of gestures.\n   */\n  Race: (...gestures: Gesture[]) => {\n    return new ComposedGesture(...gestures);\n  },\n\n  /**\n   * Builds a composed gesture that allows all base gestures to run simultaneously.\n   */\n  Simultaneous(...gestures: Gesture[]) {\n    return new SimultaneousGesture(...gestures);\n  },\n\n  /**\n   * Builds a composed gesture where only one of the provided gestures can become active.\n   * Priority is decided through the order of gestures: the first one has higher priority\n   * than the second one, second one has higher priority than the third one, and so on.\n   * For example, to make a gesture that recognizes both single and double tap you need\n   * to call Exclusive(doubleTap, singleTap).\n   */\n  Exclusive(...gestures: Gesture[]) {\n    return new ExclusiveGesture(...gestures);\n  },\n};\n"]}

package/lib/commonjs/handlers/gestures/gestureStateManager.js

@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.GestureStateManager = void 0;
+
+var _reanimatedWrapper = require("./reanimatedWrapper");
+
+var _State = require("../../State");
+
+const GestureStateManager = {
+  create(handlerTag) {
+    'worklet';
+
+    return {
+      begin: () => {
+        'worklet';
+
+        if (_reanimatedWrapper.Reanimated) {
+          _reanimatedWrapper.Reanimated.setGestureState(handlerTag, _State.State.BEGAN);
+        } else {
+          console.warn('react-native-reanimated is required in order to use synchronous state management');
+        }
+      },
+      activate: () => {
+        'worklet';
+
+        if (_reanimatedWrapper.Reanimated) {
+          _reanimatedWrapper.Reanimated.setGestureState(handlerTag, _State.State.ACTIVE);
+        } else {
+          console.warn('react-native-reanimated is required in order to use synchronous state management');
+        }
+      },
+      fail: () => {
+        'worklet';
+
+        if (_reanimatedWrapper.Reanimated) {
+          _reanimatedWrapper.Reanimated.setGestureState(handlerTag, _State.State.FAILED);
+        } else {
+          console.warn('react-native-reanimated is required in order to use synchronous state management');
+        }
+      },
+      end: () => {
+        'worklet';
+
+        if (_reanimatedWrapper.Reanimated) {
+          _reanimatedWrapper.Reanimated.setGestureState(handlerTag, _State.State.END);
+        } else {
+          console.warn('react-native-reanimated is required in order to use synchronous state management');
+        }
+      }
+    };
+  }
+
+};
+exports.GestureStateManager = GestureStateManager;
+//# sourceMappingURL=gestureStateManager.js.map

package/lib/commonjs/handlers/gestures/gestureStateManager.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["gestureStateManager.ts"],"names":["GestureStateManager","create","handlerTag","begin","Reanimated","setGestureState","State","BEGAN","console","warn","activate","ACTIVE","fail","FAILED","end","END"],"mappings":";;;;;;;AAAA;;AACA;;AASO,MAAMA,mBAAmB,GAAG;AACjCC,EAAAA,MAAM,CAACC,UAAD,EAA8C;AAClD;;AACA,WAAO;AACLC,MAAAA,KAAK,EAAE,MAAM;AACX;;AACA,YAAIC,6BAAJ,EAAgB;AACdA,wCAAWC,eAAX,CAA2BH,UAA3B,EAAuCI,aAAMC,KAA7C;AACD,SAFD,MAEO;AACLC,UAAAA,OAAO,CAACC,IAAR,CACE,kFADF;AAGD;AACF,OAVI;AAYLC,MAAAA,QAAQ,EAAE,MAAM;AACd;;AACA,YAAIN,6BAAJ,EAAgB;AACdA,wCAAWC,eAAX,CAA2BH,UAA3B,EAAuCI,aAAMK,MAA7C;AACD,SAFD,MAEO;AACLH,UAAAA,OAAO,CAACC,IAAR,CACE,kFADF;AAGD;AACF,OArBI;AAuBLG,MAAAA,IAAI,EAAE,MAAM;AACV;;AACA,YAAIR,6BAAJ,EAAgB;AACdA,wCAAWC,eAAX,CAA2BH,UAA3B,EAAuCI,aAAMO,MAA7C;AACD,SAFD,MAEO;AACLL,UAAAA,OAAO,CAACC,IAAR,CACE,kFADF;AAGD;AACF,OAhCI;AAkCLK,MAAAA,GAAG,EAAE,MAAM;AACT;;AACA,YAAIV,6BAAJ,EAAgB;AACdA,wCAAWC,eAAX,CAA2BH,UAA3B,EAAuCI,aAAMS,GAA7C;AACD,SAFD,MAEO;AACLP,UAAAA,OAAO,CAACC,IAAR,CACE,kFADF;AAGD;AACF;AA3CI,KAAP;AA6CD;;AAhDgC,CAA5B","sourcesContent":["import { Reanimated } from './reanimatedWrapper';\nimport { State } from '../../State';\n\nexport interface GestureStateManagerType {\n  begin: () => void;\n  activate: () => void;\n  fail: () => void;\n  end: () => void;\n}\n\nexport const GestureStateManager = {\n  create(handlerTag: number): GestureStateManagerType {\n    'worklet';\n    return {\n      begin: () => {\n        'worklet';\n        if (Reanimated) {\n          Reanimated.setGestureState(handlerTag, State.BEGAN);\n        } else {\n          console.warn(\n            'react-native-reanimated is required in order to use synchronous state management'\n          );\n        }\n      },\n\n      activate: () => {\n        'worklet';\n        if (Reanimated) {\n          Reanimated.setGestureState(handlerTag, State.ACTIVE);\n        } else {\n          console.warn(\n            'react-native-reanimated is required in order to use synchronous state management'\n          );\n        }\n      },\n\n      fail: () => {\n        'worklet';\n        if (Reanimated) {\n          Reanimated.setGestureState(handlerTag, State.FAILED);\n        } else {\n          console.warn(\n            'react-native-reanimated is required in order to use synchronous state management'\n          );\n        }\n      },\n\n      end: () => {\n        'worklet';\n        if (Reanimated) {\n          Reanimated.setGestureState(handlerTag, State.END);\n        } else {\n          console.warn(\n            'react-native-reanimated is required in order to use synchronous state management'\n          );\n        }\n      },\n    };\n  },\n};\n"]}

package/lib/commonjs/handlers/gestures/longPressGesture.js

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.LongPressGesture = void 0;
+
+var _gesture = require("./gesture");
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+class LongPressGesture extends _gesture.BaseGesture {
+  constructor() {
+    super();
+
+    _defineProperty(this, "config", {});
+
+    this.handlerName = 'LongPressGestureHandler';
+  }
+
+  minDuration(duration) {
+    this.config.minDurationMs = duration;
+    return this;
+  }
+
+  maxDistance(distance) {
+    this.config.maxDist = distance;
+    return this;
+  }
+
+}
+
+exports.LongPressGesture = LongPressGesture;
+//# sourceMappingURL=longPressGesture.js.map

package/lib/commonjs/handlers/gestures/longPressGesture.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["longPressGesture.ts"],"names":["LongPressGesture","BaseGesture","constructor","handlerName","minDuration","duration","config","minDurationMs","maxDistance","distance","maxDist"],"mappings":";;;;;;;AAAA;;;;AAMO,MAAMA,gBAAN,SAA+BC,oBAA/B,CAAgF;AAGrFC,EAAAA,WAAW,GAAG;AACZ;;AADY,oCAF8C,EAE9C;;AAGZ,SAAKC,WAAL,GAAmB,yBAAnB;AACD;;AAEDC,EAAAA,WAAW,CAACC,QAAD,EAAmB;AAC5B,SAAKC,MAAL,CAAYC,aAAZ,GAA4BF,QAA5B;AACA,WAAO,IAAP;AACD;;AAEDG,EAAAA,WAAW,CAACC,QAAD,EAAmB;AAC5B,SAAKH,MAAL,CAAYI,OAAZ,GAAsBD,QAAtB;AACA,WAAO,IAAP;AACD;;AAjBoF","sourcesContent":["import { BaseGesture, BaseGestureConfig } from './gesture';\nimport {\n  LongPressGestureConfig,\n  LongPressGestureHandlerEventPayload,\n} from '../LongPressGestureHandler';\n\nexport class LongPressGesture extends BaseGesture<LongPressGestureHandlerEventPayload> {\n  public config: BaseGestureConfig & LongPressGestureConfig = {};\n\n  constructor() {\n    super();\n\n    this.handlerName = 'LongPressGestureHandler';\n  }\n\n  minDuration(duration: number) {\n    this.config.minDurationMs = duration;\n    return this;\n  }\n\n  maxDistance(distance: number) {\n    this.config.maxDist = distance;\n    return this;\n  }\n}\n\nexport type LongPressGestureType = InstanceType<typeof LongPressGesture>;\n"]}