rn-web-cli/tmpl/project/.happypack/s--1028029432.map

React Native for Web

{"version":3,"sources":["node_modules\\react-dom\\lib\\ResponderEventPlugin.js"],"names":["EventPluginUtils","require","EventPropagators","ResponderSyntheticEvent","ResponderTouchHistoryStore","accumulate","isStartish","isMoveish","isEndish","executeDirectDispatch","hasDispatches","executeDispatchesInOrderStopAtTrue","responderInst","trackedTouchCount","previousActiveTouches","changeResponder","nextResponderInst","blockHostResponder","oldResponderInst","ResponderEventPlugin","GlobalResponderHandler","onChange","eventTypes","startShouldSetResponder","phasedRegistrationNames","bubbled","captured","scrollShouldSetResponder","selectionChangeShouldSetResponder","moveShouldSetResponder","responderStart","registrationName","responderMove","responderEnd","responderRelease","responderTerminationRequest","responderGrant","responderReject","responderTerminate","setResponderAndExtractTransfer","topLevelType","targetInst","nativeEvent","nativeEventTarget","shouldSetEventType","bubbleShouldSetFrom","getLowestCommonAncestor","skipOverBubbleShouldSetFrom","shouldSetEvent","getPooled","touchHistory","accumulateTwoPhaseDispatchesSkipTarget","accumulateTwoPhaseDispatches","wantsResponderInst","isPersistent","constructor","release","extracted","grantEvent","accumulateDirectDispatches","terminationRequestEvent","shouldSwitch","terminateEvent","rejectEvent","canTriggerTransfer","topLevelInst","responderIgnoreScroll","noResponderTouches","touches","length","i","activeTouch","target","undefined","getInstanceFromNode","isAncestor","_getResponderID","_rootNodeID","extractEvents","console","error","recordTouchTrack","isResponderTouchStart","isResponderTouchMove","isResponderTouchEnd","incrementalTouch","gesture","isResponderTerminate","isResponderRelease","finalTouch","finalEvent","numberActiveTouches","GlobalInteractionHandler","injection","injectGlobalResponderHandler","injectGlobalInteractionHandler","module","exports"],"mappings":"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","file":"ResponderEventPlugin.js","sourceRoot":"d:/Work/Office/react-native-on-web/cli/tmpl/project","sourcesContent":["/**\n * Copyright 2013-present, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n */\n\n'use strict';\n\nvar EventPluginUtils = require('./EventPluginUtils');\nvar EventPropagators = require('./EventPropagators');\nvar ResponderSyntheticEvent = require('./ResponderSyntheticEvent');\nvar ResponderTouchHistoryStore = require('./ResponderTouchHistoryStore');\n\nvar accumulate = require('./accumulate');\n\nvar isStartish = EventPluginUtils.isStartish;\nvar isMoveish = EventPluginUtils.isMoveish;\nvar isEndish = EventPluginUtils.isEndish;\nvar executeDirectDispatch = EventPluginUtils.executeDirectDispatch;\nvar hasDispatches = EventPluginUtils.hasDispatches;\nvar executeDispatchesInOrderStopAtTrue = EventPluginUtils.executeDispatchesInOrderStopAtTrue;\n\n/**\n * Instance of element that should respond to touch/move types of interactions,\n * as indicated explicitly by relevant callbacks.\n */\nvar responderInst = null;\n\n/**\n * Count of current touches. A textInput should become responder iff the\n * selection changes while there is a touch on the screen.\n */\nvar trackedTouchCount = 0;\n\n/**\n * Last reported number of active touches.\n */\nvar previousActiveTouches = 0;\n\nvar changeResponder = function (nextResponderInst, blockHostResponder) {\n  var oldResponderInst = responderInst;\n  responderInst = nextResponderInst;\n  if (ResponderEventPlugin.GlobalResponderHandler !== null) {\n    ResponderEventPlugin.GlobalResponderHandler.onChange(oldResponderInst, nextResponderInst, blockHostResponder);\n  }\n};\n\nvar eventTypes = {\n  /**\n   * On a `touchStart`/`mouseDown`, is it desired that this element become the\n   * responder?\n   */\n  startShouldSetResponder: {\n    phasedRegistrationNames: {\n      bubbled: 'onStartShouldSetResponder',\n      captured: 'onStartShouldSetResponderCapture'\n    }\n  },\n\n  /**\n   * On a `scroll`, is it desired that this element become the responder? This\n   * is usually not needed, but should be used to retroactively infer that a\n   * `touchStart` had occurred during momentum scroll. During a momentum scroll,\n   * a touch start will be immediately followed by a scroll event if the view is\n   * currently scrolling.\n   *\n   * TODO: This shouldn't bubble.\n   */\n  scrollShouldSetResponder: {\n    phasedRegistrationNames: {\n      bubbled: 'onScrollShouldSetResponder',\n      captured: 'onScrollShouldSetResponderCapture'\n    }\n  },\n\n  /**\n   * On text selection change, should this element become the responder? This\n   * is needed for text inputs or other views with native selection, so the\n   * JS view can claim the responder.\n   *\n   * TODO: This shouldn't bubble.\n   */\n  selectionChangeShouldSetResponder: {\n    phasedRegistrationNames: {\n      bubbled: 'onSelectionChangeShouldSetResponder',\n      captured: 'onSelectionChangeShouldSetResponderCapture'\n    }\n  },\n\n  /**\n   * On a `touchMove`/`mouseMove`, is it desired that this element become the\n   * responder?\n   */\n  moveShouldSetResponder: {\n    phasedRegistrationNames: {\n      bubbled: 'onMoveShouldSetResponder',\n      captured: 'onMoveShouldSetResponderCapture'\n    }\n  },\n\n  /**\n   * Direct responder events dispatched directly to responder. Do not bubble.\n   */\n  responderStart: { registrationName: 'onResponderStart' },\n  responderMove: { registrationName: 'onResponderMove' },\n  responderEnd: { registrationName: 'onResponderEnd' },\n  responderRelease: { registrationName: 'onResponderRelease' },\n  responderTerminationRequest: {\n    registrationName: 'onResponderTerminationRequest'\n  },\n  responderGrant: { registrationName: 'onResponderGrant' },\n  responderReject: { registrationName: 'onResponderReject' },\n  responderTerminate: { registrationName: 'onResponderTerminate' }\n};\n\n/**\n *\n * Responder System:\n * ----------------\n *\n * - A global, solitary \"interaction lock\" on a view.\n * - If a node becomes the responder, it should convey visual feedback\n *   immediately to indicate so, either by highlighting or moving accordingly.\n * - To be the responder means, that touches are exclusively important to that\n *   responder view, and no other view.\n * - While touches are still occurring, the responder lock can be transferred to\n *   a new view, but only to increasingly \"higher\" views (meaning ancestors of\n *   the current responder).\n *\n * Responder being granted:\n * ------------------------\n *\n * - Touch starts, moves, and scrolls can cause an ID to become the responder.\n * - We capture/bubble `startShouldSetResponder`/`moveShouldSetResponder` to\n *   the \"appropriate place\".\n * - If nothing is currently the responder, the \"appropriate place\" is the\n *   initiating event's `targetID`.\n * - If something *is* already the responder, the \"appropriate place\" is the\n *   first common ancestor of the event target and the current `responderInst`.\n * - Some negotiation happens: See the timing diagram below.\n * - Scrolled views automatically become responder. The reasoning is that a\n *   platform scroll view that isn't built on top of the responder system has\n *   began scrolling, and the active responder must now be notified that the\n *   interaction is no longer locked to it - the system has taken over.\n *\n * - Responder being released:\n *   As soon as no more touches that *started* inside of descendants of the\n *   *current* responderInst, an `onResponderRelease` event is dispatched to the\n *   current responder, and the responder lock is released.\n *\n * TODO:\n * - on \"end\", a callback hook for `onResponderEndShouldRemainResponder` that\n *   determines if the responder lock should remain.\n * - If a view shouldn't \"remain\" the responder, any active touches should by\n *   default be considered \"dead\" and do not influence future negotiations or\n *   bubble paths. It should be as if those touches do not exist.\n * -- For multitouch: Usually a translate-z will choose to \"remain\" responder\n *  after one out of many touches ended. For translate-y, usually the view\n *  doesn't wish to \"remain\" responder after one of many touches end.\n * - Consider building this on top of a `stopPropagation` model similar to\n *   `W3C` events.\n * - Ensure that `onResponderTerminate` is called on touch cancels, whether or\n *   not `onResponderTerminationRequest` returns `true` or `false`.\n *\n */\n\n/*                                             Negotiation Performed\n                                             +-----------------------+\n                                            /                         \\\nProcess low level events to    +     Current Responder      +   wantsResponderID\ndetermine who to perform negot-|   (if any exists at all)   |\niation/transition              | Otherwise just pass through|\n-------------------------------+----------------------------+------------------+\nBubble to find first ID        |                            |\nto return true:wantsResponderID|                            |\n                               |                            |\n     +-------------+           |                            |\n     | onTouchStart|           |                            |\n     +------+------+     none  |                            |\n            |            return|                            |\n+-----------v-------------+true| +------------------------+ |\n|onStartShouldSetResponder|----->|onResponderStart (cur)  |<-----------+\n+-----------+-------------+    | +------------------------+ |          |\n            |                  |                            | +--------+-------+\n            | returned true for|       false:REJECT +-------->|onResponderReject\n            | wantsResponderID |                    |       | +----------------+\n            | (now attempt     | +------------------+-----+ |\n            |  handoff)        | |   onResponder          | |\n            +------------------->|      TerminationRequest| |\n                               | +------------------+-----+ |\n                               |                    |       | +----------------+\n                               |         true:GRANT +-------->|onResponderGrant|\n                               |                            | +--------+-------+\n                               | +------------------------+ |          |\n                               | |   onResponderTerminate |<-----------+\n                               | +------------------+-----+ |\n                               |                    |       | +----------------+\n                               |                    +-------->|onResponderStart|\n                               |                            | +----------------+\nBubble to find first ID        |                            |\nto return true:wantsResponderID|                            |\n                               |                            |\n     +-------------+           |                            |\n     | onTouchMove |           |                            |\n     +------+------+     none  |                            |\n            |            return|                            |\n+-----------v-------------+true| +------------------------+ |\n|onMoveShouldSetResponder |----->|onResponderMove (cur)   |<-----------+\n+-----------+-------------+    | +------------------------+ |          |\n            |                  |                            | +--------+-------+\n            | returned true for|       false:REJECT +-------->|onResponderRejec|\n            | wantsResponderID |                    |       | +----------------+\n            | (now attempt     | +------------------+-----+ |\n            |  handoff)        | |   onResponder          | |\n            +------------------->|      TerminationRequest| |\n                               | +------------------+-----+ |\n                               |                    |       | +----------------+\n                               |         true:GRANT +-------->|onResponderGrant|\n                               |                            | +--------+-------+\n                               | +------------------------+ |          |\n                               | |   onResponderTerminate |<-----------+\n                               | +------------------+-----+ |\n                               |                    |       | +----------------+\n                               |                    +-------->|onResponderMove |\n                               |                            | +----------------+\n                               |                            |\n                               |                            |\n      Some active touch started|                            |\n      inside current responder | +------------------------+ |\n      +------------------------->|      onResponderEnd    | |\n      |                        | +------------------------+ |\n  +---+---------+              |                            |\n  | onTouchEnd  |              |                            |\n  +---+---------+              |                            |\n      |                        | +------------------------+ |\n      +------------------------->|     onResponderEnd     | |\n      No active touches started| +-----------+------------+ |\n      inside current responder |             |              |\n                               |             v              |\n                               | +------------------------+ |\n                               | |    onResponderRelease  | |\n                               | +------------------------+ |\n                               |                            |\n                               +                            + */\n\n/**\n * A note about event ordering in the `EventPluginHub`.\n *\n * Suppose plugins are injected in the following order:\n *\n * `[R, S, C]`\n *\n * To help illustrate the example, assume `S` is `SimpleEventPlugin` (for\n * `onClick` etc) and `R` is `ResponderEventPlugin`.\n *\n * \"Deferred-Dispatched Events\":\n *\n * - The current event plugin system will traverse the list of injected plugins,\n *   in order, and extract events by collecting the plugin's return value of\n *   `extractEvents()`.\n * - These events that are returned from `extractEvents` are \"deferred\n *   dispatched events\".\n * - When returned from `extractEvents`, deferred-dispatched events contain an\n *   \"accumulation\" of deferred dispatches.\n * - These deferred dispatches are accumulated/collected before they are\n *   returned, but processed at a later time by the `EventPluginHub` (hence the\n *   name deferred).\n *\n * In the process of returning their deferred-dispatched events, event plugins\n * themselves can dispatch events on-demand without returning them from\n * `extractEvents`. Plugins might want to do this, so that they can use event\n * dispatching as a tool that helps them decide which events should be extracted\n * in the first place.\n *\n * \"On-Demand-Dispatched Events\":\n *\n * - On-demand-dispatched events are not returned from `extractEvents`.\n * - On-demand-dispatched events are dispatched during the process of returning\n *   the deferred-dispatched events.\n * - They should not have side effects.\n * - They should be avoided, and/or eventually be replaced with another\n *   abstraction that allows event plugins to perform multiple \"rounds\" of event\n *   extraction.\n *\n * Therefore, the sequence of event dispatches becomes:\n *\n * - `R`s on-demand events (if any)   (dispatched by `R` on-demand)\n * - `S`s on-demand events (if any)   (dispatched by `S` on-demand)\n * - `C`s on-demand events (if any)   (dispatched by `C` on-demand)\n * - `R`s extracted events (if any)   (dispatched by `EventPluginHub`)\n * - `S`s extracted events (if any)   (dispatched by `EventPluginHub`)\n * - `C`s extracted events (if any)   (dispatched by `EventPluginHub`)\n *\n * In the case of `ResponderEventPlugin`: If the `startShouldSetResponder`\n * on-demand dispatch returns `true` (and some other details are satisfied) the\n * `onResponderGrant` deferred dispatched event is returned from\n * `extractEvents`. The sequence of dispatch executions in this case\n * will appear as follows:\n *\n * - `startShouldSetResponder` (`ResponderEventPlugin` dispatches on-demand)\n * - `touchStartCapture`       (`EventPluginHub` dispatches as usual)\n * - `touchStart`              (`EventPluginHub` dispatches as usual)\n * - `responderGrant/Reject`   (`EventPluginHub` dispatches as usual)\n */\n\nfunction setResponderAndExtractTransfer(topLevelType, targetInst, nativeEvent, nativeEventTarget) {\n  var shouldSetEventType = isStartish(topLevelType) ? eventTypes.startShouldSetResponder : isMoveish(topLevelType) ? eventTypes.moveShouldSetResponder : topLevelType === 'topSelectionChange' ? eventTypes.selectionChangeShouldSetResponder : eventTypes.scrollShouldSetResponder;\n\n  // TODO: stop one short of the current responder.\n  var bubbleShouldSetFrom = !responderInst ? targetInst : EventPluginUtils.getLowestCommonAncestor(responderInst, targetInst);\n\n  // When capturing/bubbling the \"shouldSet\" event, we want to skip the target\n  // (deepest ID) if it happens to be the current responder. The reasoning:\n  // It's strange to get an `onMoveShouldSetResponder` when you're *already*\n  // the responder.\n  var skipOverBubbleShouldSetFrom = bubbleShouldSetFrom === responderInst;\n  var shouldSetEvent = ResponderSyntheticEvent.getPooled(shouldSetEventType, bubbleShouldSetFrom, nativeEvent, nativeEventTarget);\n  shouldSetEvent.touchHistory = ResponderTouchHistoryStore.touchHistory;\n  if (skipOverBubbleShouldSetFrom) {\n    EventPropagators.accumulateTwoPhaseDispatchesSkipTarget(shouldSetEvent);\n  } else {\n    EventPropagators.accumulateTwoPhaseDispatches(shouldSetEvent);\n  }\n  var wantsResponderInst = executeDispatchesInOrderStopAtTrue(shouldSetEvent);\n  if (!shouldSetEvent.isPersistent()) {\n    shouldSetEvent.constructor.release(shouldSetEvent);\n  }\n\n  if (!wantsResponderInst || wantsResponderInst === responderInst) {\n    return null;\n  }\n  var extracted;\n  var grantEvent = ResponderSyntheticEvent.getPooled(eventTypes.responderGrant, wantsResponderInst, nativeEvent, nativeEventTarget);\n  grantEvent.touchHistory = ResponderTouchHistoryStore.touchHistory;\n\n  EventPropagators.accumulateDirectDispatches(grantEvent);\n  var blockHostResponder = executeDirectDispatch(grantEvent) === true;\n  if (responderInst) {\n    var terminationRequestEvent = ResponderSyntheticEvent.getPooled(eventTypes.responderTerminationRequest, responderInst, nativeEvent, nativeEventTarget);\n    terminationRequestEvent.touchHistory = ResponderTouchHistoryStore.touchHistory;\n    EventPropagators.accumulateDirectDispatches(terminationRequestEvent);\n    var shouldSwitch = !hasDispatches(terminationRequestEvent) || executeDirectDispatch(terminationRequestEvent);\n    if (!terminationRequestEvent.isPersistent()) {\n      terminationRequestEvent.constructor.release(terminationRequestEvent);\n    }\n\n    if (shouldSwitch) {\n      var terminateEvent = ResponderSyntheticEvent.getPooled(eventTypes.responderTerminate, responderInst, nativeEvent, nativeEventTarget);\n      terminateEvent.touchHistory = ResponderTouchHistoryStore.touchHistory;\n      EventPropagators.accumulateDirectDispatches(terminateEvent);\n      extracted = accumulate(extracted, [grantEvent, terminateEvent]);\n      changeResponder(wantsResponderInst, blockHostResponder);\n    } else {\n      var rejectEvent = ResponderSyntheticEvent.getPooled(eventTypes.responderReject, wantsResponderInst, nativeEvent, nativeEventTarget);\n      rejectEvent.touchHistory = ResponderTouchHistoryStore.touchHistory;\n      EventPropagators.accumulateDirectDispatches(rejectEvent);\n      extracted = accumulate(extracted, rejectEvent);\n    }\n  } else {\n    extracted = accumulate(extracted, grantEvent);\n    changeResponder(wantsResponderInst, blockHostResponder);\n  }\n  return extracted;\n}\n\n/**\n * A transfer is a negotiation between a currently set responder and the next\n * element to claim responder status. Any start event could trigger a transfer\n * of responderInst. Any move event could trigger a transfer.\n *\n * @param {string} topLevelType Record from `EventConstants`.\n * @return {boolean} True if a transfer of responder could possibly occur.\n */\nfunction canTriggerTransfer(topLevelType, topLevelInst, nativeEvent) {\n  return topLevelInst && (\n  // responderIgnoreScroll: We are trying to migrate away from specifically\n  // tracking native scroll events here and responderIgnoreScroll indicates we\n  // will send topTouchCancel to handle canceling touch events instead\n  topLevelType === 'topScroll' && !nativeEvent.responderIgnoreScroll || trackedTouchCount > 0 && topLevelType === 'topSelectionChange' || isStartish(topLevelType) || isMoveish(topLevelType));\n}\n\n/**\n * Returns whether or not this touch end event makes it such that there are no\n * longer any touches that started inside of the current `responderInst`.\n *\n * @param {NativeEvent} nativeEvent Native touch end event.\n * @return {boolean} Whether or not this touch end event ends the responder.\n */\nfunction noResponderTouches(nativeEvent) {\n  var touches = nativeEvent.touches;\n  if (!touches || touches.length === 0) {\n    return true;\n  }\n  for (var i = 0; i < touches.length; i++) {\n    var activeTouch = touches[i];\n    var target = activeTouch.target;\n    if (target !== null && target !== undefined && target !== 0) {\n      // Is the original touch location inside of the current responder?\n      var targetInst = EventPluginUtils.getInstanceFromNode(target);\n      if (EventPluginUtils.isAncestor(responderInst, targetInst)) {\n        return false;\n      }\n    }\n  }\n  return true;\n}\n\nvar ResponderEventPlugin = {\n  /* For unit testing only */\n  _getResponderID: function () {\n    return responderInst ? responderInst._rootNodeID : null;\n  },\n\n  eventTypes: eventTypes,\n\n  /**\n   * We must be resilient to `targetInst` being `null` on `touchMove` or\n   * `touchEnd`. On certain platforms, this means that a native scroll has\n   * assumed control and the original touch targets are destroyed.\n   */\n  extractEvents: function (topLevelType, targetInst, nativeEvent, nativeEventTarget) {\n    if (isStartish(topLevelType)) {\n      trackedTouchCount += 1;\n    } else if (isEndish(topLevelType)) {\n      if (trackedTouchCount >= 0) {\n        trackedTouchCount -= 1;\n      } else {\n        console.error('Ended a touch event which was not counted in `trackedTouchCount`.');\n        return null;\n      }\n    }\n\n    ResponderTouchHistoryStore.recordTouchTrack(topLevelType, nativeEvent);\n\n    var extracted = canTriggerTransfer(topLevelType, targetInst, nativeEvent) ? setResponderAndExtractTransfer(topLevelType, targetInst, nativeEvent, nativeEventTarget) : null;\n    // Responder may or may not have transferred on a new touch start/move.\n    // Regardless, whoever is the responder after any potential transfer, we\n    // direct all touch start/move/ends to them in the form of\n    // `onResponderMove/Start/End`. These will be called for *every* additional\n    // finger that move/start/end, dispatched directly to whoever is the\n    // current responder at that moment, until the responder is \"released\".\n    //\n    // These multiple individual change touch events are are always bookended\n    // by `onResponderGrant`, and one of\n    // (`onResponderRelease/onResponderTerminate`).\n    var isResponderTouchStart = responderInst && isStartish(topLevelType);\n    var isResponderTouchMove = responderInst && isMoveish(topLevelType);\n    var isResponderTouchEnd = responderInst && isEndish(topLevelType);\n    var incrementalTouch = isResponderTouchStart ? eventTypes.responderStart : isResponderTouchMove ? eventTypes.responderMove : isResponderTouchEnd ? eventTypes.responderEnd : null;\n\n    if (incrementalTouch) {\n      var gesture = ResponderSyntheticEvent.getPooled(incrementalTouch, responderInst, nativeEvent, nativeEventTarget);\n      gesture.touchHistory = ResponderTouchHistoryStore.touchHistory;\n      EventPropagators.accumulateDirectDispatches(gesture);\n      extracted = accumulate(extracted, gesture);\n    }\n\n    var isResponderTerminate = responderInst && topLevelType === 'topTouchCancel';\n    var isResponderRelease = responderInst && !isResponderTerminate && isEndish(topLevelType) && noResponderTouches(nativeEvent);\n    var finalTouch = isResponderTerminate ? eventTypes.responderTerminate : isResponderRelease ? eventTypes.responderRelease : null;\n    if (finalTouch) {\n      var finalEvent = ResponderSyntheticEvent.getPooled(finalTouch, responderInst, nativeEvent, nativeEventTarget);\n      finalEvent.touchHistory = ResponderTouchHistoryStore.touchHistory;\n      EventPropagators.accumulateDirectDispatches(finalEvent);\n      extracted = accumulate(extracted, finalEvent);\n      changeResponder(null);\n    }\n\n    var numberActiveTouches = ResponderTouchHistoryStore.touchHistory.numberActiveTouches;\n    if (ResponderEventPlugin.GlobalInteractionHandler && numberActiveTouches !== previousActiveTouches) {\n      ResponderEventPlugin.GlobalInteractionHandler.onChange(numberActiveTouches);\n    }\n    previousActiveTouches = numberActiveTouches;\n\n    return extracted;\n  },\n\n  GlobalResponderHandler: null,\n  GlobalInteractionHandler: null,\n\n  injection: {\n    /**\n     * @param {{onChange: (ReactID, ReactID) => void} GlobalResponderHandler\n     * Object that handles any change in responder. Use this to inject\n     * integration with an existing touch handling system etc.\n     */\n    injectGlobalResponderHandler: function (GlobalResponderHandler) {\n      ResponderEventPlugin.GlobalResponderHandler = GlobalResponderHandler;\n    },\n\n    /**\n     * @param {{onChange: (numberActiveTouches) => void} GlobalInteractionHandler\n     * Object that handles any change in the number of active touches.\n     */\n    injectGlobalInteractionHandler: function (GlobalInteractionHandler) {\n      ResponderEventPlugin.GlobalInteractionHandler = GlobalInteractionHandler;\n    }\n  }\n};\n\nmodule.exports = ResponderEventPlugin;"]}