@hps1978/react-native-web-tv 0.21.2-tv.0

package/dist/cjs/exports/Modal/ModalFocusTrap.js

@@ -0,0 +1,138 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+exports.__esModule = true;
+exports.default = void 0;
+var React = _interopRequireWildcard(require("react"));
+var _View = _interopRequireDefault(require("../View"));
+var _createElement = _interopRequireDefault(require("../createElement"));
+var _StyleSheet = _interopRequireDefault(require("../StyleSheet"));
+var _UIManager = _interopRequireDefault(require("../UIManager"));
+var _canUseDom = _interopRequireDefault(require("../../modules/canUseDom"));
+/**
+ * Copyright (c) Nicolas Gallagher.
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+
+/**
+ * This Component is used to "wrap" the modal we're opening
+ * so that changing focus via tab will never leave the document.
+ *
+ * This allows us to properly trap the focus within a modal
+ * even if the modal is at the start or end of a document.
+ */
+
+var FocusBracket = () => {
+  return (0, _createElement.default)('div', {
+    role: 'none',
+    tabIndex: 0,
+    style: styles.focusBracket
+  });
+};
+function attemptFocus(element) {
+  if (!_canUseDom.default) {
+    return false;
+  }
+  try {
+    element.focus();
+  } catch (e) {
+    // Do nothing
+  }
+  return document.activeElement === element;
+}
+function focusFirstDescendant(element) {
+  for (var i = 0; i < element.childNodes.length; i++) {
+    var child = element.childNodes[i];
+    if (attemptFocus(child) || focusFirstDescendant(child)) {
+      return true;
+    }
+  }
+  return false;
+}
+function focusLastDescendant(element) {
+  for (var i = element.childNodes.length - 1; i >= 0; i--) {
+    var child = element.childNodes[i];
+    if (attemptFocus(child) || focusLastDescendant(child)) {
+      return true;
+    }
+  }
+  return false;
+}
+var ModalFocusTrap = _ref => {
+  var active = _ref.active,
+    children = _ref.children;
+  var trapElementRef = React.useRef();
+  var focusRef = React.useRef({
+    trapFocusInProgress: false,
+    lastFocusedElement: null
+  });
+  React.useEffect(() => {
+    if (_canUseDom.default) {
+      var trapFocus = () => {
+        // We should not trap focus if:
+        // - The modal hasn't fully initialized with an HTMLElement ref
+        // - Focus is already in the process of being trapped (e.g., we're refocusing)
+        // - isTrapActive prop being falsey tells us to do nothing
+        if (trapElementRef.current == null || focusRef.current.trapFocusInProgress || !active) {
+          return;
+        }
+        try {
+          focusRef.current.trapFocusInProgress = true;
+          if (document.activeElement instanceof Node && !trapElementRef.current.contains(document.activeElement)) {
+            // To handle keyboard focusing we can make an assumption here.
+            // If you're tabbing through the focusable elements, the previously
+            // active element will either be the first or the last.
+            // If the previously selected element is the "first" descendant
+            // and we're leaving it - this means that we should be looping
+            // around to the other side of the modal.
+            var hasFocused = focusFirstDescendant(trapElementRef.current);
+            if (focusRef.current.lastFocusedElement === document.activeElement) {
+              hasFocused = focusLastDescendant(trapElementRef.current);
+            }
+            // If we couldn't focus a new element then we need to focus onto the trap target
+            if (!hasFocused && trapElementRef.current != null && document.activeElement) {
+              _UIManager.default.focus(trapElementRef.current);
+            }
+          }
+        } finally {
+          focusRef.current.trapFocusInProgress = false;
+        }
+        focusRef.current.lastFocusedElement = document.activeElement;
+      };
+
+      // Call the trapFocus callback at least once when this modal has been activated.
+      trapFocus();
+      document.addEventListener('focus', trapFocus, true);
+      return () => document.removeEventListener('focus', trapFocus, true);
+    }
+  }, [active]);
+
+  // To be fully compliant with WCAG we need to refocus element that triggered opening modal
+  // after closing it
+  React.useEffect(function () {
+    if (_canUseDom.default) {
+      var lastFocusedElementOutsideTrap = document.activeElement;
+      return function () {
+        if (lastFocusedElementOutsideTrap && document.contains(lastFocusedElementOutsideTrap)) {
+          _UIManager.default.focus(lastFocusedElementOutsideTrap);
+        }
+      };
+    }
+  }, []);
+  return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(FocusBracket, null), /*#__PURE__*/React.createElement(_View.default, {
+    ref: trapElementRef
+  }, children), /*#__PURE__*/React.createElement(FocusBracket, null));
+};
+var _default = exports.default = ModalFocusTrap;
+var styles = _StyleSheet.default.create({
+  focusBracket: {
+    outlineStyle: 'none'
+  }
+});
+module.exports = exports.default;

package/dist/cjs/exports/Modal/ModalPortal.js

@@ -0,0 +1,43 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+exports.__esModule = true;
+exports.default = void 0;
+var React = _interopRequireWildcard(require("react"));
+var _reactDom = require("react-dom");
+var _canUseDom = _interopRequireDefault(require("../../modules/canUseDom"));
+/**
+ * Copyright (c) Nicolas Gallagher.
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+
+function ModalPortal(props) {
+  var children = props.children;
+  var elementRef = React.useRef(null);
+  if (_canUseDom.default && !elementRef.current) {
+    var element = document.createElement('div');
+    if (element && document.body) {
+      document.body.appendChild(element);
+      elementRef.current = element;
+    }
+  }
+  React.useEffect(() => {
+    if (_canUseDom.default) {
+      return () => {
+        if (document.body && elementRef.current) {
+          document.body.removeChild(elementRef.current);
+          elementRef.current = null;
+        }
+      };
+    }
+  }, []);
+  return elementRef.current && _canUseDom.default ? /*#__PURE__*/(0, _reactDom.createPortal)(children, elementRef.current) : null;
+}
+var _default = exports.default = ModalPortal;
+module.exports = exports.default;

package/dist/cjs/exports/Modal/index.js

@@ -0,0 +1,106 @@
+"use strict";
+/**
+ * Copyright (c) Nicolas Gallagher.
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+
+'use client';
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+exports.__esModule = true;
+exports.default = void 0;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _objectWithoutPropertiesLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutPropertiesLoose"));
+var React = _interopRequireWildcard(require("react"));
+var _ModalPortal = _interopRequireDefault(require("./ModalPortal"));
+var _ModalAnimation = _interopRequireDefault(require("./ModalAnimation"));
+var _ModalContent = _interopRequireDefault(require("./ModalContent"));
+var _ModalFocusTrap = _interopRequireDefault(require("./ModalFocusTrap"));
+var _excluded = ["animationType", "children", "onDismiss", "onRequestClose", "onShow", "transparent", "visible"];
+var uniqueModalIdentifier = 0;
+var activeModalStack = [];
+var activeModalListeners = {};
+function notifyActiveModalListeners() {
+  if (activeModalStack.length === 0) {
+    return;
+  }
+  var activeModalId = activeModalStack[activeModalStack.length - 1];
+  activeModalStack.forEach(modalId => {
+    if (modalId in activeModalListeners) {
+      activeModalListeners[modalId](modalId === activeModalId);
+    }
+  });
+}
+function removeActiveModal(modalId) {
+  if (modalId in activeModalListeners) {
+    // Before removing this listener we should probably tell it
+    // that it's no longer the active modal for sure.
+    activeModalListeners[modalId](false);
+    delete activeModalListeners[modalId];
+  }
+  var index = activeModalStack.indexOf(modalId);
+  if (index !== -1) {
+    activeModalStack.splice(index, 1);
+    notifyActiveModalListeners();
+  }
+}
+function addActiveModal(modalId, listener) {
+  removeActiveModal(modalId);
+  activeModalStack.push(modalId);
+  activeModalListeners[modalId] = listener;
+  notifyActiveModalListeners();
+}
+var Modal = /*#__PURE__*/React.forwardRef((props, forwardedRef) => {
+  var animationType = props.animationType,
+    children = props.children,
+    onDismiss = props.onDismiss,
+    onRequestClose = props.onRequestClose,
+    onShow = props.onShow,
+    transparent = props.transparent,
+    _props$visible = props.visible,
+    visible = _props$visible === void 0 ? true : _props$visible,
+    rest = (0, _objectWithoutPropertiesLoose2.default)(props, _excluded);
+
+  // Set a unique model identifier so we can correctly route
+  // dismissals and check the layering of modals.
+  var modalId = React.useMemo(() => uniqueModalIdentifier++, []);
+  var _React$useState = React.useState(false),
+    isActive = _React$useState[0],
+    setIsActive = _React$useState[1];
+  var onDismissCallback = React.useCallback(() => {
+    removeActiveModal(modalId);
+    if (onDismiss) {
+      onDismiss();
+    }
+  }, [modalId, onDismiss]);
+  var onShowCallback = React.useCallback(() => {
+    addActiveModal(modalId, setIsActive);
+    if (onShow) {
+      onShow();
+    }
+  }, [modalId, onShow]);
+  React.useEffect(() => {
+    return () => removeActiveModal(modalId);
+  }, [modalId]);
+  return /*#__PURE__*/React.createElement(_ModalPortal.default, null, /*#__PURE__*/React.createElement(_ModalAnimation.default, {
+    animationType: animationType,
+    onDismiss: onDismissCallback,
+    onShow: onShowCallback,
+    visible: visible
+  }, /*#__PURE__*/React.createElement(_ModalFocusTrap.default, {
+    active: isActive
+  }, /*#__PURE__*/React.createElement(_ModalContent.default, (0, _extends2.default)({}, rest, {
+    active: isActive,
+    onRequestClose: onRequestClose,
+    ref: forwardedRef,
+    transparent: transparent
+  }), children))));
+});
+var _default = exports.default = Modal;
+module.exports = exports.default;

package/dist/cjs/exports/NativeEventEmitter/index.js

@@ -0,0 +1,16 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.default = void 0;
+var _NativeEventEmitter = _interopRequireDefault(require("../../vendor/react-native/EventEmitter/NativeEventEmitter"));
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+var _default = exports.default = _NativeEventEmitter.default;
+module.exports = exports.default;

package/dist/cjs/exports/NativeModules/index.js

@@ -0,0 +1,21 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.default = void 0;
+var _UIManager = _interopRequireDefault(require("../UIManager"));
+/**
+ * Copyright (c) Nicolas Gallagher.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+
+// NativeModules shim
+var NativeModules = {
+  UIManager: _UIManager.default
+};
+var _default = exports.default = NativeModules;
+module.exports = exports.default;

package/dist/cjs/exports/PanResponder/Alternative.js

@@ -0,0 +1,273 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ * @format
+ */
+
+/**
+ * PAN RESPONDER
+ *
+ * `PanResponder` uses the Responder System to reconcile several touches into
+ * a single gesture. It makes single-touch gestures resilient to extra touches,
+ * and can be used to recognize simple multi-touch gestures. For each handler,
+ * it provides a `gestureState` object alongside the ResponderEvent object.
+ *
+ * By default, `PanResponder` holds an `InteractionManager` handle to block
+ * long-running JS events from interrupting active gestures.
+ *
+ * A graphical explanation of the touch data flow:
+ *
+ * +----------------------------+             +--------------------------------+
+ * | ResponderTouchHistoryStore |             |TouchHistoryMath                |
+ * +----------------------------+             +----------+---------------------+
+ * |Global store of touchHistory|             |Allocation-less math util       |
+ * |including activeness, start |             |on touch history (centroids     |
+ * |position, prev/cur position.|             |and multitouch movement etc)    |
+ * |                            |             |                                |
+ * +----^-----------------------+             +----^---------------------------+
+ *      |                                          |
+ *      | (records relevant history                |
+ *      |  of touches relevant for                 |
+ *      |  implementing higher level               |
+ *      |  gestures)                               |
+ *      |                                          |
+ * +----+-----------------------+             +----|---------------------------+
+ * | ResponderEventPlugin       |             |    |   Your App/Component      |
+ * +----------------------------+             +----|---------------------------+
+ * |Negotiates which view gets  | Low level   |    |             High level    |
+ * |onResponderMove events.     | events w/   |  +-+-------+     events w/     |
+ * |Also records history into   | touchHistory|  |   Pan   |     multitouch +  |
+ * |ResponderTouchHistoryStore. +---------------->Responder+-----> accumulative|
+ * +----------------------------+ attached to |  |         |     distance and  |
+ *                                 each event |  +---------+     velocity.     |
+ *                                            |                                |
+ *                                            |                                |
+ *                                            +--------------------------------+
+ */
+
+'use strict';
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.default = void 0;
+var _InteractionManager = _interopRequireDefault(require("../InteractionManager"));
+var _TouchHistoryMath = _interopRequireDefault(require("../../vendor/react-native/TouchHistoryMath"));
+var currentCentroidX = _TouchHistoryMath.default.currentCentroidX,
+  currentCentroidY = _TouchHistoryMath.default.currentCentroidY,
+  currentCentroidXOfTouchesChangedAfter = _TouchHistoryMath.default.currentCentroidXOfTouchesChangedAfter,
+  currentCentroidYOfTouchesChangedAfter = _TouchHistoryMath.default.currentCentroidYOfTouchesChangedAfter,
+  previousCentroidXOfTouchesChangedAfter = _TouchHistoryMath.default.previousCentroidXOfTouchesChangedAfter,
+  previousCentroidYOfTouchesChangedAfter = _TouchHistoryMath.default.previousCentroidYOfTouchesChangedAfter;
+var PanResponder = {
+  _initializeGestureState(gestureState) {
+    gestureState.x = 0;
+    gestureState.y = 0;
+    gestureState.initialX = 0;
+    gestureState.initialY = 0;
+    gestureState.deltaX = 0;
+    gestureState.deltaY = 0;
+    gestureState.velocityX = 0;
+    gestureState.velocityY = 0;
+    gestureState.numberActiveTouches = 0;
+    // All `gestureState` accounts for timeStamps up until:
+    gestureState._accountsForMovesUpTo = 0;
+  },
+  /**
+   * Take all recently moved touches, calculate how the centroid has changed just for those
+   * recently moved touches, and append that change to an accumulator. This is
+   * to (at least) handle the case where the user is moving three fingers, and
+   * then one of the fingers stops but the other two continue.
+   *
+   * This is very different than taking all of the recently moved touches and
+   * storing their centroid as `dx/dy`. For correctness, we must *accumulate
+   * changes* in the centroid of recently moved touches.
+   *
+   * There is also some nuance with how we handle multiple moved touches in a
+   * single event. Multiple touches generate two 'move' events, each of
+   * them triggering `onResponderMove`. But with the way `PanResponder` works,
+   * all of the gesture inference is performed on the first dispatch, since it
+   * looks at all of the touches. Therefore, `PanResponder` does not call
+   * `onResponderMove` passed the first dispatch. This diverges from the
+   * typical responder callback pattern (without using `PanResponder`), but
+   * avoids more dispatches than necessary.
+   *
+   * When moving two touches in opposite directions, the cumulative
+   * distance is zero in each dimension. When two touches move in parallel five
+   * pixels in the same direction, the cumulative distance is five, not ten. If
+   * two touches start, one moves five in a direction, then stops and the other
+   * touch moves fives in the same direction, the cumulative distance is ten.
+   *
+   * This logic requires a kind of processing of time "clusters" of touch events
+   * so that two touch moves that essentially occur in parallel but move every
+   * other frame respectively, are considered part of the same movement.
+   *
+   * x/y: If a move event has been observed, `(x, y)` is the centroid of the most
+   * recently moved "cluster" of active touches.
+   * deltaX/deltaY: Cumulative touch distance. Accounts for touch moves that are
+   * clustered together in time, moving the same direction. Only valid when
+   * currently responder (otherwise, it only represents the drag distance below
+   * the threshold).
+   */
+  _updateGestureStateOnMove(gestureState, touchHistory) {
+    var movedAfter = gestureState._accountsForMovesUpTo;
+    var prevX = previousCentroidXOfTouchesChangedAfter(touchHistory, movedAfter);
+    var prevY = previousCentroidYOfTouchesChangedAfter(touchHistory, movedAfter);
+    var prevDeltaX = gestureState.deltaX;
+    var prevDeltaY = gestureState.deltaY;
+    var x = currentCentroidXOfTouchesChangedAfter(touchHistory, movedAfter);
+    var y = currentCentroidYOfTouchesChangedAfter(touchHistory, movedAfter);
+    var deltaX = prevDeltaX + (x - prevX);
+    var deltaY = prevDeltaY + (y - prevY);
+    // TODO: This must be filtered intelligently.
+    var dt = touchHistory.mostRecentTimeStamp - gestureState._accountsForMovesUpTo;
+    gestureState.deltaX = deltaX;
+    gestureState.deltaY = deltaY;
+    gestureState.numberActiveTouches = touchHistory.numberActiveTouches;
+    gestureState.velocityX = (deltaX - prevDeltaX) / dt;
+    gestureState.velocityY = (deltaY - prevDeltaY) / dt;
+    gestureState.x = x;
+    gestureState.y = y;
+    gestureState._accountsForMovesUpTo = touchHistory.mostRecentTimeStamp;
+  },
+  /**
+   * Enhanced versions of all of the responder callbacks that provide not only
+   * the `ResponderEvent`, but also the `PanResponder` gesture state.
+   *
+   * In general, for events that have capture equivalents, we update the
+   * gestureState once in the capture phase and can use it in the bubble phase
+   * as well.
+   */
+  create(config) {
+    var interactionState = {
+      handle: null
+    };
+    var gestureState = {
+      // Useful for debugging
+      stateID: Math.random(),
+      x: 0,
+      y: 0,
+      initialX: 0,
+      initialY: 0,
+      deltaX: 0,
+      deltaY: 0,
+      velocityX: 0,
+      velocityY: 0,
+      numberActiveTouches: 0,
+      _accountsForMovesUpTo: 0
+    };
+    var onStartShouldSetResponder = config.onStartShouldSetResponder,
+      onStartShouldSetResponderCapture = config.onStartShouldSetResponderCapture,
+      onMoveShouldSetResponder = config.onMoveShouldSetResponder,
+      onMoveShouldSetResponderCapture = config.onMoveShouldSetResponderCapture,
+      onPanGrant = config.onPanGrant,
+      onPanStart = config.onPanStart,
+      onPanMove = config.onPanMove,
+      onPanEnd = config.onPanEnd,
+      onPanRelease = config.onPanRelease,
+      onPanReject = config.onPanReject,
+      onPanTerminate = config.onPanTerminate,
+      onPanTerminationRequest = config.onPanTerminationRequest;
+    var panHandlers = {
+      onStartShouldSetResponder(event) {
+        return onStartShouldSetResponder != null ? onStartShouldSetResponder(event, gestureState) : false;
+      },
+      onMoveShouldSetResponder(event) {
+        return onMoveShouldSetResponder != null ? onMoveShouldSetResponder(event, gestureState) : false;
+      },
+      onStartShouldSetResponderCapture(event) {
+        // TODO: Actually, we should reinitialize the state any time
+        // touches.length increases from 0 active to > 0 active.
+        if (event.nativeEvent.touches.length === 1) {
+          PanResponder._initializeGestureState(gestureState);
+        }
+        gestureState.numberActiveTouches = event.touchHistory.numberActiveTouches;
+        return onStartShouldSetResponderCapture != null ? onStartShouldSetResponderCapture(event, gestureState) : false;
+      },
+      onMoveShouldSetResponderCapture(event) {
+        var touchHistory = event.touchHistory;
+        // Responder system incorrectly dispatches should* to current responder
+        // Filter out any touch moves past the first one - we would have
+        // already processed multi-touch geometry during the first event.
+        // NOTE: commented out because new responder system should get it right.
+        //if (gestureState._accountsForMovesUpTo === touchHistory.mostRecentTimeStamp) {
+        //  return false;
+        //}
+        PanResponder._updateGestureStateOnMove(gestureState, touchHistory);
+        return onMoveShouldSetResponderCapture != null ? onMoveShouldSetResponderCapture(event, gestureState) : false;
+      },
+      onResponderGrant(event) {
+        if (!interactionState.handle) {
+          interactionState.handle = _InteractionManager.default.createInteractionHandle();
+        }
+        gestureState.initialX = currentCentroidX(event.touchHistory);
+        gestureState.initialY = currentCentroidY(event.touchHistory);
+        gestureState.deltaX = 0;
+        gestureState.deltaY = 0;
+        if (onPanGrant != null) {
+          onPanGrant(event, gestureState);
+        }
+      },
+      onResponderReject(event) {
+        clearInteractionHandle(interactionState, onPanReject, event, gestureState);
+      },
+      onResponderStart(event) {
+        var numberActiveTouches = event.touchHistory.numberActiveTouches;
+        gestureState.numberActiveTouches = numberActiveTouches;
+        if (onPanStart != null) {
+          onPanStart(event, gestureState);
+        }
+      },
+      onResponderMove(event) {
+        var touchHistory = event.touchHistory;
+        // Guard against the dispatch of two touch moves when there are two
+        // simultaneously changed touches.
+        if (gestureState._accountsForMovesUpTo === touchHistory.mostRecentTimeStamp) {
+          return;
+        }
+        // Filter out any touch moves past the first one - we would have
+        // already processed multi-touch geometry during the first event.
+        PanResponder._updateGestureStateOnMove(gestureState, touchHistory);
+        if (onPanMove != null) {
+          onPanMove(event, gestureState);
+        }
+      },
+      onResponderEnd(event) {
+        var numberActiveTouches = event.touchHistory.numberActiveTouches;
+        gestureState.numberActiveTouches = numberActiveTouches;
+        clearInteractionHandle(interactionState, onPanEnd, event, gestureState);
+      },
+      onResponderRelease(event) {
+        clearInteractionHandle(interactionState, onPanRelease, event, gestureState);
+        PanResponder._initializeGestureState(gestureState);
+      },
+      onResponderTerminate(event) {
+        clearInteractionHandle(interactionState, onPanTerminate, event, gestureState);
+        PanResponder._initializeGestureState(gestureState);
+      },
+      onResponderTerminationRequest(event) {
+        return onPanTerminationRequest != null ? onPanTerminationRequest(event, gestureState) : true;
+      }
+    };
+    return {
+      panHandlers,
+      getInteractionHandle() {
+        return interactionState.handle;
+      }
+    };
+  }
+};
+function clearInteractionHandle(interactionState, callback, event, gestureState) {
+  if (interactionState.handle) {
+    _InteractionManager.default.clearInteractionHandle(interactionState.handle);
+    interactionState.handle = null;
+  }
+  if (callback) {
+    callback(event, gestureState);
+  }
+}
+var _default = exports.default = PanResponder;
+module.exports = exports.default;

package/dist/cjs/exports/PanResponder/index.js

@@ -0,0 +1,8 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.default = void 0;
+var _PanResponder = _interopRequireDefault(require("../../vendor/react-native/PanResponder"));
+var _default = exports.default = _PanResponder.default;
+module.exports = exports.default;

package/dist/cjs/exports/Picker/PickerItem.js

@@ -0,0 +1,32 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.default = PickerItem;
+var _createElement = _interopRequireDefault(require("../createElement"));
+/**
+ * Copyright (c) Nicolas Gallagher.
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+
+function PickerItem(props) {
+  var color = props.color,
+    label = props.label,
+    testID = props.testID,
+    value = props.value;
+  var style = {
+    color
+  };
+  return (0, _createElement.default)('option', {
+    children: label,
+    style,
+    testID,
+    value
+  });
+}
+module.exports = exports.default;