@telus-uds/components-base 4.0.0 → 4.1.0

package/.cache/jest-cache-react-17/jest-transform-cache-351fb7c9421020ab4cca8f7975c30d61-1324230084614362f519ae4cb2580aab/29/PanResponder_29d99859da4a16a7692092bc649721f7

@@ -0,0 +1,154 @@
+5f1f50a9fd18d1d7db2a7b4573d488b4
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var InteractionManager = require('./InteractionManager').default;
+var TouchHistoryMath = require('./TouchHistoryMath').default;
+var currentCentroidXOfTouchesChangedAfter = TouchHistoryMath.currentCentroidXOfTouchesChangedAfter;
+var currentCentroidYOfTouchesChangedAfter = TouchHistoryMath.currentCentroidYOfTouchesChangedAfter;
+var previousCentroidXOfTouchesChangedAfter = TouchHistoryMath.previousCentroidXOfTouchesChangedAfter;
+var previousCentroidYOfTouchesChangedAfter = TouchHistoryMath.previousCentroidYOfTouchesChangedAfter;
+var currentCentroidX = TouchHistoryMath.currentCentroidX;
+var currentCentroidY = TouchHistoryMath.currentCentroidY;
+var PanResponder = {
+  _initializeGestureState: function _initializeGestureState(gestureState) {
+    gestureState.moveX = 0;
+    gestureState.moveY = 0;
+    gestureState.x0 = 0;
+    gestureState.y0 = 0;
+    gestureState.dx = 0;
+    gestureState.dy = 0;
+    gestureState.vx = 0;
+    gestureState.vy = 0;
+    gestureState.numberActiveTouches = 0;
+    gestureState._accountsForMovesUpTo = 0;
+  },
+  _updateGestureStateOnMove: function _updateGestureStateOnMove(gestureState, touchHistory) {
+    gestureState.numberActiveTouches = touchHistory.numberActiveTouches;
+    gestureState.moveX = currentCentroidXOfTouchesChangedAfter(touchHistory, gestureState._accountsForMovesUpTo);
+    gestureState.moveY = currentCentroidYOfTouchesChangedAfter(touchHistory, gestureState._accountsForMovesUpTo);
+    var movedAfter = gestureState._accountsForMovesUpTo;
+    var prevX = previousCentroidXOfTouchesChangedAfter(touchHistory, movedAfter);
+    var x = currentCentroidXOfTouchesChangedAfter(touchHistory, movedAfter);
+    var prevY = previousCentroidYOfTouchesChangedAfter(touchHistory, movedAfter);
+    var y = currentCentroidYOfTouchesChangedAfter(touchHistory, movedAfter);
+    var nextDX = gestureState.dx + (x - prevX);
+    var nextDY = gestureState.dy + (y - prevY);
+    var dt = touchHistory.mostRecentTimeStamp - gestureState._accountsForMovesUpTo;
+    gestureState.vx = (nextDX - gestureState.dx) / dt;
+    gestureState.vy = (nextDY - gestureState.dy) / dt;
+    gestureState.dx = nextDX;
+    gestureState.dy = nextDY;
+    gestureState._accountsForMovesUpTo = touchHistory.mostRecentTimeStamp;
+  },
+  create: function create(config) {
+    var interactionState = {
+      handle: null
+    };
+    var gestureState = {
+      stateID: Math.random(),
+      moveX: 0,
+      moveY: 0,
+      x0: 0,
+      y0: 0,
+      dx: 0,
+      dy: 0,
+      vx: 0,
+      vy: 0,
+      numberActiveTouches: 0,
+      _accountsForMovesUpTo: 0
+    };
+    var panHandlers = {
+      onStartShouldSetResponder: function onStartShouldSetResponder(event) {
+        return config.onStartShouldSetPanResponder == null ? false : config.onStartShouldSetPanResponder(event, gestureState);
+      },
+      onMoveShouldSetResponder: function onMoveShouldSetResponder(event) {
+        return config.onMoveShouldSetPanResponder == null ? false : config.onMoveShouldSetPanResponder(event, gestureState);
+      },
+      onStartShouldSetResponderCapture: function onStartShouldSetResponderCapture(event) {
+        if (event.nativeEvent.touches.length === 1) {
+          PanResponder._initializeGestureState(gestureState);
+        }
+        gestureState.numberActiveTouches = event.touchHistory.numberActiveTouches;
+        return config.onStartShouldSetPanResponderCapture != null ? config.onStartShouldSetPanResponderCapture(event, gestureState) : false;
+      },
+      onMoveShouldSetResponderCapture: function onMoveShouldSetResponderCapture(event) {
+        var touchHistory = event.touchHistory;
+        if (gestureState._accountsForMovesUpTo === touchHistory.mostRecentTimeStamp) {
+          return false;
+        }
+        PanResponder._updateGestureStateOnMove(gestureState, touchHistory);
+        return config.onMoveShouldSetPanResponderCapture ? config.onMoveShouldSetPanResponderCapture(event, gestureState) : false;
+      },
+      onResponderGrant: function onResponderGrant(event) {
+        if (!interactionState.handle) {
+          interactionState.handle = InteractionManager.createInteractionHandle();
+        }
+        gestureState.x0 = currentCentroidX(event.touchHistory);
+        gestureState.y0 = currentCentroidY(event.touchHistory);
+        gestureState.dx = 0;
+        gestureState.dy = 0;
+        if (config.onPanResponderGrant) {
+          config.onPanResponderGrant(event, gestureState);
+        }
+        return config.onShouldBlockNativeResponder == null ? true : config.onShouldBlockNativeResponder(event, gestureState);
+      },
+      onResponderReject: function onResponderReject(event) {
+        clearInteractionHandle(interactionState, config.onPanResponderReject, event, gestureState);
+      },
+      onResponderRelease: function onResponderRelease(event) {
+        clearInteractionHandle(interactionState, config.onPanResponderRelease, event, gestureState);
+        PanResponder._initializeGestureState(gestureState);
+      },
+      onResponderStart: function onResponderStart(event) {
+        var touchHistory = event.touchHistory;
+        gestureState.numberActiveTouches = touchHistory.numberActiveTouches;
+        if (config.onPanResponderStart) {
+          config.onPanResponderStart(event, gestureState);
+        }
+      },
+      onResponderMove: function onResponderMove(event) {
+        var touchHistory = event.touchHistory;
+        if (gestureState._accountsForMovesUpTo === touchHistory.mostRecentTimeStamp) {
+          return;
+        }
+        PanResponder._updateGestureStateOnMove(gestureState, touchHistory);
+        if (config.onPanResponderMove) {
+          config.onPanResponderMove(event, gestureState);
+        }
+      },
+      onResponderEnd: function onResponderEnd(event) {
+        var touchHistory = event.touchHistory;
+        gestureState.numberActiveTouches = touchHistory.numberActiveTouches;
+        clearInteractionHandle(interactionState, config.onPanResponderEnd, event, gestureState);
+      },
+      onResponderTerminate: function onResponderTerminate(event) {
+        clearInteractionHandle(interactionState, config.onPanResponderTerminate, event, gestureState);
+        PanResponder._initializeGestureState(gestureState);
+      },
+      onResponderTerminationRequest: function onResponderTerminationRequest(event) {
+        return config.onPanResponderTerminationRequest == null ? true : config.onPanResponderTerminationRequest(event, gestureState);
+      }
+    };
+    return {
+      panHandlers: panHandlers,
+      getInteractionHandle: function getInteractionHandle() {
+        return interactionState.handle;
+      }
+    };
+  }
+};
+function clearInteractionHandle(interactionState, callback, event, gestureState) {
+  if (interactionState.handle) {
+    InteractionManager.clearInteractionHandle(interactionState.handle);
+    interactionState.handle = null;
+  }
+  if (callback) {
+    callback(event, gestureState);
+  }
+}
+var _default = exports.default = PanResponder;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["Object","defineProperty","exports","value","default","InteractionManager","require","TouchHistoryMath","currentCentroidXOfTouchesChangedAfter","currentCentroidYOfTouchesChangedAfter","previousCentroidXOfTouchesChangedAfter","previousCentroidYOfTouchesChangedAfter","currentCentroidX","currentCentroidY","PanResponder","_initializeGestureState","gestureState","moveX","moveY","x0","y0","dx","dy","vx","vy","numberActiveTouches","_accountsForMovesUpTo","_updateGestureStateOnMove","touchHistory","movedAfter","prevX","x","prevY","y","nextDX","nextDY","dt","mostRecentTimeStamp","create","config","interactionState","handle","stateID","Math","random","panHandlers","onStartShouldSetResponder","event","onStartShouldSetPanResponder","onMoveShouldSetResponder","onMoveShouldSetPanResponder","onStartShouldSetResponderCapture","nativeEvent","touches","length","onStartShouldSetPanResponderCapture","onMoveShouldSetResponderCapture","onMoveShouldSetPanResponderCapture","onResponderGrant","createInteractionHandle","onPanResponderGrant","onShouldBlockNativeResponder","onResponderReject","clearInteractionHandle","onPanResponderReject","onResponderRelease","onPanResponderRelease","onResponderStart","onPanResponderStart","onResponderMove","onPanResponderMove","onResponderEnd","onPanResponderEnd","onResponderTerminate","onPanResponderTerminate","onResponderTerminationRequest","onPanResponderTerminationRequest","getInteractionHandle","callback","_default"],"sources":["PanResponder.js"],"sourcesContent":["/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @flow\n * @format\n */\n\n'use strict';\n\nimport type {GestureResponderEvent} from '../Types/CoreEventTypes';\n\nconst InteractionManager = require('./InteractionManager').default;\nconst TouchHistoryMath = require('./TouchHistoryMath').default;\n\nconst currentCentroidXOfTouchesChangedAfter =\n  TouchHistoryMath.currentCentroidXOfTouchesChangedAfter;\nconst currentCentroidYOfTouchesChangedAfter =\n  TouchHistoryMath.currentCentroidYOfTouchesChangedAfter;\nconst previousCentroidXOfTouchesChangedAfter =\n  TouchHistoryMath.previousCentroidXOfTouchesChangedAfter;\nconst previousCentroidYOfTouchesChangedAfter =\n  TouchHistoryMath.previousCentroidYOfTouchesChangedAfter;\nconst currentCentroidX = TouchHistoryMath.currentCentroidX;\nconst currentCentroidY = TouchHistoryMath.currentCentroidY;\n\n/**\n * `PanResponder` reconciles several touches into a single gesture. It makes\n * single-touch gestures resilient to extra touches, and can be used to\n * recognize simple multi-touch gestures.\n *\n * By default, `PanResponder` holds an `InteractionManager` handle to block\n * long-running JS events from interrupting active gestures.\n *\n * It provides a predictable wrapper of the responder handlers provided by the\n * [gesture responder system](docs/gesture-responder-system.html).\n * For each handler, it provides a new `gestureState` object alongside the\n * native event object:\n *\n * ```\n * onPanResponderMove: (event, gestureState) => {}\n * ```\n *\n * A native event is a synthetic touch event with the following form:\n *\n *  - `nativeEvent`\n *      + `changedTouches` - Array of all touch events that have changed since the last event\n *      + `identifier` - The ID of the touch\n *      + `locationX` - The X position of the touch, relative to the element\n *      + `locationY` - The Y position of the touch, relative to the element\n *      + `pageX` - The X position of the touch, relative to the root element\n *      + `pageY` - The Y position of the touch, relative to the root element\n *      + `target` - The node id of the element receiving the touch event\n *      + `timestamp` - A time identifier for the touch, useful for velocity calculation\n *      + `touches` - Array of all current touches on the screen\n *\n * A `gestureState` object has the following:\n *\n *  - `stateID` - ID of the gestureState- persisted as long as there at least\n *     one touch on screen\n *  - `moveX` - the latest screen coordinates of the recently-moved touch\n *  - `moveY` - the latest screen coordinates of the recently-moved touch\n *  - `x0` - the screen coordinates of the responder grant\n *  - `y0` - the screen coordinates of the responder grant\n *  - `dx` - accumulated distance of the gesture since the touch started\n *  - `dy` - accumulated distance of the gesture since the touch started\n *  - `vx` - current velocity of the gesture\n *  - `vy` - current velocity of the gesture\n *  - `numberActiveTouches` - Number of touches currently on screen\n *\n * ### Basic Usage\n *\n * ```\n *   componentWillMount: function() {\n *     this._panResponder = PanResponder.create({\n *       // Ask to be the responder:\n *       onStartShouldSetPanResponder: (evt, gestureState) => true,\n *       onStartShouldSetPanResponderCapture: (evt, gestureState) => true,\n *       onMoveShouldSetPanResponder: (evt, gestureState) => true,\n *       onMoveShouldSetPanResponderCapture: (evt, gestureState) => true,\n *\n *       onPanResponderGrant: (evt, gestureState) => {\n *         // The gesture has started. Show visual feedback so the user knows\n *         // what is happening!\n *\n *         // gestureState.d{x,y} will be set to zero now\n *       },\n *       onPanResponderMove: (evt, gestureState) => {\n *         // The most recent move distance is gestureState.move{X,Y}\n *\n *         // The accumulated gesture distance since becoming responder is\n *         // gestureState.d{x,y}\n *       },\n *       onPanResponderTerminationRequest: (evt, gestureState) => true,\n *       onPanResponderRelease: (evt, gestureState) => {\n *         // The user has released all touches while this view is the\n *         // responder. This typically means a gesture has succeeded\n *       },\n *       onPanResponderTerminate: (evt, gestureState) => {\n *         // Another component has become the responder, so this gesture\n *         // should be cancelled\n *       },\n *       onShouldBlockNativeResponder: (evt, gestureState) => {\n *         // Returns whether this component should block native components from becoming the JS\n *         // responder. Returns true by default. Is currently only supported on android.\n *         return true;\n *       },\n *     });\n *   },\n *\n *   render: function() {\n *     return (\n *       <View {...this._panResponder.panHandlers} />\n *     );\n *   },\n *\n * ```\n *\n * ### Working Example\n *\n * To see it in action, try the\n * [PanResponder example in RNTester](https://github.com/facebook/react-native/blob/HEAD/packages/rn-tester/js/examples/PanResponder/PanResponderExample.js)\n */\n\nexport type PanResponderGestureState = {\n  /**\n   * ID of the gestureState - persisted as long as there at least one touch on screen\n   */\n  stateID: number,\n\n  /**\n   * The latest screen coordinates of the recently-moved touch\n   */\n  moveX: number,\n\n  /**\n   * The latest screen coordinates of the recently-moved touch\n   */\n  moveY: number,\n\n  /**\n   * The screen coordinates of the responder grant\n   */\n  x0: number,\n\n  /**\n   * The screen coordinates of the responder grant\n   */\n  y0: number,\n\n  /**\n   * Accumulated distance of the gesture since the touch started\n   */\n  dx: number,\n\n  /**\n   * Accumulated distance of the gesture since the touch started\n   */\n  dy: number,\n\n  /**\n   * Current velocity of the gesture\n   */\n  vx: number,\n\n  /**\n   * Current velocity of the gesture\n   */\n  vy: number,\n\n  /**\n   * Number of touches currently on screen\n   */\n  numberActiveTouches: number,\n\n  /**\n   * All `gestureState` accounts for timeStamps up until this value\n   *\n   * @private\n   */\n  _accountsForMovesUpTo: number,\n};\n\ntype ActiveCallback = (\n  event: GestureResponderEvent,\n  gestureState: PanResponderGestureState,\n) => boolean;\n\ntype PassiveCallback = (\n  event: GestureResponderEvent,\n  gestureState: PanResponderGestureState,\n) => mixed;\n\nexport type GestureResponderHandlerMethods = {\n  onMoveShouldSetResponder: (event: GestureResponderEvent) => boolean,\n  onMoveShouldSetResponderCapture: (event: GestureResponderEvent) => boolean,\n  onResponderEnd: (event: GestureResponderEvent) => void,\n  onResponderGrant: (event: GestureResponderEvent) => boolean,\n  onResponderMove: (event: GestureResponderEvent) => void,\n  onResponderReject: (event: GestureResponderEvent) => void,\n  onResponderRelease: (event: GestureResponderEvent) => void,\n  onResponderStart: (event: GestureResponderEvent) => void,\n  onResponderTerminate: (event: GestureResponderEvent) => void,\n  onResponderTerminationRequest: (event: GestureResponderEvent) => boolean,\n  onStartShouldSetResponder: (event: GestureResponderEvent) => boolean,\n  onStartShouldSetResponderCapture: (event: GestureResponderEvent) => boolean,\n};\n\nexport type PanResponderCallbacks = $ReadOnly<{\n  onMoveShouldSetPanResponder?: ?ActiveCallback,\n  onMoveShouldSetPanResponderCapture?: ?ActiveCallback,\n  onStartShouldSetPanResponder?: ?ActiveCallback,\n  onStartShouldSetPanResponderCapture?: ?ActiveCallback,\n  /**\n   * The body of `onResponderGrant` returns a bool, but the vast majority of\n   * callsites return void and this TODO notice is found in it:\n   *   TODO: t7467124 investigate if this can be removed\n   */\n  onPanResponderGrant?: ?(PassiveCallback | ActiveCallback),\n  onPanResponderReject?: ?PassiveCallback,\n  onPanResponderStart?: ?PassiveCallback,\n  onPanResponderEnd?: ?PassiveCallback,\n  onPanResponderRelease?: ?PassiveCallback,\n  onPanResponderMove?: ?PassiveCallback,\n  onPanResponderTerminate?: ?PassiveCallback,\n  onPanResponderTerminationRequest?: ?ActiveCallback,\n  onShouldBlockNativeResponder?: ?ActiveCallback,\n}>;\n\nconst PanResponder = {\n  /**\n   *\n   * A graphical explanation of the touch data flow:\n   *\n   * +----------------------------+             +--------------------------------+\n   * | ResponderTouchHistoryStore |             |TouchHistoryMath                |\n   * +----------------------------+             +----------+---------------------+\n   * |Global store of touchHistory|             |Allocation-less math util       |\n   * |including activeness, start |             |on touch history (centroids     |\n   * |position, prev/cur position.|             |and multitouch movement etc)    |\n   * |                            |             |                                |\n   * +----^-----------------------+             +----^---------------------------+\n   *      |                                          |\n   *      | (records relevant history                |\n   *      |  of touches relevant for                 |\n   *      |  implementing higher level               |\n   *      |  gestures)                               |\n   *      |                                          |\n   * +----+-----------------------+             +----|---------------------------+\n   * | ResponderEventPlugin       |             |    |   Your App/Component      |\n   * +----------------------------+             +----|---------------------------+\n   * |Negotiates which view gets  | Low level   |    |             High level    |\n   * |onResponderMove events.     | events w/   |  +-+-------+     events w/     |\n   * |Also records history into   | touchHistory|  |   Pan   |     multitouch +  |\n   * |ResponderTouchHistoryStore. +---------------->Responder+-----> accumulative|\n   * +----------------------------+ attached to |  |         |     distance and  |\n   *                                 each event |  +---------+     velocity.     |\n   *                                            |                                |\n   *                                            |                                |\n   *                                            +--------------------------------+\n   *\n   *\n   *\n   * Gesture that calculates cumulative movement over time in a way that just\n   * \"does the right thing\" for multiple touches. The \"right thing\" is very\n   * nuanced. When moving two touches in opposite directions, the cumulative\n   * distance is zero in each dimension. When two touches move in parallel five\n   * pixels in the same direction, the cumulative distance is five, not ten. If\n   * two touches start, one moves five in a direction, then stops and the other\n   * touch moves fives in the same direction, the cumulative distance is ten.\n   *\n   * This logic requires a kind of processing of time \"clusters\" of touch events\n   * so that two touch moves that essentially occur in parallel but move every\n   * other frame respectively, are considered part of the same movement.\n   *\n   * Explanation of some of the non-obvious fields:\n   *\n   * - moveX/moveY: If no move event has been observed, then `(moveX, moveY)` is\n   *   invalid. If a move event has been observed, `(moveX, moveY)` is the\n   *   centroid of the most recently moved \"cluster\" of active touches.\n   *   (Currently all move have the same timeStamp, but later we should add some\n   *   threshold for what is considered to be \"moving\"). If a palm is\n   *   accidentally counted as a touch, but a finger is moving greatly, the palm\n   *   will move slightly, but we only want to count the single moving touch.\n   * - x0/y0: Centroid location (non-cumulative) at the time of becoming\n   *   responder.\n   * - dx/dy: Cumulative touch distance - not the same thing as sum of each touch\n   *   distance. Accounts for touch moves that are clustered together in time,\n   *   moving the same direction. Only valid when currently responder (otherwise,\n   *   it only represents the drag distance below the threshold).\n   * - vx/vy: Velocity.\n   */\n\n  _initializeGestureState(gestureState: PanResponderGestureState) {\n    gestureState.moveX = 0;\n    gestureState.moveY = 0;\n    gestureState.x0 = 0;\n    gestureState.y0 = 0;\n    gestureState.dx = 0;\n    gestureState.dy = 0;\n    gestureState.vx = 0;\n    gestureState.vy = 0;\n    gestureState.numberActiveTouches = 0;\n    // All `gestureState` accounts for timeStamps up until:\n    gestureState._accountsForMovesUpTo = 0;\n  },\n\n  /**\n   * This is nuanced and is necessary. It is incorrect to continuously take all\n   * active *and* recently moved touches, find the centroid, and track how that\n   * result changes over time. Instead, we must take all recently moved\n   * touches, and calculate how the centroid has changed just for those\n   * recently moved touches, and append that change to an accumulator. This is\n   * to (at least) handle the case where the user is moving three fingers, and\n   * then one of the fingers stops but the other two continue.\n   *\n   * This is very different than taking all of the recently moved touches and\n   * storing their centroid as `dx/dy`. For correctness, we must *accumulate\n   * changes* in the centroid of recently moved touches.\n   *\n   * There is also some nuance with how we handle multiple moved touches in a\n   * single event. With the way `ReactNativeEventEmitter` dispatches touches as\n   * individual events, multiple touches generate two 'move' events, each of\n   * them triggering `onResponderMove`. But with the way `PanResponder` works,\n   * all of the gesture inference is performed on the first dispatch, since it\n   * looks at all of the touches (even the ones for which there hasn't been a\n   * native dispatch yet). Therefore, `PanResponder` does not call\n   * `onResponderMove` passed the first dispatch. This diverges from the\n   * typical responder callback pattern (without using `PanResponder`), but\n   * avoids more dispatches than necessary.\n   */\n  _updateGestureStateOnMove(\n    gestureState: PanResponderGestureState,\n    touchHistory: GestureResponderEvent['touchHistory'],\n  ) {\n    gestureState.numberActiveTouches = touchHistory.numberActiveTouches;\n    gestureState.moveX = currentCentroidXOfTouchesChangedAfter(\n      touchHistory,\n      gestureState._accountsForMovesUpTo,\n    );\n    gestureState.moveY = currentCentroidYOfTouchesChangedAfter(\n      touchHistory,\n      gestureState._accountsForMovesUpTo,\n    );\n    const movedAfter = gestureState._accountsForMovesUpTo;\n    const prevX = previousCentroidXOfTouchesChangedAfter(\n      touchHistory,\n      movedAfter,\n    );\n    const x = currentCentroidXOfTouchesChangedAfter(touchHistory, movedAfter);\n    const prevY = previousCentroidYOfTouchesChangedAfter(\n      touchHistory,\n      movedAfter,\n    );\n    const y = currentCentroidYOfTouchesChangedAfter(touchHistory, movedAfter);\n    const nextDX = gestureState.dx + (x - prevX);\n    const nextDY = gestureState.dy + (y - prevY);\n\n    // TODO: This must be filtered intelligently.\n    const dt =\n      touchHistory.mostRecentTimeStamp - gestureState._accountsForMovesUpTo;\n    gestureState.vx = (nextDX - gestureState.dx) / dt;\n    gestureState.vy = (nextDY - gestureState.dy) / dt;\n\n    gestureState.dx = nextDX;\n    gestureState.dy = nextDY;\n    gestureState._accountsForMovesUpTo = touchHistory.mostRecentTimeStamp;\n  },\n\n  /**\n   * @param {object} config Enhanced versions of all of the responder callbacks\n   * that provide not only the typical `ResponderSyntheticEvent`, but also the\n   * `PanResponder` gesture state.  Simply replace the word `Responder` with\n   * `PanResponder` in each of the typical `onResponder*` callbacks. For\n   * example, the `config` object would look like:\n   *\n   *  - `onMoveShouldSetPanResponder: (e, gestureState) => {...}`\n   *  - `onMoveShouldSetPanResponderCapture: (e, gestureState) => {...}`\n   *  - `onStartShouldSetPanResponder: (e, gestureState) => {...}`\n   *  - `onStartShouldSetPanResponderCapture: (e, gestureState) => {...}`\n   *  - `onPanResponderReject: (e, gestureState) => {...}`\n   *  - `onPanResponderGrant: (e, gestureState) => {...}`\n   *  - `onPanResponderStart: (e, gestureState) => {...}`\n   *  - `onPanResponderEnd: (e, gestureState) => {...}`\n   *  - `onPanResponderRelease: (e, gestureState) => {...}`\n   *  - `onPanResponderMove: (e, gestureState) => {...}`\n   *  - `onPanResponderTerminate: (e, gestureState) => {...}`\n   *  - `onPanResponderTerminationRequest: (e, gestureState) => {...}`\n   *  - `onShouldBlockNativeResponder: (e, gestureState) => {...}`\n   *\n   *  In general, for events that have capture equivalents, we update the\n   *  gestureState once in the capture phase and can use it in the bubble phase\n   *  as well.\n   *\n   *  Be careful with onStartShould* callbacks. They only reflect updated\n   *  `gestureState` for start/end events that bubble/capture to the Node.\n   *  Once the node is the responder, you can rely on every start/end event\n   *  being processed by the gesture and `gestureState` being updated\n   *  accordingly. (numberActiveTouches) may not be totally accurate unless you\n   *  are the responder.\n   */\n  create(config: PanResponderCallbacks): {\n    getInteractionHandle: () => ?number,\n    panHandlers: GestureResponderHandlerMethods,\n  } {\n    const interactionState = {\n      handle: (null: ?number),\n    };\n    const gestureState: PanResponderGestureState = {\n      // Useful for debugging\n      stateID: Math.random(),\n      moveX: 0,\n      moveY: 0,\n      x0: 0,\n      y0: 0,\n      dx: 0,\n      dy: 0,\n      vx: 0,\n      vy: 0,\n      numberActiveTouches: 0,\n      _accountsForMovesUpTo: 0,\n    };\n    const panHandlers = {\n      onStartShouldSetResponder(event: GestureResponderEvent): boolean {\n        return config.onStartShouldSetPanResponder == null\n          ? false\n          : config.onStartShouldSetPanResponder(event, gestureState);\n      },\n      onMoveShouldSetResponder(event: GestureResponderEvent): boolean {\n        return config.onMoveShouldSetPanResponder == null\n          ? false\n          : config.onMoveShouldSetPanResponder(event, gestureState);\n      },\n      onStartShouldSetResponderCapture(event: GestureResponderEvent): boolean {\n        // TODO: Actually, we should reinitialize the state any time\n        // touches.length increases from 0 active to > 0 active.\n        if (event.nativeEvent.touches.length === 1) {\n          PanResponder._initializeGestureState(gestureState);\n        }\n        gestureState.numberActiveTouches =\n          event.touchHistory.numberActiveTouches;\n        return config.onStartShouldSetPanResponderCapture != null\n          ? config.onStartShouldSetPanResponderCapture(event, gestureState)\n          : false;\n      },\n\n      onMoveShouldSetResponderCapture(event: GestureResponderEvent): boolean {\n        const touchHistory = event.touchHistory;\n        // Responder system incorrectly dispatches should* to current responder\n        // Filter out any touch moves past the first one - we would have\n        // already processed multi-touch geometry during the first event.\n        if (\n          gestureState._accountsForMovesUpTo ===\n          touchHistory.mostRecentTimeStamp\n        ) {\n          return false;\n        }\n        PanResponder._updateGestureStateOnMove(gestureState, touchHistory);\n        return config.onMoveShouldSetPanResponderCapture\n          ? config.onMoveShouldSetPanResponderCapture(event, gestureState)\n          : false;\n      },\n\n      onResponderGrant(event: GestureResponderEvent): boolean {\n        if (!interactionState.handle) {\n          interactionState.handle =\n            InteractionManager.createInteractionHandle();\n        }\n        gestureState.x0 = currentCentroidX(event.touchHistory);\n        gestureState.y0 = currentCentroidY(event.touchHistory);\n        gestureState.dx = 0;\n        gestureState.dy = 0;\n        if (config.onPanResponderGrant) {\n          config.onPanResponderGrant(event, gestureState);\n        }\n        // TODO: t7467124 investigate if this can be removed\n        return config.onShouldBlockNativeResponder == null\n          ? true\n          : config.onShouldBlockNativeResponder(event, gestureState);\n      },\n\n      onResponderReject(event: GestureResponderEvent): void {\n        clearInteractionHandle(\n          interactionState,\n          config.onPanResponderReject,\n          event,\n          gestureState,\n        );\n      },\n\n      onResponderRelease(event: GestureResponderEvent): void {\n        clearInteractionHandle(\n          interactionState,\n          config.onPanResponderRelease,\n          event,\n          gestureState,\n        );\n        PanResponder._initializeGestureState(gestureState);\n      },\n\n      onResponderStart(event: GestureResponderEvent): void {\n        const touchHistory = event.touchHistory;\n        gestureState.numberActiveTouches = touchHistory.numberActiveTouches;\n        if (config.onPanResponderStart) {\n          config.onPanResponderStart(event, gestureState);\n        }\n      },\n\n      onResponderMove(event: GestureResponderEvent): void {\n        const touchHistory = event.touchHistory;\n        // Guard against the dispatch of two touch moves when there are two\n        // simultaneously changed touches.\n        if (\n          gestureState._accountsForMovesUpTo ===\n          touchHistory.mostRecentTimeStamp\n        ) {\n          return;\n        }\n        // Filter out any touch moves past the first one - we would have\n        // already processed multi-touch geometry during the first event.\n        PanResponder._updateGestureStateOnMove(gestureState, touchHistory);\n        if (config.onPanResponderMove) {\n          config.onPanResponderMove(event, gestureState);\n        }\n      },\n\n      onResponderEnd(event: GestureResponderEvent): void {\n        const touchHistory = event.touchHistory;\n        gestureState.numberActiveTouches = touchHistory.numberActiveTouches;\n        clearInteractionHandle(\n          interactionState,\n          config.onPanResponderEnd,\n          event,\n          gestureState,\n        );\n      },\n\n      onResponderTerminate(event: GestureResponderEvent): void {\n        clearInteractionHandle(\n          interactionState,\n          config.onPanResponderTerminate,\n          event,\n          gestureState,\n        );\n        PanResponder._initializeGestureState(gestureState);\n      },\n\n      onResponderTerminationRequest(event: GestureResponderEvent): boolean {\n        return config.onPanResponderTerminationRequest == null\n          ? true\n          : config.onPanResponderTerminationRequest(event, gestureState);\n      },\n    };\n    return {\n      panHandlers,\n      getInteractionHandle(): ?number {\n        return interactionState.handle;\n      },\n    };\n  },\n};\n\nfunction clearInteractionHandle(\n  interactionState: {handle: ?number, ...},\n  callback: ?(ActiveCallback | PassiveCallback),\n  event: GestureResponderEvent,\n  gestureState: PanResponderGestureState,\n) {\n  if (interactionState.handle) {\n    InteractionManager.clearInteractionHandle(interactionState.handle);\n    interactionState.handle = null;\n  }\n  if (callback) {\n    callback(event, gestureState);\n  }\n}\n\nexport type PanResponderInstance = ReturnType<(typeof PanResponder)['create']>;\n\nexport default PanResponder;\n"],"mappings":"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","ignoreList":[]}

package/.cache/jest-cache-react-17/jest-transform-cache-351fb7c9421020ab4cca8f7975c30d61-1324230084614362f519ae4cb2580aab/29/PanResponder_29d99859da4a16a7692092bc649721f7.map

@@ -0,0 +1 @@
+{"version":3,"names":["Object","defineProperty","exports","value","default","InteractionManager","require","TouchHistoryMath","currentCentroidXOfTouchesChangedAfter","currentCentroidYOfTouchesChangedAfter","previousCentroidXOfTouchesChangedAfter","previousCentroidYOfTouchesChangedAfter","currentCentroidX","currentCentroidY","PanResponder","_initializeGestureState","gestureState","moveX","moveY","x0","y0","dx","dy","vx","vy","numberActiveTouches","_accountsForMovesUpTo","_updateGestureStateOnMove","touchHistory","movedAfter","prevX","x","prevY","y","nextDX","nextDY","dt","mostRecentTimeStamp","create","config","interactionState","handle","stateID","Math","random","panHandlers","onStartShouldSetResponder","event","onStartShouldSetPanResponder","onMoveShouldSetResponder","onMoveShouldSetPanResponder","onStartShouldSetResponderCapture","nativeEvent","touches","length","onStartShouldSetPanResponderCapture","onMoveShouldSetResponderCapture","onMoveShouldSetPanResponderCapture","onResponderGrant","createInteractionHandle","onPanResponderGrant","onShouldBlockNativeResponder","onResponderReject","clearInteractionHandle","onPanResponderReject","onResponderRelease","onPanResponderRelease","onResponderStart","onPanResponderStart","onResponderMove","onPanResponderMove","onResponderEnd","onPanResponderEnd","onResponderTerminate","onPanResponderTerminate","onResponderTerminationRequest","onPanResponderTerminationRequest","getInteractionHandle","callback","_default"],"sources":["PanResponder.js"],"sourcesContent":["/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @flow\n * @format\n */\n\n'use strict';\n\nimport type {GestureResponderEvent} from '../Types/CoreEventTypes';\n\nconst InteractionManager = require('./InteractionManager').default;\nconst TouchHistoryMath = require('./TouchHistoryMath').default;\n\nconst currentCentroidXOfTouchesChangedAfter =\n  TouchHistoryMath.currentCentroidXOfTouchesChangedAfter;\nconst currentCentroidYOfTouchesChangedAfter =\n  TouchHistoryMath.currentCentroidYOfTouchesChangedAfter;\nconst previousCentroidXOfTouchesChangedAfter =\n  TouchHistoryMath.previousCentroidXOfTouchesChangedAfter;\nconst previousCentroidYOfTouchesChangedAfter =\n  TouchHistoryMath.previousCentroidYOfTouchesChangedAfter;\nconst currentCentroidX = TouchHistoryMath.currentCentroidX;\nconst currentCentroidY = TouchHistoryMath.currentCentroidY;\n\n/**\n * `PanResponder` reconciles several touches into a single gesture. It makes\n * single-touch gestures resilient to extra touches, and can be used to\n * recognize simple multi-touch gestures.\n *\n * By default, `PanResponder` holds an `InteractionManager` handle to block\n * long-running JS events from interrupting active gestures.\n *\n * It provides a predictable wrapper of the responder handlers provided by the\n * [gesture responder system](docs/gesture-responder-system.html).\n * For each handler, it provides a new `gestureState` object alongside the\n * native event object:\n *\n * ```\n * onPanResponderMove: (event, gestureState) => {}\n * ```\n *\n * A native event is a synthetic touch event with the following form:\n *\n *  - `nativeEvent`\n *      + `changedTouches` - Array of all touch events that have changed since the last event\n *      + `identifier` - The ID of the touch\n *      + `locationX` - The X position of the touch, relative to the element\n *      + `locationY` - The Y position of the touch, relative to the element\n *      + `pageX` - The X position of the touch, relative to the root element\n *      + `pageY` - The Y position of the touch, relative to the root element\n *      + `target` - The node id of the element receiving the touch event\n *      + `timestamp` - A time identifier for the touch, useful for velocity calculation\n *      + `touches` - Array of all current touches on the screen\n *\n * A `gestureState` object has the following:\n *\n *  - `stateID` - ID of the gestureState- persisted as long as there at least\n *     one touch on screen\n *  - `moveX` - the latest screen coordinates of the recently-moved touch\n *  - `moveY` - the latest screen coordinates of the recently-moved touch\n *  - `x0` - the screen coordinates of the responder grant\n *  - `y0` - the screen coordinates of the responder grant\n *  - `dx` - accumulated distance of the gesture since the touch started\n *  - `dy` - accumulated distance of the gesture since the touch started\n *  - `vx` - current velocity of the gesture\n *  - `vy` - current velocity of the gesture\n *  - `numberActiveTouches` - Number of touches currently on screen\n *\n * ### Basic Usage\n *\n * ```\n *   componentWillMount: function() {\n *     this._panResponder = PanResponder.create({\n *       // Ask to be the responder:\n *       onStartShouldSetPanResponder: (evt, gestureState) => true,\n *       onStartShouldSetPanResponderCapture: (evt, gestureState) => true,\n *       onMoveShouldSetPanResponder: (evt, gestureState) => true,\n *       onMoveShouldSetPanResponderCapture: (evt, gestureState) => true,\n *\n *       onPanResponderGrant: (evt, gestureState) => {\n *         // The gesture has started. Show visual feedback so the user knows\n *         // what is happening!\n *\n *         // gestureState.d{x,y} will be set to zero now\n *       },\n *       onPanResponderMove: (evt, gestureState) => {\n *         // The most recent move distance is gestureState.move{X,Y}\n *\n *         // The accumulated gesture distance since becoming responder is\n *         // gestureState.d{x,y}\n *       },\n *       onPanResponderTerminationRequest: (evt, gestureState) => true,\n *       onPanResponderRelease: (evt, gestureState) => {\n *         // The user has released all touches while this view is the\n *         // responder. This typically means a gesture has succeeded\n *       },\n *       onPanResponderTerminate: (evt, gestureState) => {\n *         // Another component has become the responder, so this gesture\n *         // should be cancelled\n *       },\n *       onShouldBlockNativeResponder: (evt, gestureState) => {\n *         // Returns whether this component should block native components from becoming the JS\n *         // responder. Returns true by default. Is currently only supported on android.\n *         return true;\n *       },\n *     });\n *   },\n *\n *   render: function() {\n *     return (\n *       <View {...this._panResponder.panHandlers} />\n *     );\n *   },\n *\n * ```\n *\n * ### Working Example\n *\n * To see it in action, try the\n * [PanResponder example in RNTester](https://github.com/facebook/react-native/blob/HEAD/packages/rn-tester/js/examples/PanResponder/PanResponderExample.js)\n */\n\nexport type PanResponderGestureState = {\n  /**\n   * ID of the gestureState - persisted as long as there at least one touch on screen\n   */\n  stateID: number,\n\n  /**\n   * The latest screen coordinates of the recently-moved touch\n   */\n  moveX: number,\n\n  /**\n   * The latest screen coordinates of the recently-moved touch\n   */\n  moveY: number,\n\n  /**\n   * The screen coordinates of the responder grant\n   */\n  x0: number,\n\n  /**\n   * The screen coordinates of the responder grant\n   */\n  y0: number,\n\n  /**\n   * Accumulated distance of the gesture since the touch started\n   */\n  dx: number,\n\n  /**\n   * Accumulated distance of the gesture since the touch started\n   */\n  dy: number,\n\n  /**\n   * Current velocity of the gesture\n   */\n  vx: number,\n\n  /**\n   * Current velocity of the gesture\n   */\n  vy: number,\n\n  /**\n   * Number of touches currently on screen\n   */\n  numberActiveTouches: number,\n\n  /**\n   * All `gestureState` accounts for timeStamps up until this value\n   *\n   * @private\n   */\n  _accountsForMovesUpTo: number,\n};\n\ntype ActiveCallback = (\n  event: GestureResponderEvent,\n  gestureState: PanResponderGestureState,\n) => boolean;\n\ntype PassiveCallback = (\n  event: GestureResponderEvent,\n  gestureState: PanResponderGestureState,\n) => mixed;\n\nexport type GestureResponderHandlerMethods = {\n  onMoveShouldSetResponder: (event: GestureResponderEvent) => boolean,\n  onMoveShouldSetResponderCapture: (event: GestureResponderEvent) => boolean,\n  onResponderEnd: (event: GestureResponderEvent) => void,\n  onResponderGrant: (event: GestureResponderEvent) => boolean,\n  onResponderMove: (event: GestureResponderEvent) => void,\n  onResponderReject: (event: GestureResponderEvent) => void,\n  onResponderRelease: (event: GestureResponderEvent) => void,\n  onResponderStart: (event: GestureResponderEvent) => void,\n  onResponderTerminate: (event: GestureResponderEvent) => void,\n  onResponderTerminationRequest: (event: GestureResponderEvent) => boolean,\n  onStartShouldSetResponder: (event: GestureResponderEvent) => boolean,\n  onStartShouldSetResponderCapture: (event: GestureResponderEvent) => boolean,\n};\n\nexport type PanResponderCallbacks = $ReadOnly<{\n  onMoveShouldSetPanResponder?: ?ActiveCallback,\n  onMoveShouldSetPanResponderCapture?: ?ActiveCallback,\n  onStartShouldSetPanResponder?: ?ActiveCallback,\n  onStartShouldSetPanResponderCapture?: ?ActiveCallback,\n  /**\n   * The body of `onResponderGrant` returns a bool, but the vast majority of\n   * callsites return void and this TODO notice is found in it:\n   *   TODO: t7467124 investigate if this can be removed\n   */\n  onPanResponderGrant?: ?(PassiveCallback | ActiveCallback),\n  onPanResponderReject?: ?PassiveCallback,\n  onPanResponderStart?: ?PassiveCallback,\n  onPanResponderEnd?: ?PassiveCallback,\n  onPanResponderRelease?: ?PassiveCallback,\n  onPanResponderMove?: ?PassiveCallback,\n  onPanResponderTerminate?: ?PassiveCallback,\n  onPanResponderTerminationRequest?: ?ActiveCallback,\n  onShouldBlockNativeResponder?: ?ActiveCallback,\n}>;\n\nconst PanResponder = {\n  /**\n   *\n   * A graphical explanation of the touch data flow:\n   *\n   * +----------------------------+             +--------------------------------+\n   * | ResponderTouchHistoryStore |             |TouchHistoryMath                |\n   * +----------------------------+             +----------+---------------------+\n   * |Global store of touchHistory|             |Allocation-less math util       |\n   * |including activeness, start |             |on touch history (centroids     |\n   * |position, prev/cur position.|             |and multitouch movement etc)    |\n   * |                            |             |                                |\n   * +----^-----------------------+             +----^---------------------------+\n   *      |                                          |\n   *      | (records relevant history                |\n   *      |  of touches relevant for                 |\n   *      |  implementing higher level               |\n   *      |  gestures)                               |\n   *      |                                          |\n   * +----+-----------------------+             +----|---------------------------+\n   * | ResponderEventPlugin       |             |    |   Your App/Component      |\n   * +----------------------------+             +----|---------------------------+\n   * |Negotiates which view gets  | Low level   |    |             High level    |\n   * |onResponderMove events.     | events w/   |  +-+-------+     events w/     |\n   * |Also records history into   | touchHistory|  |   Pan   |     multitouch +  |\n   * |ResponderTouchHistoryStore. +---------------->Responder+-----> accumulative|\n   * +----------------------------+ attached to |  |         |     distance and  |\n   *                                 each event |  +---------+     velocity.     |\n   *                                            |                                |\n   *                                            |                                |\n   *                                            +--------------------------------+\n   *\n   *\n   *\n   * Gesture that calculates cumulative movement over time in a way that just\n   * \"does the right thing\" for multiple touches. The \"right thing\" is very\n   * nuanced. When moving two touches in opposite directions, the cumulative\n   * distance is zero in each dimension. When two touches move in parallel five\n   * pixels in the same direction, the cumulative distance is five, not ten. If\n   * two touches start, one moves five in a direction, then stops and the other\n   * touch moves fives in the same direction, the cumulative distance is ten.\n   *\n   * This logic requires a kind of processing of time \"clusters\" of touch events\n   * so that two touch moves that essentially occur in parallel but move every\n   * other frame respectively, are considered part of the same movement.\n   *\n   * Explanation of some of the non-obvious fields:\n   *\n   * - moveX/moveY: If no move event has been observed, then `(moveX, moveY)` is\n   *   invalid. If a move event has been observed, `(moveX, moveY)` is the\n   *   centroid of the most recently moved \"cluster\" of active touches.\n   *   (Currently all move have the same timeStamp, but later we should add some\n   *   threshold for what is considered to be \"moving\"). If a palm is\n   *   accidentally counted as a touch, but a finger is moving greatly, the palm\n   *   will move slightly, but we only want to count the single moving touch.\n   * - x0/y0: Centroid location (non-cumulative) at the time of becoming\n   *   responder.\n   * - dx/dy: Cumulative touch distance - not the same thing as sum of each touch\n   *   distance. Accounts for touch moves that are clustered together in time,\n   *   moving the same direction. Only valid when currently responder (otherwise,\n   *   it only represents the drag distance below the threshold).\n   * - vx/vy: Velocity.\n   */\n\n  _initializeGestureState(gestureState: PanResponderGestureState) {\n    gestureState.moveX = 0;\n    gestureState.moveY = 0;\n    gestureState.x0 = 0;\n    gestureState.y0 = 0;\n    gestureState.dx = 0;\n    gestureState.dy = 0;\n    gestureState.vx = 0;\n    gestureState.vy = 0;\n    gestureState.numberActiveTouches = 0;\n    // All `gestureState` accounts for timeStamps up until:\n    gestureState._accountsForMovesUpTo = 0;\n  },\n\n  /**\n   * This is nuanced and is necessary. It is incorrect to continuously take all\n   * active *and* recently moved touches, find the centroid, and track how that\n   * result changes over time. Instead, we must take all recently moved\n   * touches, and calculate how the centroid has changed just for those\n   * recently moved touches, and append that change to an accumulator. This is\n   * to (at least) handle the case where the user is moving three fingers, and\n   * then one of the fingers stops but the other two continue.\n   *\n   * This is very different than taking all of the recently moved touches and\n   * storing their centroid as `dx/dy`. For correctness, we must *accumulate\n   * changes* in the centroid of recently moved touches.\n   *\n   * There is also some nuance with how we handle multiple moved touches in a\n   * single event. With the way `ReactNativeEventEmitter` dispatches touches as\n   * individual events, multiple touches generate two 'move' events, each of\n   * them triggering `onResponderMove`. But with the way `PanResponder` works,\n   * all of the gesture inference is performed on the first dispatch, since it\n   * looks at all of the touches (even the ones for which there hasn't been a\n   * native dispatch yet). Therefore, `PanResponder` does not call\n   * `onResponderMove` passed the first dispatch. This diverges from the\n   * typical responder callback pattern (without using `PanResponder`), but\n   * avoids more dispatches than necessary.\n   */\n  _updateGestureStateOnMove(\n    gestureState: PanResponderGestureState,\n    touchHistory: GestureResponderEvent['touchHistory'],\n  ) {\n    gestureState.numberActiveTouches = touchHistory.numberActiveTouches;\n    gestureState.moveX = currentCentroidXOfTouchesChangedAfter(\n      touchHistory,\n      gestureState._accountsForMovesUpTo,\n    );\n    gestureState.moveY = currentCentroidYOfTouchesChangedAfter(\n      touchHistory,\n      gestureState._accountsForMovesUpTo,\n    );\n    const movedAfter = gestureState._accountsForMovesUpTo;\n    const prevX = previousCentroidXOfTouchesChangedAfter(\n      touchHistory,\n      movedAfter,\n    );\n    const x = currentCentroidXOfTouchesChangedAfter(touchHistory, movedAfter);\n    const prevY = previousCentroidYOfTouchesChangedAfter(\n      touchHistory,\n      movedAfter,\n    );\n    const y = currentCentroidYOfTouchesChangedAfter(touchHistory, movedAfter);\n    const nextDX = gestureState.dx + (x - prevX);\n    const nextDY = gestureState.dy + (y - prevY);\n\n    // TODO: This must be filtered intelligently.\n    const dt =\n      touchHistory.mostRecentTimeStamp - gestureState._accountsForMovesUpTo;\n    gestureState.vx = (nextDX - gestureState.dx) / dt;\n    gestureState.vy = (nextDY - gestureState.dy) / dt;\n\n    gestureState.dx = nextDX;\n    gestureState.dy = nextDY;\n    gestureState._accountsForMovesUpTo = touchHistory.mostRecentTimeStamp;\n  },\n\n  /**\n   * @param {object} config Enhanced versions of all of the responder callbacks\n   * that provide not only the typical `ResponderSyntheticEvent`, but also the\n   * `PanResponder` gesture state.  Simply replace the word `Responder` with\n   * `PanResponder` in each of the typical `onResponder*` callbacks. For\n   * example, the `config` object would look like:\n   *\n   *  - `onMoveShouldSetPanResponder: (e, gestureState) => {...}`\n   *  - `onMoveShouldSetPanResponderCapture: (e, gestureState) => {...}`\n   *  - `onStartShouldSetPanResponder: (e, gestureState) => {...}`\n   *  - `onStartShouldSetPanResponderCapture: (e, gestureState) => {...}`\n   *  - `onPanResponderReject: (e, gestureState) => {...}`\n   *  - `onPanResponderGrant: (e, gestureState) => {...}`\n   *  - `onPanResponderStart: (e, gestureState) => {...}`\n   *  - `onPanResponderEnd: (e, gestureState) => {...}`\n   *  - `onPanResponderRelease: (e, gestureState) => {...}`\n   *  - `onPanResponderMove: (e, gestureState) => {...}`\n   *  - `onPanResponderTerminate: (e, gestureState) => {...}`\n   *  - `onPanResponderTerminationRequest: (e, gestureState) => {...}`\n   *  - `onShouldBlockNativeResponder: (e, gestureState) => {...}`\n   *\n   *  In general, for events that have capture equivalents, we update the\n   *  gestureState once in the capture phase and can use it in the bubble phase\n   *  as well.\n   *\n   *  Be careful with onStartShould* callbacks. They only reflect updated\n   *  `gestureState` for start/end events that bubble/capture to the Node.\n   *  Once the node is the responder, you can rely on every start/end event\n   *  being processed by the gesture and `gestureState` being updated\n   *  accordingly. (numberActiveTouches) may not be totally accurate unless you\n   *  are the responder.\n   */\n  create(config: PanResponderCallbacks): {\n    getInteractionHandle: () => ?number,\n    panHandlers: GestureResponderHandlerMethods,\n  } {\n    const interactionState = {\n      handle: (null: ?number),\n    };\n    const gestureState: PanResponderGestureState = {\n      // Useful for debugging\n      stateID: Math.random(),\n      moveX: 0,\n      moveY: 0,\n      x0: 0,\n      y0: 0,\n      dx: 0,\n      dy: 0,\n      vx: 0,\n      vy: 0,\n      numberActiveTouches: 0,\n      _accountsForMovesUpTo: 0,\n    };\n    const panHandlers = {\n      onStartShouldSetResponder(event: GestureResponderEvent): boolean {\n        return config.onStartShouldSetPanResponder == null\n          ? false\n          : config.onStartShouldSetPanResponder(event, gestureState);\n      },\n      onMoveShouldSetResponder(event: GestureResponderEvent): boolean {\n        return config.onMoveShouldSetPanResponder == null\n          ? false\n          : config.onMoveShouldSetPanResponder(event, gestureState);\n      },\n      onStartShouldSetResponderCapture(event: GestureResponderEvent): boolean {\n        // TODO: Actually, we should reinitialize the state any time\n        // touches.length increases from 0 active to > 0 active.\n        if (event.nativeEvent.touches.length === 1) {\n          PanResponder._initializeGestureState(gestureState);\n        }\n        gestureState.numberActiveTouches =\n          event.touchHistory.numberActiveTouches;\n        return config.onStartShouldSetPanResponderCapture != null\n          ? config.onStartShouldSetPanResponderCapture(event, gestureState)\n          : false;\n      },\n\n      onMoveShouldSetResponderCapture(event: GestureResponderEvent): boolean {\n        const touchHistory = event.touchHistory;\n        // Responder system incorrectly dispatches should* to current responder\n        // Filter out any touch moves past the first one - we would have\n        // already processed multi-touch geometry during the first event.\n        if (\n          gestureState._accountsForMovesUpTo ===\n          touchHistory.mostRecentTimeStamp\n        ) {\n          return false;\n        }\n        PanResponder._updateGestureStateOnMove(gestureState, touchHistory);\n        return config.onMoveShouldSetPanResponderCapture\n          ? config.onMoveShouldSetPanResponderCapture(event, gestureState)\n          : false;\n      },\n\n      onResponderGrant(event: GestureResponderEvent): boolean {\n        if (!interactionState.handle) {\n          interactionState.handle =\n            InteractionManager.createInteractionHandle();\n        }\n        gestureState.x0 = currentCentroidX(event.touchHistory);\n        gestureState.y0 = currentCentroidY(event.touchHistory);\n        gestureState.dx = 0;\n        gestureState.dy = 0;\n        if (config.onPanResponderGrant) {\n          config.onPanResponderGrant(event, gestureState);\n        }\n        // TODO: t7467124 investigate if this can be removed\n        return config.onShouldBlockNativeResponder == null\n          ? true\n          : config.onShouldBlockNativeResponder(event, gestureState);\n      },\n\n      onResponderReject(event: GestureResponderEvent): void {\n        clearInteractionHandle(\n          interactionState,\n          config.onPanResponderReject,\n          event,\n          gestureState,\n        );\n      },\n\n      onResponderRelease(event: GestureResponderEvent): void {\n        clearInteractionHandle(\n          interactionState,\n          config.onPanResponderRelease,\n          event,\n          gestureState,\n        );\n        PanResponder._initializeGestureState(gestureState);\n      },\n\n      onResponderStart(event: GestureResponderEvent): void {\n        const touchHistory = event.touchHistory;\n        gestureState.numberActiveTouches = touchHistory.numberActiveTouches;\n        if (config.onPanResponderStart) {\n          config.onPanResponderStart(event, gestureState);\n        }\n      },\n\n      onResponderMove(event: GestureResponderEvent): void {\n        const touchHistory = event.touchHistory;\n        // Guard against the dispatch of two touch moves when there are two\n        // simultaneously changed touches.\n        if (\n          gestureState._accountsForMovesUpTo ===\n          touchHistory.mostRecentTimeStamp\n        ) {\n          return;\n        }\n        // Filter out any touch moves past the first one - we would have\n        // already processed multi-touch geometry during the first event.\n        PanResponder._updateGestureStateOnMove(gestureState, touchHistory);\n        if (config.onPanResponderMove) {\n          config.onPanResponderMove(event, gestureState);\n        }\n      },\n\n      onResponderEnd(event: GestureResponderEvent): void {\n        const touchHistory = event.touchHistory;\n        gestureState.numberActiveTouches = touchHistory.numberActiveTouches;\n        clearInteractionHandle(\n          interactionState,\n          config.onPanResponderEnd,\n          event,\n          gestureState,\n        );\n      },\n\n      onResponderTerminate(event: GestureResponderEvent): void {\n        clearInteractionHandle(\n          interactionState,\n          config.onPanResponderTerminate,\n          event,\n          gestureState,\n        );\n        PanResponder._initializeGestureState(gestureState);\n      },\n\n      onResponderTerminationRequest(event: GestureResponderEvent): boolean {\n        return config.onPanResponderTerminationRequest == null\n          ? true\n          : config.onPanResponderTerminationRequest(event, gestureState);\n      },\n    };\n    return {\n      panHandlers,\n      getInteractionHandle(): ?number {\n        return interactionState.handle;\n      },\n    };\n  },\n};\n\nfunction clearInteractionHandle(\n  interactionState: {handle: ?number, ...},\n  callback: ?(ActiveCallback | PassiveCallback),\n  event: GestureResponderEvent,\n  gestureState: PanResponderGestureState,\n) {\n  if (interactionState.handle) {\n    InteractionManager.clearInteractionHandle(interactionState.handle);\n    interactionState.handle = null;\n  }\n  if (callback) {\n    callback(event, gestureState);\n  }\n}\n\nexport type PanResponderInstance = ReturnType<(typeof PanResponder)['create']>;\n\nexport default PanResponder;\n"],"mappings":"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","ignoreList":[]}

package/.cache/jest-cache-react-17/jest-transform-cache-351fb7c9421020ab4cca8f7975c30d61-1324230084614362f519ae4cb2580aab/29/Replaynative_2939e295509a9cd7af60ff69c1a04da6

@@ -0,0 +1,44 @@
+3705e1e7af33d207add33bac00b3fc85
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+var _excluded = ["title", "titleId", "size", "color", "gradient"];
+var _reactNativeSvg = require("react-native-svg");
+var _jsxRuntime = require("react/jsx-runtime");
+module.exports = function (_ref) {
+  var title = _ref.title,
+    titleId = _ref.titleId,
+    size = _ref.size,
+    color = _ref.color,
+    gradient = _ref.gradient,
+    props = (0, _objectWithoutProperties2.default)(_ref, _excluded);
+  var iconSharedUtils = require('./utils/icon-shared-utils');
+  var hasGradient = iconSharedUtils.hasValidGradient(gradient);
+  var fillValue = color;
+  var gradientDefs;
+  var gradientUtils;
+  if (hasGradient) {
+    gradientUtils = iconSharedUtils.getGradientUtils();
+    var iconNativeUtils = require('./utils/icon-native-utils');
+    var gradientId = gradientUtils.generateGradientId(gradient);
+    fillValue = `url(#${gradientId})`;
+    gradientDefs = iconNativeUtils.renderNativeGradientDefs(gradient, gradientId);
+  }
+  var svgContent = (0, _jsxRuntime.jsxs)(_reactNativeSvg.default, Object.assign({}, props, {
+    xmlns: "http://www.w3.org/2000/svg",
+    viewBox: "0 0 24 24",
+    height: size,
+    width: size,
+    fill: fillValue,
+    "aria-labelledby": titleId,
+    children: [title ? (0, _jsxRuntime.jsx)("title", {
+      id: titleId,
+      children: title
+    }) : null, (0, _jsxRuntime.jsx)(_reactNativeSvg.Path, {
+      d: "M12.7.95c-4 0-7.35 2.18-9.77 6.28-.09-.13-.17-.27-.26-.4-.19-.31-.37-.63-.55-.95a17.9 17.9 0 0 1-.49-.98c-.08-.17-.16-.33-.23-.5-.04-.08-.08-.17-.11-.25a.973.973 0 0 0-.11-.23.546.546 0 0 0-.44-.22c-.12 0-.23.03-.32.11l-.03.03s-.09.11-.11.17c-.06.16-.03.33.02.48.04.13.09.27.14.4.13.41.26.83.4 1.24.07.23.15.47.22.7.32 1.01.65 2.05.92 2.87.09.28.15.59.28.85.04.08.12.18.21.22.07.04.16.05.26.02.02 0 .05-.02.07-.03l.33-.13.54-.21.7-.27c.27-.1.53-.21.8-.31l.84-.33.82-.32.74-.29.6-.24.21-.08c.07-.03.14-.06.21-.08.07-.03.14-.05.21-.08.08-.04.16-.09.22-.16.08-.11.12-.26.09-.39a.516.516 0 0 0-.6-.38l-1.53.36s-1.58.29-2.39.34c1.51-2.54 4.07-5.3 8.1-5.3 5.02 0 9.11 4.09 9.11 9.11s-4.09 9.11-9.11 9.11a9.07 9.07 0 0 1-4.63-1.27 9.47 9.47 0 0 1-1.87-1.47c-.16-.16-.3-.35-.45-.52-.19-.22-.36-.45-.53-.69-.08-.11-.15-.23-.22-.34-.18-.28-.35-.57-.49-.87l-.19-.4c-.2-.44-.66-.69-1.15-.55-.15.04-.29.12-.41.23-.14.13-.24.3-.28.49-.02.1-.03.2-.02.3.01.13.07.27.12.39.1.25.22.5.35.74.37.7.82 1.37 1.33 1.98.25.3.52.59.81.86.28.27.58.53.9.77a10.47 10.47 0 0 0 2.02 1.23c.36.17.73.32 1.11.45.38.13.77.24 1.16.33.4.09.8.16 1.21.2.41.05.83.07 1.24.07 6.09 0 11.05-4.96 11.05-11.05C23.75 5.9 18.79.95 12.7.95Z"
+    })]
+  }));
+  return hasGradient ? gradientUtils.addGradientToSvg(svgContent, gradientDefs) : svgContent;
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/.cache/jest-cache-react-17/jest-transform-cache-351fb7c9421020ab4cca8f7975c30d61-1324230084614362f519ae4cb2580aab/29/Replaynative_2939e295509a9cd7af60ff69c1a04da6.map

@@ -0,0 +1 @@
+{"version":3,"names":["_interopRequireDefault","require","_objectWithoutProperties2","_excluded","_reactNativeSvg","_jsxRuntime","module","exports","_ref","title","titleId","size","color","gradient","props","default","iconSharedUtils","hasGradient","hasValidGradient","fillValue","gradientDefs","gradientUtils","getGradientUtils","iconNativeUtils","gradientId","generateGradientId","renderNativeGradientDefs","svgContent","jsxs","Object","assign","xmlns","viewBox","height","width","fill","children","jsx","id","Path","d","addGradientToSvg"],"sources":["Replay.native.js"],"sourcesContent":["\"use strict\";\n\nvar _reactNativeSvg = require(\"react-native-svg\");\nvar _jsxRuntime = require(\"react/jsx-runtime\");\nmodule.exports = ({\n  title,\n  titleId,\n  size,\n  color,\n  gradient,\n  ...props\n}) => {\n  const iconSharedUtils = require('./utils/icon-shared-utils');\n  const hasGradient = iconSharedUtils.hasValidGradient(gradient);\n  let fillValue = color;\n  let gradientDefs;\n  let gradientUtils;\n  if (hasGradient) {\n    gradientUtils = iconSharedUtils.getGradientUtils();\n    const iconNativeUtils = require('./utils/icon-native-utils');\n    const gradientId = gradientUtils.generateGradientId(gradient);\n    fillValue = `url(#${gradientId})`;\n    gradientDefs = iconNativeUtils.renderNativeGradientDefs(gradient, gradientId);\n  }\n  const svgContent = (0, _jsxRuntime.jsxs)(_reactNativeSvg.default, {\n    ...props,\n    xmlns: \"http://www.w3.org/2000/svg\",\n    viewBox: \"0 0 24 24\",\n    height: size,\n    width: size,\n    fill: fillValue,\n    \"aria-labelledby\": titleId,\n    children: [title ? (0, _jsxRuntime.jsx)(\"title\", {\n      id: titleId,\n      children: title\n    }) : null, (0, _jsxRuntime.jsx)(_reactNativeSvg.Path, {\n      d: \"M12.7.95c-4 0-7.35 2.18-9.77 6.28-.09-.13-.17-.27-.26-.4-.19-.31-.37-.63-.55-.95a17.9 17.9 0 0 1-.49-.98c-.08-.17-.16-.33-.23-.5-.04-.08-.08-.17-.11-.25a.973.973 0 0 0-.11-.23.546.546 0 0 0-.44-.22c-.12 0-.23.03-.32.11l-.03.03s-.09.11-.11.17c-.06.16-.03.33.02.48.04.13.09.27.14.4.13.41.26.83.4 1.24.07.23.15.47.22.7.32 1.01.65 2.05.92 2.87.09.28.15.59.28.85.04.08.12.18.21.22.07.04.16.05.26.02.02 0 .05-.02.07-.03l.33-.13.54-.21.7-.27c.27-.1.53-.21.8-.31l.84-.33.82-.32.74-.29.6-.24.21-.08c.07-.03.14-.06.21-.08.07-.03.14-.05.21-.08.08-.04.16-.09.22-.16.08-.11.12-.26.09-.39a.516.516 0 0 0-.6-.38l-1.53.36s-1.58.29-2.39.34c1.51-2.54 4.07-5.3 8.1-5.3 5.02 0 9.11 4.09 9.11 9.11s-4.09 9.11-9.11 9.11a9.07 9.07 0 0 1-4.63-1.27 9.47 9.47 0 0 1-1.87-1.47c-.16-.16-.3-.35-.45-.52-.19-.22-.36-.45-.53-.69-.08-.11-.15-.23-.22-.34-.18-.28-.35-.57-.49-.87l-.19-.4c-.2-.44-.66-.69-1.15-.55-.15.04-.29.12-.41.23-.14.13-.24.3-.28.49-.02.1-.03.2-.02.3.01.13.07.27.12.39.1.25.22.5.35.74.37.7.82 1.37 1.33 1.98.25.3.52.59.81.86.28.27.58.53.9.77a10.47 10.47 0 0 0 2.02 1.23c.36.17.73.32 1.11.45.38.13.77.24 1.16.33.4.09.8.16 1.21.2.41.05.83.07 1.24.07 6.09 0 11.05-4.96 11.05-11.05C23.75 5.9 18.79.95 12.7.95Z\"\n    })]\n  });\n  return hasGradient ? gradientUtils.addGradientToSvg(svgContent, gradientDefs) : svgContent;\n};"],"mappings":"AAAA,YAAY;;AAAC,IAAAA,sBAAA,GAAAC,OAAA;AAAA,IAAAC,yBAAA,GAAAF,sBAAA,CAAAC,OAAA;AAAA,IAAAE,SAAA;AAEb,IAAIC,eAAe,GAAGH,OAAO,CAAC,kBAAkB,CAAC;AACjD,IAAII,WAAW,GAAGJ,OAAO,CAAC,mBAAmB,CAAC;AAC9CK,MAAM,CAACC,OAAO,GAAG,UAAAC,IAAA,EAOX;EAAA,IANJC,KAAK,GAAAD,IAAA,CAALC,KAAK;IACLC,OAAO,GAAAF,IAAA,CAAPE,OAAO;IACPC,IAAI,GAAAH,IAAA,CAAJG,IAAI;IACJC,KAAK,GAAAJ,IAAA,CAALI,KAAK;IACLC,QAAQ,GAAAL,IAAA,CAARK,QAAQ;IACLC,KAAK,OAAAZ,yBAAA,CAAAa,OAAA,EAAAP,IAAA,EAAAL,SAAA;EAER,IAAMa,eAAe,GAAGf,OAAO,CAAC,2BAA2B,CAAC;EAC5D,IAAMgB,WAAW,GAAGD,eAAe,CAACE,gBAAgB,CAACL,QAAQ,CAAC;EAC9D,IAAIM,SAAS,GAAGP,KAAK;EACrB,IAAIQ,YAAY;EAChB,IAAIC,aAAa;EACjB,IAAIJ,WAAW,EAAE;IACfI,aAAa,GAAGL,eAAe,CAACM,gBAAgB,CAAC,CAAC;IAClD,IAAMC,eAAe,GAAGtB,OAAO,CAAC,2BAA2B,CAAC;IAC5D,IAAMuB,UAAU,GAAGH,aAAa,CAACI,kBAAkB,CAACZ,QAAQ,CAAC;IAC7DM,SAAS,GAAG,QAAQK,UAAU,GAAG;IACjCJ,YAAY,GAAGG,eAAe,CAACG,wBAAwB,CAACb,QAAQ,EAAEW,UAAU,CAAC;EAC/E;EACA,IAAMG,UAAU,GAAG,CAAC,CAAC,EAAEtB,WAAW,CAACuB,IAAI,EAAExB,eAAe,CAACW,OAAO,EAAAc,MAAA,CAAAC,MAAA,KAC3DhB,KAAK;IACRiB,KAAK,EAAE,4BAA4B;IACnCC,OAAO,EAAE,WAAW;IACpBC,MAAM,EAAEtB,IAAI;IACZuB,KAAK,EAAEvB,IAAI;IACXwB,IAAI,EAAEhB,SAAS;IACf,iBAAiB,EAAET,OAAO;IAC1B0B,QAAQ,EAAE,CAAC3B,KAAK,GAAG,CAAC,CAAC,EAAEJ,WAAW,CAACgC,GAAG,EAAE,OAAO,EAAE;MAC/CC,EAAE,EAAE5B,OAAO;MACX0B,QAAQ,EAAE3B;IACZ,CAAC,CAAC,GAAG,IAAI,EAAE,CAAC,CAAC,EAAEJ,WAAW,CAACgC,GAAG,EAAEjC,eAAe,CAACmC,IAAI,EAAE;MACpDC,CAAC,EAAE;IACL,CAAC,CAAC;EAAC,EACJ,CAAC;EACF,OAAOvB,WAAW,GAAGI,aAAa,CAACoB,gBAAgB,CAACd,UAAU,EAAEP,YAAY,CAAC,GAAGO,UAAU;AAC5F,CAAC","ignoreList":[]}

package/.cache/jest-cache-react-17/jest-transform-cache-351fb7c9421020ab4cca8f7975c30d61-1324230084614362f519ae4cb2580aab/2a/CheckboxCardtest_2a441833b3772e50ad11081e9efbf8fd

@@ -0,0 +1,202 @@
+2c57bd6f56d38c62fa815d97945635b4
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _react = _interopRequireDefault(require("react"));
+var _reactNative = require("react-native");
+var _reactNative2 = require("@testing-library/react-native");
+var _src = require("../../src");
+var _Theme = require("../../__fixtures__/Theme");
+var _jsxRuntime = require("react/jsx-runtime");
+var checkedId = 'Checkbox-Icon';
+var setup = function setup(props) {
+  return (0, _reactNative2.render)((0, _jsxRuntime.jsx)(_Theme.Theme, {
+    children: (0, _jsxRuntime.jsx)(_src.CheckboxCard, Object.assign({}, props, {
+      iconId: "Checkbox-Icon"
+    }))
+  }));
+};
+describe('CheckboxCard', function () {
+  var consoleError = console.error;
+  beforeEach(function () {
+    console.error = function () {};
+  });
+  afterEach(function () {
+    console.error = consoleError;
+  });
+  it('renders with defaults', function () {
+    var _setup = setup(),
+      getByRole = _setup.getByRole;
+    expect(getByRole('checkbox')).toBeTruthy();
+  });
+  it('renders a title', function () {
+    var title = 'Test title message';
+    var _setup2 = setup({
+        title: title
+      }),
+      queryByText = _setup2.queryByText;
+    expect(queryByText(title)).toBeTruthy();
+  });
+  it('triggers the callback', function () {
+    var onChange = jest.fn();
+    var _setup3 = setup({
+        onChange: onChange
+      }),
+      getByRole = _setup3.getByRole;
+    var checkbox = getByRole('checkbox');
+    expect(onChange).not.toHaveBeenCalled();
+    (0, _reactNative2.fireEvent)(checkbox, 'press');
+    expect(onChange).toHaveBeenCalledTimes(1);
+  });
+  it('cannot be changed if inactive', function () {
+    var _setup4 = setup({
+        inactive: true
+      }),
+      getByRole = _setup4.getByRole,
+      queryByTestId = _setup4.queryByTestId;
+    var checkbox = getByRole('checkbox');
+    expect(queryByTestId(checkedId)).toBeFalsy();
+    (0, _reactNative2.fireEvent)(checkbox, 'press');
+    expect(queryByTestId(checkedId)).toBeFalsy();
+  });
+  it('is not disabled by default', function () {
+    var _setup5 = setup(),
+      getByRole = _setup5.getByRole;
+    expect(getByRole('checkbox')).not.toBeDisabled();
+  });
+  it('is disabled when set to inactive', function () {
+    var _setup6 = setup({
+        inactive: true
+      }),
+      getByRole = _setup6.getByRole;
+    expect(getByRole('checkbox')).toBeDisabled();
+  });
+  it('is unchecked by default', function () {
+    var _setup7 = setup(),
+      getByRole = _setup7.getByRole,
+      queryByTestId = _setup7.queryByTestId;
+    expect(queryByTestId(checkedId)).toBeFalsy();
+    expect(getByRole('checkbox')).not.toBeChecked();
+  });
+  describe('when uncontrolled', function () {
+    it('uses `defaultChecked` as the initial value', function () {
+      var _setup8 = setup({
+          defaultChecked: true
+        }),
+        getByRole = _setup8.getByRole,
+        queryByTestId = _setup8.queryByTestId;
+      expect(queryByTestId(checkedId)).toBeTruthy();
+      expect(getByRole('checkbox')).toBeChecked();
+    });
+    it('changes value', function () {
+      var _setup9 = setup({
+          defaultChecked: false
+        }),
+        getByRole = _setup9.getByRole,
+        queryByTestId = _setup9.queryByTestId;
+      var checkbox = getByRole('checkbox');
+      expect(queryByTestId(checkedId)).toBeFalsy();
+      expect(checkbox).not.toBeChecked();
+      (0, _reactNative2.fireEvent)(checkbox, 'press');
+      expect(queryByTestId(checkedId)).toBeTruthy();
+      expect(checkbox).toBeChecked();
+    });
+  });
+  describe('when controlled', function () {
+    it('is checked when passed checked: true', function () {
+      var _setup0 = setup({
+          checked: true,
+          onChange: function onChange() {}
+        }),
+        getByRole = _setup0.getByRole,
+        queryByTestId = _setup0.queryByTestId;
+      expect(queryByTestId(checkedId)).toBeTruthy();
+      expect(getByRole('checkbox')).toBeChecked();
+    });
+    it('calls `onChange` with the new value', function () {
+      var onChange = jest.fn();
+      var _setup1 = setup({
+          onChange: onChange,
+          checked: false
+        }),
+        getByRole = _setup1.getByRole,
+        queryByTestId = _setup1.queryByTestId;
+      var checkbox = getByRole('checkbox');
+      expect(queryByTestId(checkedId)).toBeFalsy();
+      (0, _reactNative2.fireEvent)(checkbox, 'press', {
+        nativeEvent: 'example'
+      });
+      expect(onChange).toHaveBeenCalledTimes(1);
+      expect(onChange).toHaveBeenCalledWith(true, {
+        nativeEvent: 'example'
+      });
+    });
+  });
+  it('matches snapshot', function () {
+    var _setup10 = setup(),
+      toJSON = _setup10.toJSON;
+    expect(toJSON()).toMatchSnapshot();
+  });
+  describe('children prop rendering', function () {
+    it('renders static children when children is not a function', function () {
+      var staticContent = (0, _jsxRuntime.jsx)(_reactNative.Text, {
+        children: "Static child content"
+      });
+      var _setup11 = setup({
+          children: staticContent
+        }),
+        getByText = _setup11.getByText;
+      expect(getByText('Static child content')).toBeTruthy();
+    });
+    it('renders function children with cardState and textStyle parameters', function () {
+      var mockFunctionChild = jest.fn(function () {
+        return (0, _jsxRuntime.jsx)(_reactNative.Text, {
+          children: "Function child content"
+        });
+      });
+      var _setup12 = setup({
+          children: mockFunctionChild
+        }),
+        getByText = _setup12.getByText;
+      expect(mockFunctionChild).toHaveBeenCalledTimes(1);
+      var _mockFunctionChild$mo = (0, _slicedToArray2.default)(mockFunctionChild.mock.calls[0], 2),
+        cardState = _mockFunctionChild$mo[0],
+        textStyle = _mockFunctionChild$mo[1];
+      expect(cardState).toEqual(expect.objectContaining({
+        focus: false,
+        hover: false,
+        pressed: false
+      }));
+      expect(textStyle).toEqual(expect.objectContaining({
+        fontSize: expect.any(Number),
+        lineHeight: expect.any(Number),
+        fontFamily: expect.any(String)
+      }));
+      expect(getByText('Function child content')).toBeTruthy();
+    });
+    it('renders string children as static content', function () {
+      var staticContent = (0, _jsxRuntime.jsx)(_reactNative.Text, {
+        children: "String child content"
+      });
+      var _setup13 = setup({
+          children: staticContent
+        }),
+        getByText = _setup13.getByText;
+      expect(getByText('String child content')).toBeTruthy();
+    });
+    it('handles null children gracefully', function () {
+      var _setup14 = setup({
+          children: null
+        }),
+        root = _setup14.root;
+      expect(root).toBeTruthy();
+    });
+    it('handles undefined children gracefully', function () {
+      var _setup15 = setup({
+          children: undefined
+        }),
+        root = _setup15.root;
+      expect(root).toBeTruthy();
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_react","_interopRequireDefault","require","_reactNative","_reactNative2","_src","_Theme","_jsxRuntime","checkedId","setup","props","render","jsx","Theme","children","CheckboxCard","Object","assign","iconId","describe","consoleError","console","error","beforeEach","afterEach","it","_setup","getByRole","expect","toBeTruthy","title","_setup2","queryByText","onChange","jest","fn","_setup3","checkbox","not","toHaveBeenCalled","fireEvent","toHaveBeenCalledTimes","_setup4","inactive","queryByTestId","toBeFalsy","_setup5","toBeDisabled","_setup6","_setup7","toBeChecked","_setup8","defaultChecked","_setup9","_setup0","checked","_setup1","nativeEvent","toHaveBeenCalledWith","_setup10","toJSON","toMatchSnapshot","staticContent","Text","_setup11","getByText","mockFunctionChild","_setup12","_mockFunctionChild$mo","_slicedToArray2","default","mock","calls","cardState","textStyle","toEqual","objectContaining","focus","hover","pressed","fontSize","any","Number","lineHeight","fontFamily","String","_setup13","_setup14","root","_setup15","undefined"],"sources":["CheckboxCard.test.jsx"],"sourcesContent":["import React from 'react'\nimport { Text } from 'react-native'\nimport { fireEvent, render } from '@testing-library/react-native'\n\nimport { CheckboxCard } from '../../src'\nimport { Theme } from '../../__fixtures__/Theme'\n\nconst checkedId = 'Checkbox-Icon'\nconst setup = (props) =>\n  render(\n    <Theme>\n      <CheckboxCard {...props} iconId=\"Checkbox-Icon\" />\n    </Theme>\n  )\n\ndescribe('CheckboxCard', () => {\n  // eslint-disable-next-line no-console\n  const consoleError = console.error\n  beforeEach(() => {\n    // eslint-disable-next-line no-console\n    console.error = () => {}\n  })\n  afterEach(() => {\n    // eslint-disable-next-line no-console\n    console.error = consoleError\n  })\n\n  it('renders with defaults', () => {\n    const { getByRole } = setup()\n\n    expect(getByRole('checkbox')).toBeTruthy()\n  })\n\n  it('renders a title', () => {\n    const title = 'Test title message'\n    const { queryByText } = setup({ title })\n\n    expect(queryByText(title)).toBeTruthy()\n  })\n\n  it('triggers the callback', () => {\n    const onChange = jest.fn()\n\n    const { getByRole } = setup({ onChange })\n\n    const checkbox = getByRole('checkbox')\n    expect(onChange).not.toHaveBeenCalled()\n    fireEvent(checkbox, 'press')\n    expect(onChange).toHaveBeenCalledTimes(1)\n  })\n\n  it('cannot be changed if inactive', () => {\n    const { getByRole, queryByTestId } = setup({ inactive: true })\n\n    const checkbox = getByRole('checkbox')\n    expect(queryByTestId(checkedId)).toBeFalsy()\n    fireEvent(checkbox, 'press')\n    expect(queryByTestId(checkedId)).toBeFalsy()\n  })\n\n  it('is not disabled by default', () => {\n    const { getByRole } = setup()\n    expect(getByRole('checkbox')).not.toBeDisabled()\n  })\n\n  it('is disabled when set to inactive', () => {\n    const { getByRole } = setup({ inactive: true })\n    expect(getByRole('checkbox')).toBeDisabled()\n  })\n\n  it('is unchecked by default', () => {\n    const { getByRole, queryByTestId } = setup()\n\n    expect(queryByTestId(checkedId)).toBeFalsy()\n    expect(getByRole('checkbox')).not.toBeChecked()\n  })\n\n  describe('when uncontrolled', () => {\n    it('uses `defaultChecked` as the initial value', () => {\n      const { getByRole, queryByTestId } = setup({ defaultChecked: true })\n\n      expect(queryByTestId(checkedId)).toBeTruthy()\n      expect(getByRole('checkbox')).toBeChecked()\n    })\n\n    it('changes value', () => {\n      const { getByRole, queryByTestId } = setup({ defaultChecked: false })\n\n      const checkbox = getByRole('checkbox')\n      expect(queryByTestId(checkedId)).toBeFalsy()\n      expect(checkbox).not.toBeChecked()\n      fireEvent(checkbox, 'press')\n      expect(queryByTestId(checkedId)).toBeTruthy()\n      expect(checkbox).toBeChecked()\n    })\n  })\n\n  describe('when controlled', () => {\n    it('is checked when passed checked: true', () => {\n      const { getByRole, queryByTestId } = setup({ checked: true, onChange: () => {} })\n\n      expect(queryByTestId(checkedId)).toBeTruthy()\n      expect(getByRole('checkbox')).toBeChecked()\n    })\n\n    it('calls `onChange` with the new value', () => {\n      const onChange = jest.fn()\n      const { getByRole, queryByTestId } = setup({ onChange, checked: false })\n\n      const checkbox = getByRole('checkbox')\n      expect(queryByTestId(checkedId)).toBeFalsy()\n      fireEvent(checkbox, 'press', { nativeEvent: 'example' })\n      expect(onChange).toHaveBeenCalledTimes(1)\n      expect(onChange).toHaveBeenCalledWith(true, { nativeEvent: 'example' })\n    })\n  })\n\n  it('matches snapshot', () => {\n    const { toJSON } = setup()\n    expect(toJSON()).toMatchSnapshot()\n  })\n\n  describe('children prop rendering', () => {\n    it('renders static children when children is not a function', () => {\n      const staticContent = <Text>Static child content</Text>\n      const { getByText } = setup({ children: staticContent })\n\n      expect(getByText('Static child content')).toBeTruthy()\n    })\n\n    it('renders function children with cardState and textStyle parameters', () => {\n      const mockFunctionChild = jest.fn(() => <Text>Function child content</Text>)\n      const { getByText } = setup({ children: mockFunctionChild })\n\n      // Verify the function was called\n      expect(mockFunctionChild).toHaveBeenCalledTimes(1)\n\n      // Verify it was called with cardState and textStyle\n      const [cardState, textStyle] = mockFunctionChild.mock.calls[0]\n\n      expect(cardState).toEqual(\n        expect.objectContaining({\n          focus: false,\n          hover: false,\n          pressed: false\n        })\n      )\n      expect(textStyle).toEqual(\n        expect.objectContaining({\n          fontSize: expect.any(Number),\n          lineHeight: expect.any(Number),\n          fontFamily: expect.any(String)\n        })\n      )\n\n      expect(getByText('Function child content')).toBeTruthy()\n    })\n\n    it('renders string children as static content', () => {\n      const staticContent = <Text>String child content</Text>\n      const { getByText } = setup({ children: staticContent })\n\n      expect(getByText('String child content')).toBeTruthy()\n    })\n\n    it('handles null children gracefully', () => {\n      const { root } = setup({ children: null })\n\n      expect(root).toBeTruthy()\n    })\n\n    it('handles undefined children gracefully', () => {\n      const { root } = setup({ children: undefined })\n\n      expect(root).toBeTruthy()\n    })\n  })\n})\n"],"mappings":"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","ignoreList":[]}