react-native-gesture-handler 1.10.0 → 2.0.0

package/lib/commonjs/handlers/createHandler.js

@@ -0,0 +1,373 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = createHandler;
+
+var React = _interopRequireWildcard(require("react"));
+
+var _reactNative = require("react-native");
+
+var _isEqual = _interopRequireDefault(require("lodash/isEqual"));
+
+var _RNGestureHandlerModule = _interopRequireDefault(require("../RNGestureHandlerModule"));
+
+var _State = require("../State");
+
+var _handlersRegistry = require("./handlersRegistry");
+
+var _gestureHandlerCommon = require("./gestureHandlerCommon");
+
+var _UIManagerAny$getView, _UIManagerAny$getView2, _UIManagerAny$getCons;
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+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 UIManagerAny = _reactNative.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.default.handleSetJSResponder(tag, blockNativeResponder);
+
+  oldSetJSResponder(tag, blockNativeResponder);
+};
+
+UIManagerAny.clearJSResponder = () => {
+  _RNGestureHandlerModule.default.handleClearJSResponder();
+
+  oldClearJSResponder();
+};
+
+let allowTouches = true;
+const DEV_ON_ANDROID = __DEV__ && _reactNative.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) {
+  _reactNative.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.State.UNDETERMINED]: undefined,
+  [_State.State.BEGAN]: 'onBegan',
+  [_State.State.FAILED]: 'onFailed',
+  [_State.State.CANCELLED]: 'onCancelled',
+  [_State.State.ACTIVE]: 'onActivated',
+  [_State.State.END]: 'onEnded'
+};
+
+// TODO(TS) - make sure that BaseGestureHandlerProps doesn't need other generic parameter to work with custom properties.
+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.default.createGestureHandler(name, this.handlerTag, newConfig);
+      });
+
+      _defineProperty(this, "attachGestureHandler", newViewTag => {
+        this.viewTag = newViewTag;
+
+        if (_reactNative.Platform.OS === 'web') {
+          // typecast due to dynamic resolution, attachGestureHandler should have web version signature in this branch
+          _RNGestureHandlerModule.default.attachGestureHandler(this.handlerTag, newViewTag, false, this.propsRef);
+        } else {
+          _RNGestureHandlerModule.default.attachGestureHandler(this.handlerTag, newViewTag, false);
+        }
+      });
+
+      _defineProperty(this, "updateGestureHandler", newConfig => {
+        this.config = newConfig;
+
+        _RNGestureHandlerModule.default.updateGestureHandler(this.handlerTag, newConfig);
+      });
+
+      this.handlerTag = (0, _handlersRegistry.getNextHandlerTag)();
+      this.config = {};
+      this.propsRef = /*#__PURE__*/React.createRef();
+      this.state = {
+        allowTouches
+      };
+
+      if (props.id) {
+        if (_handlersRegistry.handlerIDToTag[props.id] !== undefined) {
+          throw new Error(`Handler with ID "${props.id}" already registered`);
+        }
+
+        _handlersRegistry.handlerIDToTag[props.id] = this.handlerTag;
+      }
+    }
+
+    componentDidMount() {
+      const props = this.props;
+
+      if (DEV_ON_ANDROID) {
+        this.inspectorToggleListener = _reactNative.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((0, _gestureHandlerCommon.filterConfig)(transformProps ? transformProps(this.props) : this.props, [...allowedProps, ...customNativeProps], config));
+      this.attachGestureHandler((0, _gestureHandlerCommon.findNodeHandle)(this.viewNode)); // TODO(TS) - check if this can be null
+    }
+
+    componentDidUpdate() {
+      const viewTag = (0, _gestureHandlerCommon.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.default.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 _handlersRegistry.handlerIDToTag[handlerID];
+      }
+    }
+
+    update() {
+      const newConfig = (0, _gestureHandlerCommon.filterConfig)(transformProps ? transformProps(this.props) : this.props, [...allowedProps, ...customNativeProps], config);
+
+      if (!(0, _isEqual.default)(this.config, newConfig)) {
+        this.updateGestureHandler(newConfig);
+      }
+    }
+
+    setNativeProps(updates) {
+      const mergedProps = { ...this.props,
+        ...updates
+      };
+      const newConfig = (0, _gestureHandlerCommon.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 (_reactNative.Touchable.TOUCH_TARGET_DEBUG && child.type && (child.type === 'RNGestureHandlerButton' || child.type.name === 'View' || child.type.displayName === 'View')) {
+        grandChildren = React.Children.toArray(grandChildren);
+        grandChildren.push(_reactNative.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/commonjs/handlers/createHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["createHandler.ts"],"names":["UIManagerAny","UIManager","customGHEventsConfig","onGestureHandlerEvent","registrationName","onGestureHandlerStateChange","genericDirectEventTypes","UIManagerConstants","getViewManagerConfig","getConstants","setJSResponder","oldSetJSResponder","clearJSResponder","oldClearJSResponder","tag","blockNativeResponder","RNGestureHandlerModule","handleSetJSResponder","handleClearJSResponder","allowTouches","DEV_ON_ANDROID","__DEV__","Platform","OS","DeviceEventEmitter","addListener","hasUnresolvedRefs","props","extract","refs","Array","isArray","current","some","r","stateToPropMappings","State","UNDETERMINED","undefined","BEGAN","FAILED","CANCELLED","ACTIVE","END","createHandler","name","allowedProps","config","transformProps","customNativeProps","Handler","React","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","handlerIDToTag","Error","componentDidMount","inspectorToggleListener","setState","_","update","updateEnqueued","setImmediate","componentDidUpdate","componentWillUnmount","remove","dropGestureHandler","clearImmediate","handlerID","setNativeProps","updates","mergedProps","render","gestureEventHandler","gestureStateEventHandler","events","grandChildren","Touchable","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/commonjs/handlers/createNativeWrapper.js

@@ -0,0 +1,70 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = createNativeWrapper;
+
+var React = _interopRequireWildcard(require("react"));
+
+var _NativeViewGestureHandler = require("./NativeViewGestureHandler");
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+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); }
+
+/*
+ * This array should consist of:
+ *   - All keys in propTypes from NativeGestureHandler
+ *     (and all keys in GestureHandlerPropTypes)
+ *   - 'onGestureHandlerEvent'
+ *   - 'onGestureHandlerStateChange'
+ */
+const NATIVE_WRAPPER_PROPS_FILTER = [..._NativeViewGestureHandler.nativeViewProps, 'onGestureHandlerEvent', 'onGestureHandlerStateChange'];
+
+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 = (0, React.useRef)();
+
+    const _gestureHandlerRef = (0, React.useRef)();
+
+    (0, React.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.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/commonjs/handlers/createNativeWrapper.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["createNativeWrapper.tsx"],"names":["NATIVE_WRAPPER_PROPS_FILTER","nativeViewProps","createNativeWrapper","Component","config","ComponentWrapper","React","forwardRef","props","ref","gestureHandlerProps","Object","keys","reduce","res","key","allowedKeys","includes","_ref","_gestureHandlerRef","node","current","handlerTag","displayName"],"mappings":";;;;;;;AAAA;;AAGA;;;;;;;;AAMA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMA,2BAA2B,GAAG,CAClC,GAAGC,yCAD+B,EAElC,uBAFkC,EAGlC,6BAHkC,CAApC;;AAMe,SAASC,mBAAT,CACbC,SADa,EAEbC,MAA+C,GAAG,EAFrC,EAGb;AACA,QAAMC,gBAAgB,gBAAGC,KAAK,CAACC,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,GAAGhB,2BAAvC;;AACA,UAAIgB,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,GAAGV;AAAL,KAV0B,CAUZ;AAVY,KAA5B;;AAYA,UAAMc,IAAI,GAAG,mBAAb;;AACA,UAAMC,kBAAkB,GAAG,mBAA3B;;AACA,mCACEV,GADF,EAEE;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,KAZH,EAaE,CAACH,IAAD,EAAOC,kBAAP,CAbF;AAeA,wBACE,oBAAC,kDAAD,eACMT,mBADN;AAEE;AACA,MAAA,GAAG,EAAES;AAHP,qBAIE,oBAAC,SAAD,eAAeX,KAAf;AAAsB,MAAA,GAAG,EAAEU;AAA3B,OAJF,CADF;AAQD,GA1CwB,CAAzB;AA4CAb,EAAAA,gBAAgB,CAACkB,WAAjB,GAA+BpB,SAAS,CAACoB,WAAV,IAAyB,kBAAxD;AAEA,SAAOlB,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/commonjs/handlers/gestureHandlerCommon.js

@@ -0,0 +1,80 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.filterConfig = filterConfig;
+exports.findNodeHandle = findNodeHandle;
+exports.baseGestureHandlerWithMonitorProps = exports.baseGestureHandlerProps = void 0;
+
+var _reactNative = require("react-native");
+
+var _handlersRegistry = require("./handlersRegistry");
+
+var _utils = require("../utils");
+
+// 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.
+const commonProps = ['id', 'enabled', 'shouldCancelWhenOutside', 'hitSlop'];
+const componentInteractionProps = ['waitFor', 'simultaneousHandlers'];
+const baseGestureHandlerProps = [...commonProps, ...componentInteractionProps, 'onBegan', 'onFailed', 'onCancelled', 'onActivated', 'onEnded', 'onGestureEvent', 'onHandlerStateChange'];
+exports.baseGestureHandlerProps = baseGestureHandlerProps;
+const baseGestureHandlerWithMonitorProps = [...commonProps, 'needsPointerData', 'manualActivation'];
+exports.baseGestureHandlerWithMonitorProps = baseGestureHandlerWithMonitorProps;
+
+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';
+}
+
+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 = (0, _utils.toArray)(handlerIDs);
+
+  if (_reactNative.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 _handlersRegistry.handlerIDToTag[handlerID] || ((_handlerID$current = handlerID.current) === null || _handlerID$current === void 0 ? void 0 : _handlerID$current.handlerTag) || -1;
+  }).filter(handlerTag => handlerTag > 0);
+}
+
+function findNodeHandle(node) {
+  if (_reactNative.Platform.OS === 'web') return node;
+  return (0, _reactNative.findNodeHandle)(node);
+}
+//# sourceMappingURL=gestureHandlerCommon.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["gestureHandlerCommon.ts"],"names":["commonProps","componentInteractionProps","baseGestureHandlerProps","baseGestureHandlerWithMonitorProps","isConfigParam","param","name","undefined","Object","filterConfig","props","validProps","defaults","filteredConfig","key","value","transformIntoHandlerTags","top","left","bottom","right","handlerIDs","Platform","OS","map","current","filter","handle","handlerID","handlerIDToTag","handlerTag","findNodeHandle","node"],"mappings":";;;;;;;;;AAKA;;AAKA;;AACA;;AAXA;AACA;AACA;AACA;AAUA,MAAMA,WAAW,GAAG,CAClB,IADkB,EAElB,SAFkB,EAGlB,yBAHkB,EAIlB,SAJkB,CAApB;AAOA,MAAMC,yBAAyB,GAAG,CAAC,SAAD,EAAY,sBAAZ,CAAlC;AAEO,MAAMC,uBAAuB,GAAG,CACrC,GAAGF,WADkC,EAErC,GAAGC,yBAFkC,EAGrC,SAHqC,EAIrC,UAJqC,EAKrC,aALqC,EAMrC,aANqC,EAOrC,SAPqC,EAQrC,gBARqC,EASrC,sBATqC,CAAhC;;AAYA,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;;AAEM,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,GAAG,oBAAQA,UAAR,CAAb;;AAEA,MAAIC,sBAASC,EAAT,KAAgB,KAApB,EAA2B;AACzB,WAAOF,UAAU,CACdG,GADI,CACA,CAAC;AAAEC,MAAAA;AAAF,KAAD,KAAmCA,OADnC,EAEJC,MAFI,CAEIC,MAAD,IAAiBA,MAFpB,CAAP;AAGD,GAPgD,CAQjD;;;AACA,SAAON,UAAU,CACdG,GADI,CAEFI,SAAD;AAAA;;AAAA,WACEC,iCAAeD,SAAf,4BAA6BA,SAAS,CAACH,OAAvC,uDAA6B,mBAAmBK,UAAhD,KAA8D,CAAC,CADjE;AAAA,GAFG,EAKJJ,MALI,CAKII,UAAD,IAAwBA,UAAU,GAAG,CALxC,CAAP;AAMD;;AAEM,SAASC,cAAT,CACLC,IADK,EAEkE;AACvE,MAAIV,sBAASC,EAAT,KAAgB,KAApB,EAA2B,OAAOS,IAAP;AAC3B,SAAO,iCAAiBA,IAAjB,CAAP;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/commonjs/handlers/gestureHandlerTypesCompat.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=gestureHandlerTypesCompat.js.map

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

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