{"version":3,"sources":["webpack:///webpack/bootstrap 3b634e065016ee39c5c8?8ff7","webpack:///./packages/universal-panresponder/src/index.js?c96e","webpack:///./packages/universal-env/lib/index.js?8271","webpack:///./packages/universal-panresponder/src/TouchHistoryMath.js?8d4f","webpack:///./packages/universal-panresponder/src/ResponderTouchHistoryStore.js?0e95"],"names":["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","stateID","Math","random","setHandlers","onStartShouldSetResponder","e","onStartShouldSetPanResponder","undefined","onMoveShouldSetResponder","onMoveShouldSetPanResponder","onStartShouldSetResponderCapture","nativeEvent","touches","length","onStartShouldSetPanResponderCapture","onMoveShouldSetResponderCapture","onMoveShouldSetPanResponderCapture","responderHandlers","onResponderGrant","onPanResponderGrant","onShouldBlockNativeResponder","onResponderReject","onPanResponderReject","onResponderRelease","onPanResponderRelease","onResponderTerminate","onPanResponderTerminate","onResponderTerminationRequest","onPanResponderTerminationRequest","isPanStart","panHandlers","onTouchStart","recordTouchTrack","onPanResponderStart","onTouchMove","onPanResponderMove","onTouchEnd","onPanResponderEnd","window","onMouseDown","onMouseMove","onMouseUp","module","exports","Object","defineProperty","value","_typeof","Symbol","iterator","obj","constructor","prototype","isWeb","navigator","appCodeName","product","isNode","process","versions","node","isWeex","callNative","isReactNative","__fbBatchedBridgeConfig","default","TouchHistoryMath","centroidDimension","touchesChangedAfter","isXAxis","ofCurrent","touchBank","total","count","oneTouchData","indexOfSingleActiveTouch","touchActive","currentTimeStamp","currentPageX","currentPageY","previousPageX","previousPageY","i","touchTrack","toAdd","noCentroid","initializeTouchData","touch","startTimeStamp","timestamp","startPageX","pageX","startPageY","pageY","previousTimeStamp","reinitializeTouchTrack","recordStartTouchData","identifier","recordMoveTouchData","recordEndTouchData","toArray","collection","Array","slice","call","normalizeTouches","timeStamp","map","clientX","clientY","force","screenX","screenY","radiusX","radiusY","rotationAngle","target","ResponderTouchHistoryStore","topLevelType","changedTouches","forEach","touchTrackToCheck"],"mappings":"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","file":"panresponder.js","sourcesContent":[" \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, {\n \t\t\t\tconfigurable: false,\n \t\t\t\tenumerable: true,\n \t\t\t\tget: getter\n \t\t\t});\n \t\t}\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 0);\n\n\n\n// WEBPACK FOOTER //\n// webpack/bootstrap 3b634e065016ee39c5c8","import {isWeex, isWeb} from 'universal-env';\nimport TouchHistoryMath from './TouchHistoryMath';\nimport ResponderTouchHistoryStore from './ResponderTouchHistoryStore';\n\nconst currentCentroidXOfTouchesChangedAfter = TouchHistoryMath.currentCentroidXOfTouchesChangedAfter;\nconst currentCentroidYOfTouchesChangedAfter = TouchHistoryMath.currentCentroidYOfTouchesChangedAfter;\nconst previousCentroidXOfTouchesChangedAfter = TouchHistoryMath.previousCentroidXOfTouchesChangedAfter;\nconst previousCentroidYOfTouchesChangedAfter = 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 guesture has started. Show visual feedback so the user knows\n * // what is happening!\n *\n * // gestureState.{x,y}0 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 * \n * );\n * },\n *\n * ```\n *\n * ### Working Example\n *\n * To see it in action, try the\n * [PanResponder example in UIExplorer](https://github.com/facebook/react-native/blob/master/Examples/UIExplorer/PanResponderExample.js)\n */\n\nconst PanResponder = {\n\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: function(gestureState) {\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: function(gestureState, touchHistory) {\n gestureState.numberActiveTouches = touchHistory.numberActiveTouches;\n gestureState.moveX = currentCentroidXOfTouchesChangedAfter(touchHistory, gestureState._accountsForMovesUpTo);\n gestureState.moveY = currentCentroidYOfTouchesChangedAfter(touchHistory, gestureState._accountsForMovesUpTo);\n const movedAfter = gestureState._accountsForMovesUpTo;\n const prevX = previousCentroidXOfTouchesChangedAfter(touchHistory, movedAfter);\n const x = currentCentroidXOfTouchesChangedAfter(touchHistory, movedAfter);\n const prevY = previousCentroidYOfTouchesChangedAfter(touchHistory, movedAfter);\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 = 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: function(config) {\n const gestureState = {\n // Useful for debugging\n stateID: Math.random(),\n };\n PanResponder._initializeGestureState(gestureState);\n\n let setHandlers = {\n // Ask to be the responder:\n onStartShouldSetResponder: function(e) {\n return config.onStartShouldSetPanResponder === undefined ?\n false :\n config.onStartShouldSetPanResponder(e, gestureState);\n },\n onMoveShouldSetResponder: function(e) {\n return config.onMoveShouldSetPanResponder === undefined ?\n false :\n config.onMoveShouldSetPanResponder(e, gestureState);\n },\n onStartShouldSetResponderCapture: function(e) {\n // TODO: Actually, we should reinitialize the state any time\n // touches.length increases from 0 active to > 0 active.\n if (e.nativeEvent.touches.length === 1) {\n PanResponder._initializeGestureState(gestureState);\n }\n gestureState.numberActiveTouches = ResponderTouchHistoryStore.touchHistory.numberActiveTouches;\n return config.onStartShouldSetPanResponderCapture !== undefined ?\n config.onStartShouldSetPanResponderCapture(e, gestureState) :\n false;\n },\n\n onMoveShouldSetResponderCapture: function(e) {\n const touchHistory = ResponderTouchHistoryStore.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 (gestureState._accountsForMovesUpTo === touchHistory.mostRecentTimeStamp) {\n return false;\n }\n PanResponder._updateGestureStateOnMove(gestureState, touchHistory);\n return config.onMoveShouldSetPanResponderCapture ?\n config.onMoveShouldSetPanResponderCapture(e, gestureState) :\n false;\n },\n };\n\n let responderHandlers = {\n onResponderGrant: function(e) {\n gestureState.x0 = currentCentroidX(ResponderTouchHistoryStore.touchHistory);\n gestureState.y0 = currentCentroidY(ResponderTouchHistoryStore.touchHistory);\n gestureState.dx = 0;\n gestureState.dy = 0;\n if (config.onPanResponderGrant) {\n config.onPanResponderGrant(e, gestureState);\n }\n // TODO: t7467124 investigate if this can be removed\n return config.onShouldBlockNativeResponder === undefined ?\n true :\n config.onShouldBlockNativeResponder();\n },\n\n onResponderReject: function(e) {\n config.onPanResponderReject && config.onPanResponderReject(e, gestureState);\n },\n\n onResponderRelease: function(e) {\n config.onPanResponderRelease && config.onPanResponderRelease(e, gestureState);\n PanResponder._initializeGestureState(gestureState);\n },\n\n onResponderTerminate: function(e) {\n config.onPanResponderTerminate && config.onPanResponderTerminate(e, gestureState);\n PanResponder._initializeGestureState(gestureState);\n },\n\n onResponderTerminationRequest: function(e) {\n return config.onPanResponderTerminationRequest === undefined ?\n true :\n config.onPanResponderTerminationRequest(e, gestureState);\n }\n };\n\n // Track for mouse event\n let isPanStart = false;\n\n // Default\n let panHandlers = {\n onTouchStart: function(e) {\n isPanStart = true;\n\n ResponderTouchHistoryStore.recordTouchTrack('start', e);\n\n responderHandlers.onResponderGrant(e);\n\n const touchHistory = ResponderTouchHistoryStore.touchHistory;\n gestureState.numberActiveTouches = touchHistory.numberActiveTouches;\n\n if (!setHandlers.onStartShouldSetResponder(e)) {\n return responderHandlers.onResponderReject(e);\n }\n\n if (config.onPanResponderStart) {\n config.onPanResponderStart(e, gestureState);\n }\n },\n\n onTouchMove: function(e) {\n if (!isPanStart) return;\n\n ResponderTouchHistoryStore.recordTouchTrack('move', e);\n\n const touchHistory = ResponderTouchHistoryStore.touchHistory;\n\n // Guard against the dispatch of two touch moves when there are two\n // simultaneously changed touches.\n if (gestureState._accountsForMovesUpTo === touchHistory.mostRecentTimeStamp) {\n return;\n }\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\n if (!setHandlers.onMoveShouldSetResponder(e)) {\n return;\n }\n\n if (config.onPanResponderMove) {\n config.onPanResponderMove(e, gestureState);\n }\n },\n\n onTouchEnd: function(e) {\n isPanStart = false;\n\n ResponderTouchHistoryStore.recordTouchTrack('end', e);\n\n const touchHistory = ResponderTouchHistoryStore.touchHistory;\n gestureState.numberActiveTouches = touchHistory.numberActiveTouches;\n\n if (config.onPanResponderEnd) {\n config.onPanResponderEnd(e, gestureState);\n }\n\n responderHandlers.onResponderRelease(e);\n },\n };\n\n if (isWeb) {\n if ('ontouchstart' in window) {\n panHandlers = {\n onTouchStart: panHandlers.onTouchStart,\n onTouchMove: panHandlers.onTouchMove,\n onTouchEnd: panHandlers.onTouchEnd\n };\n } else {\n panHandlers = {\n onMouseDown: panHandlers.onTouchStart,\n onMouseMove: panHandlers.onTouchMove,\n onMouseUp: panHandlers.onTouchEnd\n };\n }\n }\n\n return { panHandlers: panHandlers };\n }\n};\n\nmodule.exports = PanResponder;\n\n\n\n// WEBPACK FOOTER //\n// ./packages/universal-panresponder/src/index.js","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\n// https://www.w3.org/TR/html5/webappapis.html#dom-navigator-appcodename\nvar isWeb = exports.isWeb = (typeof navigator === 'undefined' ? 'undefined' : _typeof(navigator)) === 'object' && (navigator.appCodeName === 'Mozilla' || navigator.product === 'Gecko');\nvar isNode = exports.isNode = typeof process !== 'undefined' && !!(process.versions && process.versions.node);\nvar isWeex = exports.isWeex = typeof callNative === 'function';\nvar isReactNative = exports.isReactNative = typeof __fbBatchedBridgeConfig !== 'undefined';\nexports['default'] = module.exports;\nexports.default = module.exports;\n\n\n// WEBPACK FOOTER //\n// ./packages/universal-env/lib/index.js","var TouchHistoryMath = {\n /**\n * This code is optimized and not intended to look beautiful. This allows\n * computing of touch centroids that have moved after `touchesChangedAfter`\n * timeStamp. You can compute the current centroid involving all touches\n * moves after `touchesChangedAfter`, or you can compute the previous\n * centroid of all touches that were moved after `touchesChangedAfter`.\n *\n * @param {TouchHistoryMath} touchHistory Standard Responder touch track\n * data.\n * @param {number} touchesChangedAfter timeStamp after which moved touches\n * are considered \"actively moving\" - not just \"active\".\n * @param {boolean} isXAxis Consider `x` dimension vs. `y` dimension.\n * @param {boolean} ofCurrent Compute current centroid for actively moving\n * touches vs. previous centroid of now actively moving touches.\n * @return {number} value of centroid in specified dimension.\n */\n centroidDimension: function(touchHistory, touchesChangedAfter, isXAxis, ofCurrent) {\n var touchBank = touchHistory.touchBank;\n var total = 0;\n var count = 0;\n\n var oneTouchData = touchHistory.numberActiveTouches === 1 ?\n touchHistory.touchBank[touchHistory.indexOfSingleActiveTouch] : null;\n\n if (oneTouchData !== null) {\n if (oneTouchData.touchActive && oneTouchData.currentTimeStamp > touchesChangedAfter) {\n total += ofCurrent && isXAxis ? oneTouchData.currentPageX :\n ofCurrent && !isXAxis ? oneTouchData.currentPageY :\n !ofCurrent && isXAxis ? oneTouchData.previousPageX :\n oneTouchData.previousPageY;\n count = 1;\n }\n } else {\n for (var i in touchBank) {\n var touchTrack = touchBank[i];\n if (touchTrack !== null &&\n touchTrack !== undefined &&\n touchTrack.touchActive &&\n touchTrack.currentTimeStamp >= touchesChangedAfter) {\n var toAdd; // Yuck, program temporarily in invalid state.\n if (ofCurrent && isXAxis) {\n toAdd = touchTrack.currentPageX;\n } else if (ofCurrent && !isXAxis) {\n toAdd = touchTrack.currentPageY;\n } else if (!ofCurrent && isXAxis) {\n toAdd = touchTrack.previousPageX;\n } else {\n toAdd = touchTrack.previousPageY;\n }\n total += toAdd;\n count++;\n }\n }\n }\n return count > 0 ? total / count : TouchHistoryMath.noCentroid;\n },\n\n currentCentroidXOfTouchesChangedAfter: function(touchHistory, touchesChangedAfter) {\n return TouchHistoryMath.centroidDimension(\n touchHistory,\n touchesChangedAfter,\n true, // isXAxis\n true // ofCurrent\n );\n },\n\n currentCentroidYOfTouchesChangedAfter: function(touchHistory, touchesChangedAfter) {\n return TouchHistoryMath.centroidDimension(\n touchHistory,\n touchesChangedAfter,\n false, // isXAxis\n true // ofCurrent\n );\n },\n\n previousCentroidXOfTouchesChangedAfter: function(touchHistory, touchesChangedAfter) {\n return TouchHistoryMath.centroidDimension(\n touchHistory,\n touchesChangedAfter,\n true, // isXAxis\n false // ofCurrent\n );\n },\n\n previousCentroidYOfTouchesChangedAfter: function(touchHistory, touchesChangedAfter) {\n return TouchHistoryMath.centroidDimension(\n touchHistory,\n touchesChangedAfter,\n false, // isXAxis\n false // ofCurrent\n );\n },\n\n currentCentroidX: function(touchHistory) {\n return TouchHistoryMath.centroidDimension(\n touchHistory,\n 0, // touchesChangedAfter\n true, // isXAxis\n true // ofCurrent\n );\n },\n\n currentCentroidY: function(touchHistory) {\n return TouchHistoryMath.centroidDimension(\n touchHistory,\n 0, // touchesChangedAfter\n false, // isXAxis\n true // ofCurrent\n );\n },\n\n noCentroid: -1,\n};\n\nmodule.exports = TouchHistoryMath;\n\n\n\n// WEBPACK FOOTER //\n// ./packages/universal-panresponder/src/TouchHistoryMath.js","/**\n * Touch position/time tracking information by touchID. Typically, we'll only\n * see IDs with a range of 1-20 (they are recycled when touches end and then\n * start again). This data is commonly needed by many different interaction\n * logic modules so precomputing it is very helpful to do once.\n * Each touch object in `touchBank` is of the following form:\n * { touchActive: boolean,\n * startTimeStamp: number,\n * startPageX: number,\n * startPageY: number,\n * currentPageX: number,\n * currentPageY: number,\n * currentTimeStamp: number\n * }\n */\nvar touchHistory = {\n touchBank: {},\n numberActiveTouches: 0,\n // If there is only one active touch, we remember its location. This prevents\n // us having to loop through all of the touches all the time in the most\n // common case.\n indexOfSingleActiveTouch: -1,\n mostRecentTimeStamp: 0,\n};\n\n/**\n * TODO: Instead of making gestures recompute filtered velocity, we could\n * include a built in velocity computation that can be reused globally.\n * @param {Touch} touch Native touch object.\n */\nvar initializeTouchData = function(touch) {\n return {\n touchActive: true,\n startTimeStamp: touch.timestamp,\n startPageX: touch.pageX,\n startPageY: touch.pageY,\n currentPageX: touch.pageX,\n currentPageY: touch.pageY,\n currentTimeStamp: touch.timestamp,\n previousPageX: touch.pageX,\n previousPageY: touch.pageY,\n previousTimeStamp: touch.timestamp,\n };\n};\n\nvar reinitializeTouchTrack = function(touchTrack, touch) {\n touchTrack.touchActive = true;\n touchTrack.startTimeStamp = touch.timestamp;\n touchTrack.startPageX = touch.pageX;\n touchTrack.startPageY = touch.pageY;\n touchTrack.currentPageX = touch.pageX;\n touchTrack.currentPageY = touch.pageY;\n touchTrack.currentTimeStamp = touch.timestamp;\n touchTrack.previousPageX = touch.pageX;\n touchTrack.previousPageY = touch.pageY;\n touchTrack.previousTimeStamp = touch.timestamp;\n};\n\nvar recordStartTouchData = function(touch) {\n var touchBank = touchHistory.touchBank;\n var identifier = touch.identifier;\n var touchTrack = touchBank[identifier];\n if (touchTrack) {\n reinitializeTouchTrack(touchTrack, touch);\n } else {\n touchBank[touch.identifier] = initializeTouchData(touch);\n }\n touchHistory.mostRecentTimeStamp = touch.timestamp;\n};\n\nvar recordMoveTouchData = function(touch) {\n var touchBank = touchHistory.touchBank;\n var touchTrack = touchBank[touch.identifier];\n touchTrack.touchActive = true;\n touchTrack.previousPageX = touchTrack.currentPageX;\n touchTrack.previousPageY = touchTrack.currentPageY;\n touchTrack.previousTimeStamp = touchTrack.currentTimeStamp;\n touchTrack.currentPageX = touch.pageX;\n touchTrack.currentPageY = touch.pageY;\n touchTrack.currentTimeStamp = touch.timestamp;\n touchHistory.mostRecentTimeStamp = touch.timestamp;\n};\n\nvar recordEndTouchData = function(touch) {\n var touchBank = touchHistory.touchBank;\n var touchTrack = touchBank[touch.identifier];\n touchTrack.previousPageX = touchTrack.currentPageX;\n touchTrack.previousPageY = touchTrack.currentPageY;\n touchTrack.previousTimeStamp = touchTrack.currentTimeStamp;\n touchTrack.currentPageX = touch.pageX;\n touchTrack.currentPageY = touch.pageY;\n touchTrack.currentTimeStamp = touch.timestamp;\n touchTrack.touchActive = false;\n touchHistory.mostRecentTimeStamp = touch.timestamp;\n};\n\nfunction toArray(collection) {\n return collection && Array.prototype.slice.call(collection) || [];\n}\n\nfunction normalizeTouches(touches, nativeEvent) {\n // Weex is timestamp\n let timeStamp = nativeEvent.timeStamp || nativeEvent.timestamp;\n\n return toArray(touches).map((touch) => {\n // Cloned touch\n return {\n clientX: touch.clientX,\n clientY: touch.clientY,\n force: touch.force,\n // FIXME: In weex android pageX/Y return a error value\n pageX: touch.screenX,\n pageY: touch.screenY,\n radiusX: touch.radiusX,\n radiusY: touch.radiusY,\n rotationAngle: touch.rotationAngle,\n screenX: touch.screenX,\n screenY: touch.screenY,\n target: touch.target || nativeEvent.target,\n timestamp: timeStamp,\n identifier: touch.identifier || 1 // MouseEvent without identifier\n };\n });\n};\n\nvar ResponderTouchHistoryStore = {\n recordTouchTrack: function(topLevelType, nativeEvent) {\n var touchBank = touchHistory.touchBank;\n var changedTouches = normalizeTouches(nativeEvent.changedTouches || [nativeEvent], nativeEvent);\n if (topLevelType === 'move') {\n changedTouches.forEach(recordMoveTouchData);\n } else if (topLevelType === 'start') {\n changedTouches.forEach(recordStartTouchData);\n touchHistory.numberActiveTouches = changedTouches.length;\n if (touchHistory.numberActiveTouches === 1) {\n touchHistory.indexOfSingleActiveTouch = changedTouches[0].identifier;\n }\n } else if (topLevelType === 'end') {\n changedTouches.forEach(recordEndTouchData);\n touchHistory.numberActiveTouches = changedTouches.length;\n if (touchHistory.numberActiveTouches === 1) {\n for (var i in touchBank) {\n var touchTrackToCheck = touchBank[i];\n if (touchTrackToCheck != null && touchTrackToCheck.touchActive) {\n touchHistory.indexOfSingleActiveTouch = i;\n break;\n }\n }\n }\n }\n },\n\n touchHistory: touchHistory,\n};\n\nmodule.exports = ResponderTouchHistoryStore;\n\n\n\n// WEBPACK FOOTER //\n// ./packages/universal-panresponder/src/ResponderTouchHistoryStore.js"],"sourceRoot":""}