react-native-gesture-handler 1.10.1 → 2.1.0

package/lib/module/handlers/createHandler.js

@@ -0,0 +1,348 @@
+var _UIManagerAny$getView, _UIManagerAny$getView2, _UIManagerAny$getCons;
+
+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; }
+
+import * as React from 'react';
+import { Platform, Touchable, UIManager, DeviceEventEmitter } from 'react-native'; // @ts-ignore - it isn't typed by TS & don't have definitelyTyped types
+
+import deepEqual from 'lodash/isEqual';
+import RNGestureHandlerModule from '../RNGestureHandlerModule';
+import { State } from '../State';
+import { handlerIDToTag, getNextHandlerTag } from './handlersRegistry';
+import { filterConfig, findNodeHandle } from './gestureHandlerCommon';
+const UIManagerAny = UIManager;
+const customGHEventsConfig = {
+  onGestureHandlerEvent: {
+    registrationName: 'onGestureHandlerEvent'
+  },
+  onGestureHandlerStateChange: {
+    registrationName: 'onGestureHandlerStateChange'
+  }
+}; // Add gesture specific events to genericDirectEventTypes object exported from UIManager
+// native module.
+// Once new event types are registered with react it is possible to dispatch these
+// events to all kind of native views.
+
+UIManagerAny.genericDirectEventTypes = { ...UIManagerAny.genericDirectEventTypes,
+  ...customGHEventsConfig
+}; // In newer versions of RN the `genericDirectEventTypes` is located in the object
+// returned by UIManager.getViewManagerConfig('getConstants') or in older RN UIManager.getConstants(), we need to add it there as well to make
+// it compatible with RN 61+
+
+const UIManagerConstants = (_UIManagerAny$getView = (_UIManagerAny$getView2 = UIManagerAny.getViewManagerConfig) === null || _UIManagerAny$getView2 === void 0 ? void 0 : _UIManagerAny$getView2.call(UIManagerAny, 'getConstants')) !== null && _UIManagerAny$getView !== void 0 ? _UIManagerAny$getView : (_UIManagerAny$getCons = UIManagerAny.getConstants) === null || _UIManagerAny$getCons === void 0 ? void 0 : _UIManagerAny$getCons.call(UIManagerAny);
+
+if (UIManagerConstants) {
+  UIManagerConstants.genericDirectEventTypes = { ...UIManagerConstants.genericDirectEventTypes,
+    ...customGHEventsConfig
+  };
+} // Wrap JS responder calls and notify gesture handler manager
+
+
+const {
+  setJSResponder: oldSetJSResponder = () => {//no operation
+  },
+  clearJSResponder: oldClearJSResponder = () => {//no operation
+  }
+} = UIManagerAny;
+
+UIManagerAny.setJSResponder = (tag, blockNativeResponder) => {
+  RNGestureHandlerModule.handleSetJSResponder(tag, blockNativeResponder);
+  oldSetJSResponder(tag, blockNativeResponder);
+};
+
+UIManagerAny.clearJSResponder = () => {
+  RNGestureHandlerModule.handleClearJSResponder();
+  oldClearJSResponder();
+};
+
+let allowTouches = true;
+const DEV_ON_ANDROID = __DEV__ && Platform.OS === 'android'; // Toggled inspector blocks touch events in order to allow inspecting on Android
+// This needs to be a global variable in order to set initial state for `allowTouches` property in Handler component
+
+if (DEV_ON_ANDROID) {
+  DeviceEventEmitter.addListener('toggleElementInspector', () => {
+    allowTouches = !allowTouches;
+  });
+}
+
+function hasUnresolvedRefs(props) {
+  // TODO(TS) - add type for extract arg
+  const extract = refs => {
+    if (!Array.isArray(refs)) {
+      return refs && refs.current === null;
+    }
+
+    return refs.some(r => r && r.current === null);
+  };
+
+  return extract(props['simultaneousHandlers']) || extract(props['waitFor']);
+}
+
+const stateToPropMappings = {
+  [State.UNDETERMINED]: undefined,
+  [State.BEGAN]: 'onBegan',
+  [State.FAILED]: 'onFailed',
+  [State.CANCELLED]: 'onCancelled',
+  [State.ACTIVE]: 'onActivated',
+  [State.END]: 'onEnded'
+};
+// TODO(TS) - make sure that BaseGestureHandlerProps doesn't need other generic parameter to work with custom properties.
+export default function createHandler({
+  name,
+  allowedProps = [],
+  config = {},
+  transformProps,
+  customNativeProps = []
+}) {
+  class Handler extends React.Component {
+    constructor(props) {
+      super(props);
+
+      _defineProperty(this, "handlerTag", void 0);
+
+      _defineProperty(this, "config", void 0);
+
+      _defineProperty(this, "propsRef", void 0);
+
+      _defineProperty(this, "viewNode", void 0);
+
+      _defineProperty(this, "viewTag", void 0);
+
+      _defineProperty(this, "updateEnqueued", null);
+
+      _defineProperty(this, "inspectorToggleListener", void 0);
+
+      _defineProperty(this, "onGestureHandlerEvent", event => {
+        if (event.nativeEvent.handlerTag === this.handlerTag) {
+          var _this$props$onGesture, _this$props;
+
+          (_this$props$onGesture = (_this$props = this.props).onGestureEvent) === null || _this$props$onGesture === void 0 ? void 0 : _this$props$onGesture.call(_this$props, event);
+        } else {
+          var _this$props$onGesture2, _this$props2;
+
+          (_this$props$onGesture2 = (_this$props2 = this.props).onGestureHandlerEvent) === null || _this$props$onGesture2 === void 0 ? void 0 : _this$props$onGesture2.call(_this$props2, event);
+        }
+      });
+
+      _defineProperty(this, "onGestureHandlerStateChange", event => {
+        if (event.nativeEvent.handlerTag === this.handlerTag) {
+          var _this$props$onHandler, _this$props3;
+
+          (_this$props$onHandler = (_this$props3 = this.props).onHandlerStateChange) === null || _this$props$onHandler === void 0 ? void 0 : _this$props$onHandler.call(_this$props3, event);
+          const state = event.nativeEvent.state;
+          const stateEventName = stateToPropMappings[state];
+          const eventHandler = stateEventName && this.props[stateEventName];
+
+          if (eventHandler && typeof eventHandler === 'function') {
+            eventHandler(event);
+          }
+        } else {
+          var _this$props$onGesture3, _this$props4;
+
+          (_this$props$onGesture3 = (_this$props4 = this.props).onGestureHandlerStateChange) === null || _this$props$onGesture3 === void 0 ? void 0 : _this$props$onGesture3.call(_this$props4, event);
+        }
+      });
+
+      _defineProperty(this, "refHandler", node => {
+        this.viewNode = node;
+        const child = React.Children.only(this.props.children); // TODO(TS) fix ref type
+
+        const {
+          ref
+        } = child;
+
+        if (ref !== null) {
+          if (typeof ref === 'function') {
+            ref(node);
+          } else {
+            ref.current = node;
+          }
+        }
+      });
+
+      _defineProperty(this, "createGestureHandler", newConfig => {
+        this.config = newConfig;
+        RNGestureHandlerModule.createGestureHandler(name, this.handlerTag, newConfig);
+      });
+
+      _defineProperty(this, "attachGestureHandler", newViewTag => {
+        this.viewTag = newViewTag;
+
+        if (Platform.OS === 'web') {
+          // typecast due to dynamic resolution, attachGestureHandler should have web version signature in this branch
+          RNGestureHandlerModule.attachGestureHandler(this.handlerTag, newViewTag, false, this.propsRef);
+        } else {
+          RNGestureHandlerModule.attachGestureHandler(this.handlerTag, newViewTag, false);
+        }
+      });
+
+      _defineProperty(this, "updateGestureHandler", newConfig => {
+        this.config = newConfig;
+        RNGestureHandlerModule.updateGestureHandler(this.handlerTag, newConfig);
+      });
+
+      this.handlerTag = getNextHandlerTag();
+      this.config = {};
+      this.propsRef = /*#__PURE__*/React.createRef();
+      this.state = {
+        allowTouches
+      };
+
+      if (props.id) {
+        if (handlerIDToTag[props.id] !== undefined) {
+          throw new Error(`Handler with ID "${props.id}" already registered`);
+        }
+
+        handlerIDToTag[props.id] = this.handlerTag;
+      }
+    }
+
+    componentDidMount() {
+      const props = this.props;
+
+      if (DEV_ON_ANDROID) {
+        this.inspectorToggleListener = DeviceEventEmitter.addListener('toggleElementInspector', () => {
+          this.setState(_ => ({
+            allowTouches
+          }));
+          this.update();
+        });
+      }
+
+      if (hasUnresolvedRefs(props)) {
+        // If there are unresolved refs (e.g. ".current" has not yet been set)
+        // passed as `simultaneousHandlers` or `waitFor`, we enqueue a call to
+        // _update method that will try to update native handler props using
+        // setImmediate. This makes it so update() function gets called after all
+        // react components are mounted and we expect the missing ref object to
+        // be resolved by then.
+        this.updateEnqueued = setImmediate(() => {
+          this.updateEnqueued = null;
+          this.update();
+        });
+      }
+
+      this.createGestureHandler(filterConfig(transformProps ? transformProps(this.props) : this.props, [...allowedProps, ...customNativeProps], config));
+      this.attachGestureHandler(findNodeHandle(this.viewNode)); // TODO(TS) - check if this can be null
+    }
+
+    componentDidUpdate() {
+      const viewTag = findNodeHandle(this.viewNode);
+
+      if (this.viewTag !== viewTag) {
+        this.attachGestureHandler(viewTag); // TODO(TS) - check interaction between _viewTag & findNodeHandle
+      }
+
+      this.update();
+    }
+
+    componentWillUnmount() {
+      var _this$inspectorToggle;
+
+      (_this$inspectorToggle = this.inspectorToggleListener) === null || _this$inspectorToggle === void 0 ? void 0 : _this$inspectorToggle.remove();
+      RNGestureHandlerModule.dropGestureHandler(this.handlerTag);
+
+      if (this.updateEnqueued) {
+        clearImmediate(this.updateEnqueued);
+      } // We can't use this.props.id directly due to TS generic type narrowing bug, see https://github.com/microsoft/TypeScript/issues/13995 for more context
+
+
+      const handlerID = this.props.id;
+
+      if (handlerID) {
+        // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+        delete handlerIDToTag[handlerID];
+      }
+    }
+
+    update() {
+      const newConfig = filterConfig(transformProps ? transformProps(this.props) : this.props, [...allowedProps, ...customNativeProps], config);
+
+      if (!deepEqual(this.config, newConfig)) {
+        this.updateGestureHandler(newConfig);
+      }
+    }
+
+    setNativeProps(updates) {
+      const mergedProps = { ...this.props,
+        ...updates
+      };
+      const newConfig = filterConfig(transformProps ? transformProps(mergedProps) : mergedProps, [...allowedProps, ...customNativeProps], config);
+      this.updateGestureHandler(newConfig);
+    }
+
+    render() {
+      let gestureEventHandler = this.onGestureHandlerEvent; // Another instance of https://github.com/microsoft/TypeScript/issues/13995
+
+      const {
+        onGestureEvent,
+        onGestureHandlerEvent
+      } = this.props;
+
+      if (onGestureEvent && typeof onGestureEvent !== 'function') {
+        // If it's not a method it should be an native Animated.event
+        // object. We set it directly as the handler for the view
+        // In this case nested handlers are not going to be supported
+        if (onGestureHandlerEvent) {
+          throw new Error('Nesting touch handlers with native animated driver is not supported yet');
+        }
+
+        gestureEventHandler = onGestureEvent;
+      } else {
+        if (onGestureHandlerEvent && typeof onGestureHandlerEvent !== 'function') {
+          throw new Error('Nesting touch handlers with native animated driver is not supported yet');
+        }
+      }
+
+      let gestureStateEventHandler = this.onGestureHandlerStateChange; // Another instance of https://github.com/microsoft/TypeScript/issues/13995
+
+      const {
+        onHandlerStateChange,
+        onGestureHandlerStateChange
+      } = this.props;
+
+      if (onHandlerStateChange && typeof onHandlerStateChange !== 'function') {
+        // If it's not a method it should be an native Animated.event
+        // object. We set it directly as the handler for the view
+        // In this case nested handlers are not going to be supported
+        if (onGestureHandlerStateChange) {
+          throw new Error('Nesting touch handlers with native animated driver is not supported yet');
+        }
+
+        gestureStateEventHandler = onHandlerStateChange;
+      } else {
+        if (onGestureHandlerStateChange && typeof onGestureHandlerStateChange !== 'function') {
+          throw new Error('Nesting touch handlers with native animated driver is not supported yet');
+        }
+      }
+
+      const events = {
+        onGestureHandlerEvent: this.state.allowTouches ? gestureEventHandler : undefined,
+        onGestureHandlerStateChange: this.state.allowTouches ? gestureStateEventHandler : undefined
+      };
+      this.propsRef.current = events;
+      const child = React.Children.only(this.props.children);
+      let grandChildren = child.props.children;
+
+      if (Touchable.TOUCH_TARGET_DEBUG && child.type && (child.type === 'RNGestureHandlerButton' || child.type.name === 'View' || child.type.displayName === 'View')) {
+        grandChildren = React.Children.toArray(grandChildren);
+        grandChildren.push(Touchable.renderDebugView({
+          color: 'mediumspringgreen',
+          hitSlop: child.props.hitSlop
+        }));
+      }
+
+      return /*#__PURE__*/React.cloneElement(child, {
+        ref: this.refHandler,
+        collapsable: false,
+        ...events
+      }, grandChildren);
+    }
+
+  }
+
+  _defineProperty(Handler, "displayName", name);
+
+  return Handler;
+}
+//# sourceMappingURL=createHandler.js.map

package/lib/module/handlers/createHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["createHandler.ts"],"names":["React","Platform","Touchable","UIManager","DeviceEventEmitter","deepEqual","RNGestureHandlerModule","State","handlerIDToTag","getNextHandlerTag","filterConfig","findNodeHandle","UIManagerAny","customGHEventsConfig","onGestureHandlerEvent","registrationName","onGestureHandlerStateChange","genericDirectEventTypes","UIManagerConstants","getViewManagerConfig","getConstants","setJSResponder","oldSetJSResponder","clearJSResponder","oldClearJSResponder","tag","blockNativeResponder","handleSetJSResponder","handleClearJSResponder","allowTouches","DEV_ON_ANDROID","__DEV__","OS","addListener","hasUnresolvedRefs","props","extract","refs","Array","isArray","current","some","r","stateToPropMappings","UNDETERMINED","undefined","BEGAN","FAILED","CANCELLED","ACTIVE","END","createHandler","name","allowedProps","config","transformProps","customNativeProps","Handler","Component","constructor","event","nativeEvent","handlerTag","onGestureEvent","onHandlerStateChange","state","stateEventName","eventHandler","node","viewNode","child","Children","only","children","ref","newConfig","createGestureHandler","newViewTag","viewTag","attachGestureHandler","propsRef","updateGestureHandler","createRef","id","Error","componentDidMount","inspectorToggleListener","setState","_","update","updateEnqueued","setImmediate","componentDidUpdate","componentWillUnmount","remove","dropGestureHandler","clearImmediate","handlerID","setNativeProps","updates","mergedProps","render","gestureEventHandler","gestureStateEventHandler","events","grandChildren","TOUCH_TARGET_DEBUG","type","displayName","toArray","push","renderDebugView","color","hitSlop","cloneElement","refHandler","collapsable"],"mappings":"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","sourcesContent":["import * as React from 'react';\nimport {\n  Platform,\n  Touchable,\n  UIManager,\n  DeviceEventEmitter,\n  EmitterSubscription,\n} from 'react-native';\n// @ts-ignore - it isn't typed by TS & don't have definitelyTyped types\nimport deepEqual from 'lodash/isEqual';\nimport RNGestureHandlerModule from '../RNGestureHandlerModule';\nimport type RNGestureHandlerModuleWeb from '../RNGestureHandlerModule.web';\nimport { State } from '../State';\nimport { handlerIDToTag, getNextHandlerTag } from './handlersRegistry';\n\nimport {\n  BaseGestureHandlerProps,\n  filterConfig,\n  GestureEvent,\n  HandlerStateChangeEvent,\n  findNodeHandle,\n} from './gestureHandlerCommon';\nimport { ValueOf } from '../typeUtils';\n\nconst UIManagerAny = UIManager as any;\n\nconst customGHEventsConfig = {\n  onGestureHandlerEvent: { registrationName: 'onGestureHandlerEvent' },\n  onGestureHandlerStateChange: {\n    registrationName: 'onGestureHandlerStateChange',\n  },\n};\n\n// Add gesture specific events to genericDirectEventTypes object exported from UIManager\n// native module.\n// Once new event types are registered with react it is possible to dispatch these\n// events to all kind of native views.\nUIManagerAny.genericDirectEventTypes = {\n  ...UIManagerAny.genericDirectEventTypes,\n  ...customGHEventsConfig,\n};\n// In newer versions of RN the `genericDirectEventTypes` is located in the object\n// returned by UIManager.getViewManagerConfig('getConstants') or in older RN UIManager.getConstants(), we need to add it there as well to make\n// it compatible with RN 61+\nconst UIManagerConstants =\n  UIManagerAny.getViewManagerConfig?.('getConstants') ??\n  UIManagerAny.getConstants?.();\n\nif (UIManagerConstants) {\n  UIManagerConstants.genericDirectEventTypes = {\n    ...UIManagerConstants.genericDirectEventTypes,\n    ...customGHEventsConfig,\n  };\n}\n\n// Wrap JS responder calls and notify gesture handler manager\nconst {\n  setJSResponder: oldSetJSResponder = () => {\n    //no operation\n  },\n  clearJSResponder: oldClearJSResponder = () => {\n    //no operation\n  },\n} = UIManagerAny;\nUIManagerAny.setJSResponder = (tag: number, blockNativeResponder: boolean) => {\n  RNGestureHandlerModule.handleSetJSResponder(tag, blockNativeResponder);\n  oldSetJSResponder(tag, blockNativeResponder);\n};\nUIManagerAny.clearJSResponder = () => {\n  RNGestureHandlerModule.handleClearJSResponder();\n  oldClearJSResponder();\n};\n\nlet allowTouches = true;\nconst DEV_ON_ANDROID = __DEV__ && Platform.OS === 'android';\n// Toggled inspector blocks touch events in order to allow inspecting on Android\n// This needs to be a global variable in order to set initial state for `allowTouches` property in Handler component\nif (DEV_ON_ANDROID) {\n  DeviceEventEmitter.addListener('toggleElementInspector', () => {\n    allowTouches = !allowTouches;\n  });\n}\n\ntype HandlerProps<T extends Record<string, unknown>> = Readonly<\n  React.PropsWithChildren<BaseGestureHandlerProps<T>>\n>;\nfunction hasUnresolvedRefs<T extends Record<string, unknown>>(\n  props: HandlerProps<T>\n) {\n  // TODO(TS) - add type for extract arg\n  const extract = (refs: any | any[]) => {\n    if (!Array.isArray(refs)) {\n      return refs && refs.current === null;\n    }\n    return refs.some((r) => r && r.current === null);\n  };\n  return extract(props['simultaneousHandlers']) || extract(props['waitFor']);\n}\n\nconst stateToPropMappings = {\n  [State.UNDETERMINED]: undefined,\n  [State.BEGAN]: 'onBegan',\n  [State.FAILED]: 'onFailed',\n  [State.CANCELLED]: 'onCancelled',\n  [State.ACTIVE]: 'onActivated',\n  [State.END]: 'onEnded',\n} as const;\n\ntype CreateHandlerArgs<\n  HandlerPropsT extends Record<string, unknown>\n> = Readonly<{\n  name: string;\n  allowedProps: Readonly<Extract<keyof HandlerPropsT, string>[]>;\n  config: Readonly<Record<string, unknown>>;\n  transformProps?: (props: HandlerPropsT) => HandlerPropsT;\n  customNativeProps?: Readonly<string[]>;\n}>;\n\n// TODO(TS) fix event types\ntype InternalEventHandlers = {\n  onGestureHandlerEvent?: (event: any) => void;\n  onGestureHandlerStateChange?: (event: any) => void;\n};\n\n// TODO(TS) - make sure that BaseGestureHandlerProps doesn't need other generic parameter to work with custom properties.\nexport default function createHandler<\n  T extends BaseGestureHandlerProps<U>,\n  U extends Record<string, unknown>\n>({\n  name,\n  allowedProps = [],\n  config = {},\n  transformProps,\n  customNativeProps = [],\n}: CreateHandlerArgs<T>): React.ComponentType<T & React.RefAttributes<any>> {\n  interface HandlerState {\n    allowTouches: boolean;\n  }\n  class Handler extends React.Component<\n    T & InternalEventHandlers,\n    HandlerState\n  > {\n    static displayName = name;\n\n    private handlerTag: number;\n    private config: Record<string, unknown>;\n    private propsRef: React.MutableRefObject<unknown>;\n    private viewNode: any;\n    private viewTag?: number;\n    private updateEnqueued: ReturnType<typeof setImmediate> | null = null;\n    private inspectorToggleListener?: EmitterSubscription;\n\n    constructor(props: T & InternalEventHandlers) {\n      super(props);\n      this.handlerTag = getNextHandlerTag();\n      this.config = {};\n      this.propsRef = React.createRef();\n      this.state = { allowTouches };\n      if (props.id) {\n        if (handlerIDToTag[props.id] !== undefined) {\n          throw new Error(`Handler with ID \"${props.id}\" already registered`);\n        }\n        handlerIDToTag[props.id] = this.handlerTag;\n      }\n    }\n\n    componentDidMount() {\n      const props: HandlerProps<U> = this.props;\n\n      if (DEV_ON_ANDROID) {\n        this.inspectorToggleListener = DeviceEventEmitter.addListener(\n          'toggleElementInspector',\n          () => {\n            this.setState((_) => ({ allowTouches }));\n            this.update();\n          }\n        );\n      }\n      if (hasUnresolvedRefs(props)) {\n        // If there are unresolved refs (e.g. \".current\" has not yet been set)\n        // passed as `simultaneousHandlers` or `waitFor`, we enqueue a call to\n        // _update method that will try to update native handler props using\n        // setImmediate. This makes it so update() function gets called after all\n        // react components are mounted and we expect the missing ref object to\n        // be resolved by then.\n        this.updateEnqueued = setImmediate(() => {\n          this.updateEnqueued = null;\n          this.update();\n        });\n      }\n\n      this.createGestureHandler(\n        filterConfig(\n          transformProps ? transformProps(this.props) : this.props,\n          [...allowedProps, ...customNativeProps],\n          config\n        )\n      );\n\n      this.attachGestureHandler(findNodeHandle(this.viewNode) as number); // TODO(TS) - check if this can be null\n    }\n\n    componentDidUpdate() {\n      const viewTag = findNodeHandle(this.viewNode);\n      if (this.viewTag !== viewTag) {\n        this.attachGestureHandler(viewTag as number); // TODO(TS) - check interaction between _viewTag & findNodeHandle\n      }\n      this.update();\n    }\n\n    componentWillUnmount() {\n      this.inspectorToggleListener?.remove();\n      RNGestureHandlerModule.dropGestureHandler(this.handlerTag);\n      if (this.updateEnqueued) {\n        clearImmediate(this.updateEnqueued);\n      }\n      // We can't use this.props.id directly due to TS generic type narrowing bug, see https://github.com/microsoft/TypeScript/issues/13995 for more context\n      const handlerID: string | undefined = this.props.id;\n      if (handlerID) {\n        // eslint-disable-next-line @typescript-eslint/no-dynamic-delete\n        delete handlerIDToTag[handlerID];\n      }\n    }\n\n    private onGestureHandlerEvent = (event: GestureEvent<U>) => {\n      if (event.nativeEvent.handlerTag === this.handlerTag) {\n        this.props.onGestureEvent?.(event);\n      } else {\n        this.props.onGestureHandlerEvent?.(event);\n      }\n    };\n\n    // TODO(TS) - make sure this is right type for event\n    private onGestureHandlerStateChange = (\n      event: HandlerStateChangeEvent<U>\n    ) => {\n      if (event.nativeEvent.handlerTag === this.handlerTag) {\n        this.props.onHandlerStateChange?.(event);\n\n        const state: ValueOf<typeof State> = event.nativeEvent.state;\n        const stateEventName = stateToPropMappings[state];\n        const eventHandler = stateEventName && this.props[stateEventName];\n        if (eventHandler && typeof eventHandler === 'function') {\n          eventHandler(event);\n        }\n      } else {\n        this.props.onGestureHandlerStateChange?.(event);\n      }\n    };\n\n    private refHandler = (node: any) => {\n      this.viewNode = node;\n\n      const child = React.Children.only(this.props.children);\n      // TODO(TS) fix ref type\n      const { ref }: any = child;\n      if (ref !== null) {\n        if (typeof ref === 'function') {\n          ref(node);\n        } else {\n          ref.current = node;\n        }\n      }\n    };\n\n    private createGestureHandler = (\n      newConfig: Readonly<Record<string, unknown>>\n    ) => {\n      this.config = newConfig;\n\n      RNGestureHandlerModule.createGestureHandler(\n        name,\n        this.handlerTag,\n        newConfig\n      );\n    };\n\n    private attachGestureHandler = (newViewTag: number) => {\n      this.viewTag = newViewTag;\n\n      if (Platform.OS === 'web') {\n        // typecast due to dynamic resolution, attachGestureHandler should have web version signature in this branch\n        (RNGestureHandlerModule.attachGestureHandler as typeof RNGestureHandlerModuleWeb.attachGestureHandler)(\n          this.handlerTag,\n          newViewTag,\n          false,\n          this.propsRef\n        );\n      } else {\n        RNGestureHandlerModule.attachGestureHandler(\n          this.handlerTag,\n          newViewTag,\n          false\n        );\n      }\n    };\n\n    private updateGestureHandler = (\n      newConfig: Readonly<Record<string, unknown>>\n    ) => {\n      this.config = newConfig;\n\n      RNGestureHandlerModule.updateGestureHandler(this.handlerTag, newConfig);\n    };\n\n    private update() {\n      const newConfig = filterConfig(\n        transformProps ? transformProps(this.props) : this.props,\n        [...allowedProps, ...customNativeProps],\n        config\n      );\n      if (!deepEqual(this.config, newConfig)) {\n        this.updateGestureHandler(newConfig);\n      }\n    }\n\n    setNativeProps(updates: any) {\n      const mergedProps = { ...this.props, ...updates };\n      const newConfig = filterConfig(\n        transformProps ? transformProps(mergedProps) : mergedProps,\n        [...allowedProps, ...customNativeProps],\n        config\n      );\n      this.updateGestureHandler(newConfig);\n    }\n\n    render() {\n      let gestureEventHandler = this.onGestureHandlerEvent;\n      // Another instance of https://github.com/microsoft/TypeScript/issues/13995\n      type OnGestureEventHandlers = {\n        onGestureEvent?: BaseGestureHandlerProps<U>['onGestureEvent'];\n        onGestureHandlerEvent?: InternalEventHandlers['onGestureHandlerEvent'];\n      };\n      const {\n        onGestureEvent,\n        onGestureHandlerEvent,\n      }: OnGestureEventHandlers = this.props;\n      if (onGestureEvent && typeof onGestureEvent !== 'function') {\n        // If it's not a method it should be an native Animated.event\n        // object. We set it directly as the handler for the view\n        // In this case nested handlers are not going to be supported\n        if (onGestureHandlerEvent) {\n          throw new Error(\n            'Nesting touch handlers with native animated driver is not supported yet'\n          );\n        }\n        gestureEventHandler = onGestureEvent;\n      } else {\n        if (\n          onGestureHandlerEvent &&\n          typeof onGestureHandlerEvent !== 'function'\n        ) {\n          throw new Error(\n            'Nesting touch handlers with native animated driver is not supported yet'\n          );\n        }\n      }\n\n      let gestureStateEventHandler = this.onGestureHandlerStateChange;\n      // Another instance of https://github.com/microsoft/TypeScript/issues/13995\n      type OnGestureStateChangeHandlers = {\n        onHandlerStateChange?: BaseGestureHandlerProps<U>['onHandlerStateChange'];\n        onGestureHandlerStateChange?: InternalEventHandlers['onGestureHandlerStateChange'];\n      };\n      const {\n        onHandlerStateChange,\n        onGestureHandlerStateChange,\n      }: OnGestureStateChangeHandlers = this.props;\n      if (onHandlerStateChange && typeof onHandlerStateChange !== 'function') {\n        // If it's not a method it should be an native Animated.event\n        // object. We set it directly as the handler for the view\n        // In this case nested handlers are not going to be supported\n        if (onGestureHandlerStateChange) {\n          throw new Error(\n            'Nesting touch handlers with native animated driver is not supported yet'\n          );\n        }\n        gestureStateEventHandler = onHandlerStateChange;\n      } else {\n        if (\n          onGestureHandlerStateChange &&\n          typeof onGestureHandlerStateChange !== 'function'\n        ) {\n          throw new Error(\n            'Nesting touch handlers with native animated driver is not supported yet'\n          );\n        }\n      }\n      const events = {\n        onGestureHandlerEvent: this.state.allowTouches\n          ? gestureEventHandler\n          : undefined,\n        onGestureHandlerStateChange: this.state.allowTouches\n          ? gestureStateEventHandler\n          : undefined,\n      };\n\n      this.propsRef.current = events;\n\n      const child: any = React.Children.only(this.props.children);\n      let grandChildren = child.props.children;\n      if (\n        Touchable.TOUCH_TARGET_DEBUG &&\n        child.type &&\n        (child.type === 'RNGestureHandlerButton' ||\n          child.type.name === 'View' ||\n          child.type.displayName === 'View')\n      ) {\n        grandChildren = React.Children.toArray(grandChildren);\n        grandChildren.push(\n          Touchable.renderDebugView({\n            color: 'mediumspringgreen',\n            hitSlop: child.props.hitSlop,\n          })\n        );\n      }\n\n      return React.cloneElement(\n        child,\n        {\n          ref: this.refHandler,\n          collapsable: false,\n          ...events,\n        },\n        grandChildren\n      );\n    }\n  }\n  return Handler;\n}\n"]}

package/lib/module/handlers/createNativeWrapper.js

@@ -0,0 +1,58 @@
+function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+
+import * as React from 'react';
+import { useImperativeHandle, useRef } from 'react';
+import { NativeViewGestureHandler, nativeViewProps } from './NativeViewGestureHandler';
+/*
+ * This array should consist of:
+ *   - All keys in propTypes from NativeGestureHandler
+ *     (and all keys in GestureHandlerPropTypes)
+ *   - 'onGestureHandlerEvent'
+ *   - 'onGestureHandlerStateChange'
+ */
+
+const NATIVE_WRAPPER_PROPS_FILTER = [...nativeViewProps, 'onGestureHandlerEvent', 'onGestureHandlerStateChange'];
+export default function createNativeWrapper(Component, config = {}) {
+  const ComponentWrapper = /*#__PURE__*/React.forwardRef((props, ref) => {
+    // filter out props that should be passed to gesture handler wrapper
+    const gestureHandlerProps = Object.keys(props).reduce((res, key) => {
+      // TS being overly protective with it's types, see https://github.com/microsoft/TypeScript/issues/26255#issuecomment-458013731 for more info
+      const allowedKeys = NATIVE_WRAPPER_PROPS_FILTER;
+
+      if (allowedKeys.includes(key)) {
+        // @ts-ignore FIXME(TS)
+        res[key] = props[key];
+      }
+
+      return res;
+    }, { ...config
+    } // watch out not to modify config
+    );
+
+    const _ref = useRef();
+
+    const _gestureHandlerRef = useRef();
+
+    useImperativeHandle(ref, // @ts-ignore TODO(TS) decide how nulls work in this context
+    () => {
+      const node = _gestureHandlerRef.current; // add handlerTag for relations config
+
+      if (_ref.current && node) {
+        // @ts-ignore FIXME(TS) think about createHandler return type
+        _ref.current.handlerTag = node.handlerTag;
+        return _ref.current;
+      }
+
+      return null;
+    }, [_ref, _gestureHandlerRef]);
+    return /*#__PURE__*/React.createElement(NativeViewGestureHandler, _extends({}, gestureHandlerProps, {
+      // @ts-ignore TODO(TS)
+      ref: _gestureHandlerRef
+    }), /*#__PURE__*/React.createElement(Component, _extends({}, props, {
+      ref: _ref
+    })));
+  });
+  ComponentWrapper.displayName = Component.displayName || 'ComponentWrapper';
+  return ComponentWrapper;
+}
+//# sourceMappingURL=createNativeWrapper.js.map

package/lib/module/handlers/createNativeWrapper.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["createNativeWrapper.tsx"],"names":["React","useImperativeHandle","useRef","NativeViewGestureHandler","nativeViewProps","NATIVE_WRAPPER_PROPS_FILTER","createNativeWrapper","Component","config","ComponentWrapper","forwardRef","props","ref","gestureHandlerProps","Object","keys","reduce","res","key","allowedKeys","includes","_ref","_gestureHandlerRef","node","current","handlerTag","displayName"],"mappings":";;AAAA,OAAO,KAAKA,KAAZ,MAAuB,OAAvB;AACA,SAASC,mBAAT,EAA8BC,MAA9B,QAA4C,OAA5C;AAEA,SACEC,wBADF,EAGEC,eAHF,QAIO,4BAJP;AAMA;AACA;AACA;AACA;AACA;AACA;AACA;;AACA,MAAMC,2BAA2B,GAAG,CAClC,GAAGD,eAD+B,EAElC,uBAFkC,EAGlC,6BAHkC,CAApC;AAMA,eAAe,SAASE,mBAAT,CACbC,SADa,EAEbC,MAA+C,GAAG,EAFrC,EAGb;AACA,QAAMC,gBAAgB,gBAAGT,KAAK,CAACU,UAAN,CAGvB,CAACC,KAAD,EAAQC,GAAR,KAAgB;AAChB;AACA,UAAMC,mBAAmB,GAAGC,MAAM,CAACC,IAAP,CAAYJ,KAAZ,EAAmBK,MAAnB,CAC1B,CAACC,GAAD,EAAMC,GAAN,KAAc;AACZ;AACA,YAAMC,WAA8B,GAAGd,2BAAvC;;AACA,UAAIc,WAAW,CAACC,QAAZ,CAAqBF,GAArB,CAAJ,EAA+B;AAC7B;AACAD,QAAAA,GAAG,CAACC,GAAD,CAAH,GAAWP,KAAK,CAACO,GAAD,CAAhB;AACD;;AACD,aAAOD,GAAP;AACD,KATyB,EAU1B,EAAE,GAAGT;AAAL,KAV0B,CAUZ;AAVY,KAA5B;;AAYA,UAAMa,IAAI,GAAGnB,MAAM,EAAnB;;AACA,UAAMoB,kBAAkB,GAAGpB,MAAM,EAAjC;;AACAD,IAAAA,mBAAmB,CACjBW,GADiB,EAEjB;AACA,UAAM;AACJ,YAAMW,IAAI,GAAGD,kBAAkB,CAACE,OAAhC,CADI,CAEJ;;AACA,UAAIH,IAAI,CAACG,OAAL,IAAgBD,IAApB,EAA0B;AACxB;AACAF,QAAAA,IAAI,CAACG,OAAL,CAAaC,UAAb,GAA0BF,IAAI,CAACE,UAA/B;AACA,eAAOJ,IAAI,CAACG,OAAZ;AACD;;AACD,aAAO,IAAP;AACD,KAZgB,EAajB,CAACH,IAAD,EAAOC,kBAAP,CAbiB,CAAnB;AAeA,wBACE,oBAAC,wBAAD,eACMT,mBADN;AAEE;AACA,MAAA,GAAG,EAAES;AAHP,qBAIE,oBAAC,SAAD,eAAeX,KAAf;AAAsB,MAAA,GAAG,EAAEU;AAA3B,OAJF,CADF;AAQD,GA1CwB,CAAzB;AA4CAZ,EAAAA,gBAAgB,CAACiB,WAAjB,GAA+BnB,SAAS,CAACmB,WAAV,IAAyB,kBAAxD;AAEA,SAAOjB,gBAAP;AACD","sourcesContent":["import * as React from 'react';\nimport { useImperativeHandle, useRef } from 'react';\n\nimport {\n  NativeViewGestureHandler,\n  NativeViewGestureHandlerProps,\n  nativeViewProps,\n} from './NativeViewGestureHandler';\n\n/*\n * This array should consist of:\n *   - All keys in propTypes from NativeGestureHandler\n *     (and all keys in GestureHandlerPropTypes)\n *   - 'onGestureHandlerEvent'\n *   - 'onGestureHandlerStateChange'\n */\nconst NATIVE_WRAPPER_PROPS_FILTER = [\n  ...nativeViewProps,\n  'onGestureHandlerEvent',\n  'onGestureHandlerStateChange',\n] as const;\n\nexport default function createNativeWrapper<P>(\n  Component: React.ComponentType<P>,\n  config: Readonly<NativeViewGestureHandlerProps> = {}\n) {\n  const ComponentWrapper = React.forwardRef<\n    React.ComponentType<any>,\n    P & NativeViewGestureHandlerProps\n  >((props, ref) => {\n    // filter out props that should be passed to gesture handler wrapper\n    const gestureHandlerProps = Object.keys(props).reduce(\n      (res, key) => {\n        // TS being overly protective with it's types, see https://github.com/microsoft/TypeScript/issues/26255#issuecomment-458013731 for more info\n        const allowedKeys: readonly string[] = NATIVE_WRAPPER_PROPS_FILTER;\n        if (allowedKeys.includes(key)) {\n          // @ts-ignore FIXME(TS)\n          res[key] = props[key];\n        }\n        return res;\n      },\n      { ...config } // watch out not to modify config\n    );\n    const _ref = useRef<React.ComponentType<P>>();\n    const _gestureHandlerRef = useRef<React.ComponentType<P>>();\n    useImperativeHandle(\n      ref,\n      // @ts-ignore TODO(TS) decide how nulls work in this context\n      () => {\n        const node = _gestureHandlerRef.current;\n        // add handlerTag for relations config\n        if (_ref.current && node) {\n          // @ts-ignore FIXME(TS) think about createHandler return type\n          _ref.current.handlerTag = node.handlerTag;\n          return _ref.current;\n        }\n        return null;\n      },\n      [_ref, _gestureHandlerRef]\n    );\n    return (\n      <NativeViewGestureHandler\n        {...gestureHandlerProps}\n        // @ts-ignore TODO(TS)\n        ref={_gestureHandlerRef}>\n        <Component {...props} ref={_ref} />\n      </NativeViewGestureHandler>\n    );\n  });\n\n  ComponentWrapper.displayName = Component.displayName || 'ComponentWrapper';\n\n  return ComponentWrapper;\n}\n"]}

package/lib/module/handlers/gestureHandlerCommon.js

@@ -0,0 +1,66 @@
+// Previous types exported gesture handlers as classes which creates an interface and variable, both named the same as class.
+// Without those types, we'd introduce breaking change, forcing users to prefix every handler type specification with typeof
+// e.g. React.createRef<TapGestureHandler> -> React.createRef<typeof TapGestureHandler>.
+// See https://www.typescriptlang.org/docs/handbook/classes.html#constructor-functions for reference.
+import { Platform, findNodeHandle as findNodeHandleRN } from 'react-native';
+import { handlerIDToTag } from './handlersRegistry';
+import { toArray } from '../utils';
+const commonProps = ['id', 'enabled', 'shouldCancelWhenOutside', 'hitSlop'];
+const componentInteractionProps = ['waitFor', 'simultaneousHandlers'];
+export const baseGestureHandlerProps = [...commonProps, ...componentInteractionProps, 'onBegan', 'onFailed', 'onCancelled', 'onActivated', 'onEnded', 'onGestureEvent', 'onHandlerStateChange'];
+export const baseGestureHandlerWithMonitorProps = [...commonProps, 'needsPointerData', 'manualActivation'];
+
+function isConfigParam(param, name) {
+  // param !== Object(param) returns false if `param` is a function
+  // or an object and returns true if `param` is null
+  return param !== undefined && (param !== Object(param) || !('__isNative' in param)) && name !== 'onHandlerStateChange' && name !== 'onGestureEvent';
+}
+
+export function filterConfig(props, validProps, defaults = {}) {
+  const filteredConfig = { ...defaults
+  };
+
+  for (const key of validProps) {
+    let value = props[key];
+
+    if (isConfigParam(value, key)) {
+      if (key === 'simultaneousHandlers' || key === 'waitFor') {
+        value = transformIntoHandlerTags(props[key]);
+      } else if (key === 'hitSlop' && typeof value !== 'object') {
+        value = {
+          top: value,
+          left: value,
+          bottom: value,
+          right: value
+        };
+      }
+
+      filteredConfig[key] = value;
+    }
+  }
+
+  return filteredConfig;
+}
+
+function transformIntoHandlerTags(handlerIDs) {
+  handlerIDs = toArray(handlerIDs);
+
+  if (Platform.OS === 'web') {
+    return handlerIDs.map(({
+      current
+    }) => current).filter(handle => handle);
+  } // converts handler string IDs into their numeric tags
+
+
+  return handlerIDs.map(handlerID => {
+    var _handlerID$current;
+
+    return handlerIDToTag[handlerID] || ((_handlerID$current = handlerID.current) === null || _handlerID$current === void 0 ? void 0 : _handlerID$current.handlerTag) || -1;
+  }).filter(handlerTag => handlerTag > 0);
+}
+
+export function findNodeHandle(node) {
+  if (Platform.OS === 'web') return node;
+  return findNodeHandleRN(node);
+}
+//# sourceMappingURL=gestureHandlerCommon.js.map

package/lib/module/handlers/gestureHandlerCommon.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["gestureHandlerCommon.ts"],"names":["Platform","findNodeHandle","findNodeHandleRN","handlerIDToTag","toArray","commonProps","componentInteractionProps","baseGestureHandlerProps","baseGestureHandlerWithMonitorProps","isConfigParam","param","name","undefined","Object","filterConfig","props","validProps","defaults","filteredConfig","key","value","transformIntoHandlerTags","top","left","bottom","right","handlerIDs","OS","map","current","filter","handle","handlerID","handlerTag","node"],"mappings":"AAAA;AACA;AACA;AACA;AAEA,SAASA,QAAT,EAAmBC,cAAc,IAAIC,gBAArC,QAA6D,cAA7D;AAKA,SAASC,cAAT,QAA+B,oBAA/B;AACA,SAASC,OAAT,QAAwB,UAAxB;AAEA,MAAMC,WAAW,GAAG,CAClB,IADkB,EAElB,SAFkB,EAGlB,yBAHkB,EAIlB,SAJkB,CAApB;AAOA,MAAMC,yBAAyB,GAAG,CAAC,SAAD,EAAY,sBAAZ,CAAlC;AAEA,OAAO,MAAMC,uBAAuB,GAAG,CACrC,GAAGF,WADkC,EAErC,GAAGC,yBAFkC,EAGrC,SAHqC,EAIrC,UAJqC,EAKrC,aALqC,EAMrC,aANqC,EAOrC,SAPqC,EAQrC,gBARqC,EASrC,sBATqC,CAAhC;AAYP,OAAO,MAAME,kCAAkC,GAAG,CAChD,GAAGH,WAD6C,EAEhD,kBAFgD,EAGhD,kBAHgD,CAA3C;;AAgGP,SAASI,aAAT,CAAuBC,KAAvB,EAAuCC,IAAvC,EAAqD;AACnD;AACA;AACA,SACED,KAAK,KAAKE,SAAV,KACCF,KAAK,KAAKG,MAAM,CAACH,KAAD,CAAhB,IACC,EAAE,gBAAiBA,KAAnB,CAFF,KAGAC,IAAI,KAAK,sBAHT,IAIAA,IAAI,KAAK,gBALX;AAOD;;AAED,OAAO,SAASG,YAAT,CACLC,KADK,EAELC,UAFK,EAGLC,QAAiC,GAAG,EAH/B,EAIL;AACA,QAAMC,cAAc,GAAG,EAAE,GAAGD;AAAL,GAAvB;;AACA,OAAK,MAAME,GAAX,IAAkBH,UAAlB,EAA8B;AAC5B,QAAII,KAAK,GAAGL,KAAK,CAACI,GAAD,CAAjB;;AACA,QAAIV,aAAa,CAACW,KAAD,EAAQD,GAAR,CAAjB,EAA+B;AAC7B,UAAIA,GAAG,KAAK,sBAAR,IAAkCA,GAAG,KAAK,SAA9C,EAAyD;AACvDC,QAAAA,KAAK,GAAGC,wBAAwB,CAACN,KAAK,CAACI,GAAD,CAAN,CAAhC;AACD,OAFD,MAEO,IAAIA,GAAG,KAAK,SAAR,IAAqB,OAAOC,KAAP,KAAiB,QAA1C,EAAoD;AACzDA,QAAAA,KAAK,GAAG;AAAEE,UAAAA,GAAG,EAAEF,KAAP;AAAcG,UAAAA,IAAI,EAAEH,KAApB;AAA2BI,UAAAA,MAAM,EAAEJ,KAAnC;AAA0CK,UAAAA,KAAK,EAAEL;AAAjD,SAAR;AACD;;AACDF,MAAAA,cAAc,CAACC,GAAD,CAAd,GAAsBC,KAAtB;AACD;AACF;;AACD,SAAOF,cAAP;AACD;;AAED,SAASG,wBAAT,CAAkCK,UAAlC,EAAmD;AACjDA,EAAAA,UAAU,GAAGtB,OAAO,CAACsB,UAAD,CAApB;;AAEA,MAAI1B,QAAQ,CAAC2B,EAAT,KAAgB,KAApB,EAA2B;AACzB,WAAOD,UAAU,CACdE,GADI,CACA,CAAC;AAAEC,MAAAA;AAAF,KAAD,KAAmCA,OADnC,EAEJC,MAFI,CAEIC,MAAD,IAAiBA,MAFpB,CAAP;AAGD,GAPgD,CAQjD;;;AACA,SAAOL,UAAU,CACdE,GADI,CAEFI,SAAD;AAAA;;AAAA,WACE7B,cAAc,CAAC6B,SAAD,CAAd,2BAA6BA,SAAS,CAACH,OAAvC,uDAA6B,mBAAmBI,UAAhD,KAA8D,CAAC,CADjE;AAAA,GAFG,EAKJH,MALI,CAKIG,UAAD,IAAwBA,UAAU,GAAG,CALxC,CAAP;AAMD;;AAED,OAAO,SAAShC,cAAT,CACLiC,IADK,EAEkE;AACvE,MAAIlC,QAAQ,CAAC2B,EAAT,KAAgB,KAApB,EAA2B,OAAOO,IAAP;AAC3B,SAAOhC,gBAAgB,CAACgC,IAAD,CAAvB;AACD","sourcesContent":["// Previous types exported gesture handlers as classes which creates an interface and variable, both named the same as class.\n// Without those types, we'd introduce breaking change, forcing users to prefix every handler type specification with typeof\n// e.g. React.createRef<TapGestureHandler> -> React.createRef<typeof TapGestureHandler>.\n// See https://www.typescriptlang.org/docs/handbook/classes.html#constructor-functions for reference.\nimport * as React from 'react';\nimport { Platform, findNodeHandle as findNodeHandleRN } from 'react-native';\n\nimport { State } from '../State';\nimport { EventType } from '../EventType';\nimport { ValueOf } from '../typeUtils';\nimport { handlerIDToTag } from './handlersRegistry';\nimport { toArray } from '../utils';\n\nconst commonProps = [\n  'id',\n  'enabled',\n  'shouldCancelWhenOutside',\n  'hitSlop',\n] as const;\n\nconst componentInteractionProps = ['waitFor', 'simultaneousHandlers'] as const;\n\nexport const baseGestureHandlerProps = [\n  ...commonProps,\n  ...componentInteractionProps,\n  'onBegan',\n  'onFailed',\n  'onCancelled',\n  'onActivated',\n  'onEnded',\n  'onGestureEvent',\n  'onHandlerStateChange',\n] as const;\n\nexport const baseGestureHandlerWithMonitorProps = [\n  ...commonProps,\n  'needsPointerData',\n  'manualActivation',\n];\n\nexport interface GestureEventPayload {\n  handlerTag: number;\n  numberOfPointers: number;\n  state: ValueOf<typeof State>;\n}\n\nexport interface HandlerStateChangeEventPayload {\n  handlerTag: number;\n  numberOfPointers: number;\n  state: ValueOf<typeof State>;\n  oldState: ValueOf<typeof State>;\n}\n\nexport type HitSlop =\n  | number\n  | Partial<\n      Record<\n        'left' | 'right' | 'top' | 'bottom' | 'vertical' | 'horizontal',\n        number\n      >\n    >\n  | Record<'width' | 'left', number>\n  | Record<'width' | 'right', number>\n  | Record<'height' | 'top', number>\n  | Record<'height' | 'bottom', number>;\n\n//TODO(TS) events in handlers\n\nexport interface GestureEvent<ExtraEventPayloadT = Record<string, unknown>> {\n  nativeEvent: Readonly<GestureEventPayload & ExtraEventPayloadT>;\n}\nexport interface HandlerStateChangeEvent<\n  ExtraEventPayloadT = Record<string, unknown>\n> {\n  nativeEvent: Readonly<HandlerStateChangeEventPayload & ExtraEventPayloadT>;\n}\n\nexport type TouchData = {\n  id: number;\n  x: number;\n  y: number;\n  absoluteX: number;\n  absoluteY: number;\n};\n\nexport type GestureTouchEvent = {\n  handlerTag: number;\n  numberOfTouches: number;\n  state: ValueOf<typeof State>;\n  eventType: EventType;\n  allTouches: TouchData[];\n  changedTouches: TouchData[];\n};\n\nexport type GestureUpdateEvent<\n  GestureEventPayloadT = Record<string, unknown>\n> = GestureEventPayload & GestureEventPayloadT;\n\nexport type GestureStateChangeEvent<\n  GestureStateChangeEventPayloadT = Record<string, unknown>\n> = HandlerStateChangeEventPayload & GestureStateChangeEventPayloadT;\n\nexport type CommonGestureConfig = {\n  enabled?: boolean;\n  shouldCancelWhenOutside?: boolean;\n  hitSlop?: HitSlop;\n};\n\n// Events payloads are types instead of interfaces due to TS limitation.\n// See https://github.com/microsoft/TypeScript/issues/15300 for more info.\nexport type BaseGestureHandlerProps<\n  ExtraEventPayloadT extends Record<string, unknown> = Record<string, unknown>\n> = CommonGestureConfig & {\n  id?: string;\n  waitFor?: React.Ref<unknown> | React.Ref<unknown>[];\n  simultaneousHandlers?: React.Ref<unknown> | React.Ref<unknown>[];\n  // TODO(TS) - fix event types\n  onBegan?: (event: HandlerStateChangeEvent) => void;\n  onFailed?: (event: HandlerStateChangeEvent) => void;\n  onCancelled?: (event: HandlerStateChangeEvent) => void;\n  onActivated?: (event: HandlerStateChangeEvent) => void;\n  onEnded?: (event: HandlerStateChangeEvent) => void;\n\n  //TODO(TS) consider using NativeSyntheticEvent\n  onGestureEvent?: (event: GestureEvent<ExtraEventPayloadT>) => void;\n  onHandlerStateChange?: (\n    event: HandlerStateChangeEvent<ExtraEventPayloadT>\n  ) => void;\n};\n\nfunction isConfigParam(param: unknown, name: string) {\n  // param !== Object(param) returns false if `param` is a function\n  // or an object and returns true if `param` is null\n  return (\n    param !== undefined &&\n    (param !== Object(param) ||\n      !('__isNative' in (param as Record<string, unknown>))) &&\n    name !== 'onHandlerStateChange' &&\n    name !== 'onGestureEvent'\n  );\n}\n\nexport function filterConfig(\n  props: Record<string, unknown>,\n  validProps: string[],\n  defaults: Record<string, unknown> = {}\n) {\n  const filteredConfig = { ...defaults };\n  for (const key of validProps) {\n    let value = props[key];\n    if (isConfigParam(value, key)) {\n      if (key === 'simultaneousHandlers' || key === 'waitFor') {\n        value = transformIntoHandlerTags(props[key]);\n      } else if (key === 'hitSlop' && typeof value !== 'object') {\n        value = { top: value, left: value, bottom: value, right: value };\n      }\n      filteredConfig[key] = value;\n    }\n  }\n  return filteredConfig;\n}\n\nfunction transformIntoHandlerTags(handlerIDs: any) {\n  handlerIDs = toArray(handlerIDs);\n\n  if (Platform.OS === 'web') {\n    return handlerIDs\n      .map(({ current }: { current: any }) => current)\n      .filter((handle: any) => handle);\n  }\n  // converts handler string IDs into their numeric tags\n  return handlerIDs\n    .map(\n      (handlerID: any) =>\n        handlerIDToTag[handlerID] || handlerID.current?.handlerTag || -1\n    )\n    .filter((handlerTag: number) => handlerTag > 0);\n}\n\nexport function findNodeHandle(\n  node: null | number | React.Component<any, any> | React.ComponentClass<any>\n): null | number | React.Component<any, any> | React.ComponentClass<any> {\n  if (Platform.OS === 'web') return node;\n  return findNodeHandleRN(node);\n}\n"]}

package/lib/module/handlers/gestureHandlerTypesCompat.js

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=gestureHandlerTypesCompat.js.map

package/lib/module/handlers/gestureHandlerTypesCompat.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","sourcesContent":[]}