react 0.14.0-alpha2 → 0.14.0-beta3

package/lib/ResponderSyntheticEvent.js

@@ -0,0 +1,40 @@
+/**
+ * Copyright 2013-2015, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ *
+ * @providesModule ResponderSyntheticEvent
+ * @typechecks static-only
+ */
+
+'use strict';
+
+var SyntheticEvent = require('./SyntheticEvent');
+
+/**
+ * `touchHistory` isn't actually on the native event, but putting it in the
+ * interface will ensure that it is cleaned up when pooled/destroyed. The
+ * `ResponderEventPlugin` will populate it appropriately.
+ */
+var ResponderEventInterface = {
+  touchHistory: function (nativeEvent) {
+    return null; // Actually doesn't even look at the native event.
+  }
+};
+
+/**
+ * @param {object} dispatchConfig Configuration used to dispatch this event.
+ * @param {string} dispatchMarker Marker identifying the event target.
+ * @param {object} nativeEvent Native event.
+ * @extends {SyntheticEvent}
+ */
+function ResponderSyntheticEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) {
+  SyntheticEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget);
+}
+
+SyntheticEvent.augmentClass(ResponderSyntheticEvent, ResponderEventInterface);
+
+module.exports = ResponderSyntheticEvent;

package/lib/ResponderTouchHistoryStore.js

@@ -0,0 +1,180 @@
+/**
+ * Copyright 2013-2015, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ *
+ * @providesModule ResponderTouchHistoryStore
+ */
+
+'use strict';
+
+var EventPluginUtils = require('./EventPluginUtils');
+
+var invariant = require('fbjs/lib/invariant');
+
+var isMoveish = EventPluginUtils.isMoveish;
+var isStartish = EventPluginUtils.isStartish;
+var isEndish = EventPluginUtils.isEndish;
+
+var MAX_TOUCH_BANK = 20;
+
+/**
+ * Touch position/time tracking information by touchID. Typically, we'll only
+ * see IDs with a range of 1-20 (they are recycled when touches end and then
+ * start again). This data is commonly needed by many different interaction
+ * logic modules so precomputing it is very helpful to do once.
+ * Each touch object in `touchBank` is of the following form:
+ * { touchActive: boolean,
+ *   startTimeStamp: number,
+ *   startPageX: number,
+ *   startPageY: number,
+ *   currentPageX: number,
+ *   currentPageY: number,
+ *   currentTimeStamp: number
+ * }
+ */
+var touchHistory = {
+  touchBank: [],
+  numberActiveTouches: 0,
+  // If there is only one active touch, we remember its location. This prevents
+  // us having to loop through all of the touches all the time in the most
+  // common case.
+  indexOfSingleActiveTouch: -1,
+  mostRecentTimeStamp: 0
+};
+
+var timestampForTouch = function (touch) {
+  // The legacy internal implementation provides "timeStamp", which has been
+  // renamed to "timestamp". Let both work for now while we iron it out
+  // TODO (evv): rename timeStamp to timestamp in internal code
+  return touch.timeStamp || touch.timestamp;
+};
+
+/**
+ * TODO: Instead of making gestures recompute filtered velocity, we could
+ * include a built in velocity computation that can be reused globally.
+ * @param {Touch} touch Native touch object.
+ */
+var initializeTouchData = function (touch) {
+  return {
+    touchActive: true,
+    startTimeStamp: timestampForTouch(touch),
+    startPageX: touch.pageX,
+    startPageY: touch.pageY,
+    currentPageX: touch.pageX,
+    currentPageY: touch.pageY,
+    currentTimeStamp: timestampForTouch(touch),
+    previousPageX: touch.pageX,
+    previousPageY: touch.pageY,
+    previousTimeStamp: timestampForTouch(touch)
+  };
+};
+
+var reinitializeTouchTrack = function (touchTrack, touch) {
+  touchTrack.touchActive = true;
+  touchTrack.startTimeStamp = timestampForTouch(touch);
+  touchTrack.startPageX = touch.pageX;
+  touchTrack.startPageY = touch.pageY;
+  touchTrack.currentPageX = touch.pageX;
+  touchTrack.currentPageY = touch.pageY;
+  touchTrack.currentTimeStamp = timestampForTouch(touch);
+  touchTrack.previousPageX = touch.pageX;
+  touchTrack.previousPageY = touch.pageY;
+  touchTrack.previousTimeStamp = timestampForTouch(touch);
+};
+
+var validateTouch = function (touch) {
+  var identifier = touch.identifier;
+  !(identifier != null) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Touch object is missing identifier') : invariant(false) : undefined;
+  if (identifier > MAX_TOUCH_BANK) {
+    console.warn('Touch identifier ' + identifier + ' is greater than maximum ' + 'supported ' + MAX_TOUCH_BANK + ' which causes performance issues ' + 'backfilling array locations for all of the indices.');
+  }
+};
+
+var recordStartTouchData = function (touch) {
+  var touchBank = touchHistory.touchBank;
+  var identifier = touch.identifier;
+  var touchTrack = touchBank[identifier];
+  if (process.env.NODE_ENV !== 'production') {
+    validateTouch(touch);
+  }
+  if (touchTrack) {
+    reinitializeTouchTrack(touchTrack, touch);
+  } else {
+    touchBank[touch.identifier] = initializeTouchData(touch);
+  }
+  touchHistory.mostRecentTimeStamp = timestampForTouch(touch);
+};
+
+var recordMoveTouchData = function (touch) {
+  var touchBank = touchHistory.touchBank;
+  var touchTrack = touchBank[touch.identifier];
+  if (process.env.NODE_ENV !== 'production') {
+    validateTouch(touch);
+    !touchTrack ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Touch data should have been recorded on start') : invariant(false) : undefined;
+  }
+  touchTrack.touchActive = true;
+  touchTrack.previousPageX = touchTrack.currentPageX;
+  touchTrack.previousPageY = touchTrack.currentPageY;
+  touchTrack.previousTimeStamp = touchTrack.currentTimeStamp;
+  touchTrack.currentPageX = touch.pageX;
+  touchTrack.currentPageY = touch.pageY;
+  touchTrack.currentTimeStamp = timestampForTouch(touch);
+  touchHistory.mostRecentTimeStamp = timestampForTouch(touch);
+};
+
+var recordEndTouchData = function (touch) {
+  var touchBank = touchHistory.touchBank;
+  var touchTrack = touchBank[touch.identifier];
+  if (process.env.NODE_ENV !== 'production') {
+    validateTouch(touch);
+    !touchTrack ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Touch data should have been recorded on start') : invariant(false) : undefined;
+  }
+  touchTrack.previousPageX = touchTrack.currentPageX;
+  touchTrack.previousPageY = touchTrack.currentPageY;
+  touchTrack.previousTimeStamp = touchTrack.currentTimeStamp;
+  touchTrack.currentPageX = touch.pageX;
+  touchTrack.currentPageY = touch.pageY;
+  touchTrack.currentTimeStamp = timestampForTouch(touch);
+  touchTrack.touchActive = false;
+  touchHistory.mostRecentTimeStamp = timestampForTouch(touch);
+};
+
+var ResponderTouchHistoryStore = {
+  recordTouchTrack: function (topLevelType, nativeEvent) {
+    var touchBank = touchHistory.touchBank;
+    if (isMoveish(topLevelType)) {
+      nativeEvent.changedTouches.forEach(recordMoveTouchData);
+    } else if (isStartish(topLevelType)) {
+      nativeEvent.changedTouches.forEach(recordStartTouchData);
+      touchHistory.numberActiveTouches = nativeEvent.touches.length;
+      if (touchHistory.numberActiveTouches === 1) {
+        touchHistory.indexOfSingleActiveTouch = nativeEvent.touches[0].identifier;
+      }
+    } else if (isEndish(topLevelType)) {
+      nativeEvent.changedTouches.forEach(recordEndTouchData);
+      touchHistory.numberActiveTouches = nativeEvent.touches.length;
+      if (touchHistory.numberActiveTouches === 1) {
+        for (var i = 0; i < touchBank.length; i++) {
+          var touchTrackToCheck = touchBank[i];
+          if (touchTrackToCheck != null && touchTrackToCheck.touchActive) {
+            touchHistory.indexOfSingleActiveTouch = i;
+            break;
+          }
+        }
+        if (process.env.NODE_ENV !== 'production') {
+          var activeTouchData = touchBank[touchHistory.indexOfSingleActiveTouch];
+          var foundActive = activeTouchData != null && !!activeTouchData.touchActive;
+          !foundActive ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Cannot find single active touch') : invariant(false) : undefined;
+        }
+      }
+    }
+  },
+
+  touchHistory: touchHistory
+};
+
+module.exports = ResponderTouchHistoryStore;

package/lib/SVGDOMPropertyConfig.js

@@ -11,7 +11,7 @@
 
 'use strict';
 
-var DOMProperty = require("./DOMProperty");
+var DOMProperty = require('./DOMProperty');
 
 var MUST_USE_ATTRIBUTE = DOMProperty.injection.MUST_USE_ATTRIBUTE;
 

package/lib/SelectEventPlugin.js

@@ -11,15 +11,15 @@
 
 'use strict';
 
-var EventConstants = require("./EventConstants");
-var EventPropagators = require("./EventPropagators");
-var ReactInputSelection = require("./ReactInputSelection");
-var SyntheticEvent = require("./SyntheticEvent");
+var EventConstants = require('./EventConstants');
+var EventPropagators = require('./EventPropagators');
+var ReactInputSelection = require('./ReactInputSelection');
+var SyntheticEvent = require('./SyntheticEvent');
 
-var getActiveElement = require("./getActiveElement");
-var isTextInputElement = require("./isTextInputElement");
-var keyOf = require("./keyOf");
-var shallowEqual = require("./shallowEqual");
+var getActiveElement = require('fbjs/lib/getActiveElement');
+var isTextInputElement = require('./isTextInputElement');
+var keyOf = require('fbjs/lib/keyOf');
+var shallowEqual = require('fbjs/lib/shallowEqual');
 
 var topLevelTypes = EventConstants.topLevelTypes;
 
@@ -50,7 +50,7 @@ var ON_SELECT_KEY = keyOf({ onSelect: null });
  * two identical selections on the same node will return identical objects.
  *
  * @param {DOMElement} node
- * @param {object}
+ * @return {object}
  */
 function getSelection(node) {
   if ('selectionStart' in node && ReactInputSelection.hasSelectionCapabilities(node)) {
@@ -83,7 +83,7 @@ function getSelection(node) {
  * @param {object} nativeEvent
  * @return {?SyntheticEvent}
  */
-function constructSelectEvent(nativeEvent) {
+function constructSelectEvent(nativeEvent, nativeEventTarget) {
   // Ensure we have the right element, and that the user is not dragging a
   // selection (this matches native `select` event behavior). In HTML5, select
   // fires only on input and textarea thus if there's no focused element we
@@ -97,7 +97,7 @@ function constructSelectEvent(nativeEvent) {
   if (!lastSelection || !shallowEqual(lastSelection, currentSelection)) {
     lastSelection = currentSelection;
 
-    var syntheticEvent = SyntheticEvent.getPooled(eventTypes.select, activeElementID, nativeEvent);
+    var syntheticEvent = SyntheticEvent.getPooled(eventTypes.select, activeElementID, nativeEvent, nativeEventTarget);
 
     syntheticEvent.type = 'select';
     syntheticEvent.target = activeElement;
@@ -136,8 +136,7 @@ var SelectEventPlugin = {
    * @return {*} An accumulation of synthetic events.
    * @see {EventPluginHub.extractEvents}
    */
-  extractEvents: function (topLevelType, topLevelTarget, topLevelTargetID, nativeEvent) {
-
+  extractEvents: function (topLevelType, topLevelTarget, topLevelTargetID, nativeEvent, nativeEventTarget) {
     if (!hasListener) {
       return null;
     }
@@ -165,7 +164,7 @@ var SelectEventPlugin = {
       case topLevelTypes.topContextMenu:
       case topLevelTypes.topMouseUp:
         mouseDown = false;
-        return constructSelectEvent(nativeEvent);
+        return constructSelectEvent(nativeEvent, nativeEventTarget);
 
       // Chrome and IE fire non-standard event when selection is changed (and
       // sometimes when it hasn't).
@@ -176,7 +175,7 @@ var SelectEventPlugin = {
       case topLevelTypes.topSelectionChange:
       case topLevelTypes.topKeyDown:
       case topLevelTypes.topKeyUp:
-        return constructSelectEvent(nativeEvent);
+        return constructSelectEvent(nativeEvent, nativeEventTarget);
     }
 
     return null;

package/lib/SimpleEventPlugin.js

@@ -11,36 +11,54 @@
 
 'use strict';
 
-var EventConstants = require("./EventConstants");
-var EventListener = require("./EventListener");
-var EventPluginUtils = require("./EventPluginUtils");
-var EventPropagators = require("./EventPropagators");
-var ReactMount = require("./ReactMount");
-var SyntheticClipboardEvent = require("./SyntheticClipboardEvent");
-var SyntheticEvent = require("./SyntheticEvent");
-var SyntheticFocusEvent = require("./SyntheticFocusEvent");
-var SyntheticKeyboardEvent = require("./SyntheticKeyboardEvent");
-var SyntheticMouseEvent = require("./SyntheticMouseEvent");
-var SyntheticDragEvent = require("./SyntheticDragEvent");
-var SyntheticTouchEvent = require("./SyntheticTouchEvent");
-var SyntheticUIEvent = require("./SyntheticUIEvent");
-var SyntheticWheelEvent = require("./SyntheticWheelEvent");
+var EventConstants = require('./EventConstants');
+var EventListener = require('fbjs/lib/EventListener');
+var EventPluginUtils = require('./EventPluginUtils');
+var EventPropagators = require('./EventPropagators');
+var ReactMount = require('./ReactMount');
+var SyntheticClipboardEvent = require('./SyntheticClipboardEvent');
+var SyntheticEvent = require('./SyntheticEvent');
+var SyntheticFocusEvent = require('./SyntheticFocusEvent');
+var SyntheticKeyboardEvent = require('./SyntheticKeyboardEvent');
+var SyntheticMouseEvent = require('./SyntheticMouseEvent');
+var SyntheticDragEvent = require('./SyntheticDragEvent');
+var SyntheticTouchEvent = require('./SyntheticTouchEvent');
+var SyntheticUIEvent = require('./SyntheticUIEvent');
+var SyntheticWheelEvent = require('./SyntheticWheelEvent');
 
-var emptyFunction = require("./emptyFunction");
-var getEventCharCode = require("./getEventCharCode");
-var invariant = require("./invariant");
-var keyOf = require("./keyOf");
-var warning = require("./warning");
+var emptyFunction = require('fbjs/lib/emptyFunction');
+var getEventCharCode = require('./getEventCharCode');
+var invariant = require('fbjs/lib/invariant');
+var keyOf = require('fbjs/lib/keyOf');
+var warning = require('fbjs/lib/warning');
 
 var topLevelTypes = EventConstants.topLevelTypes;
 
 var eventTypes = {
+  abort: {
+    phasedRegistrationNames: {
+      bubbled: keyOf({ onAbort: true }),
+      captured: keyOf({ onAbortCapture: true })
+    }
+  },
   blur: {
     phasedRegistrationNames: {
       bubbled: keyOf({ onBlur: true }),
       captured: keyOf({ onBlurCapture: true })
     }
   },
+  canPlay: {
+    phasedRegistrationNames: {
+      bubbled: keyOf({ onCanPlay: true }),
+      captured: keyOf({ onCanPlayCapture: true })
+    }
+  },
+  canPlayThrough: {
+    phasedRegistrationNames: {
+      bubbled: keyOf({ onCanPlayThrough: true }),
+      captured: keyOf({ onCanPlayThroughCapture: true })
+    }
+  },
   click: {
     phasedRegistrationNames: {
       bubbled: keyOf({ onClick: true }),
@@ -119,6 +137,36 @@ var eventTypes = {
       captured: keyOf({ onDropCapture: true })
     }
   },
+  durationChange: {
+    phasedRegistrationNames: {
+      bubbled: keyOf({ onDurationChange: true }),
+      captured: keyOf({ onDurationChangeCapture: true })
+    }
+  },
+  emptied: {
+    phasedRegistrationNames: {
+      bubbled: keyOf({ onEmptied: true }),
+      captured: keyOf({ onEmptiedCapture: true })
+    }
+  },
+  encrypted: {
+    phasedRegistrationNames: {
+      bubbled: keyOf({ onEncrypted: true }),
+      captured: keyOf({ onEncryptedCapture: true })
+    }
+  },
+  ended: {
+    phasedRegistrationNames: {
+      bubbled: keyOf({ onEnded: true }),
+      captured: keyOf({ onEndedCapture: true })
+    }
+  },
+  error: {
+    phasedRegistrationNames: {
+      bubbled: keyOf({ onError: true }),
+      captured: keyOf({ onErrorCapture: true })
+    }
+  },
   focus: {
     phasedRegistrationNames: {
       bubbled: keyOf({ onFocus: true }),
@@ -155,10 +203,22 @@ var eventTypes = {
       captured: keyOf({ onLoadCapture: true })
     }
   },
-  error: {
+  loadedData: {
     phasedRegistrationNames: {
-      bubbled: keyOf({ onError: true }),
-      captured: keyOf({ onErrorCapture: true })
+      bubbled: keyOf({ onLoadedData: true }),
+      captured: keyOf({ onLoadedDataCapture: true })
+    }
+  },
+  loadedMetadata: {
+    phasedRegistrationNames: {
+      bubbled: keyOf({ onLoadedMetadata: true }),
+      captured: keyOf({ onLoadedMetadataCapture: true })
+    }
+  },
+  loadStart: {
+    phasedRegistrationNames: {
+      bubbled: keyOf({ onLoadStart: true }),
+      captured: keyOf({ onLoadStartCapture: true })
     }
   },
   // Note: We do not allow listening to mouseOver events. Instead, use the
@@ -199,6 +259,36 @@ var eventTypes = {
       captured: keyOf({ onPasteCapture: true })
     }
   },
+  pause: {
+    phasedRegistrationNames: {
+      bubbled: keyOf({ onPause: true }),
+      captured: keyOf({ onPauseCapture: true })
+    }
+  },
+  play: {
+    phasedRegistrationNames: {
+      bubbled: keyOf({ onPlay: true }),
+      captured: keyOf({ onPlayCapture: true })
+    }
+  },
+  playing: {
+    phasedRegistrationNames: {
+      bubbled: keyOf({ onPlaying: true }),
+      captured: keyOf({ onPlayingCapture: true })
+    }
+  },
+  progress: {
+    phasedRegistrationNames: {
+      bubbled: keyOf({ onProgress: true }),
+      captured: keyOf({ onProgressCapture: true })
+    }
+  },
+  rateChange: {
+    phasedRegistrationNames: {
+      bubbled: keyOf({ onRateChange: true }),
+      captured: keyOf({ onRateChangeCapture: true })
+    }
+  },
   reset: {
     phasedRegistrationNames: {
       bubbled: keyOf({ onReset: true }),
@@ -211,12 +301,42 @@ var eventTypes = {
       captured: keyOf({ onScrollCapture: true })
     }
   },
+  seeked: {
+    phasedRegistrationNames: {
+      bubbled: keyOf({ onSeeked: true }),
+      captured: keyOf({ onSeekedCapture: true })
+    }
+  },
+  seeking: {
+    phasedRegistrationNames: {
+      bubbled: keyOf({ onSeeking: true }),
+      captured: keyOf({ onSeekingCapture: true })
+    }
+  },
+  stalled: {
+    phasedRegistrationNames: {
+      bubbled: keyOf({ onStalled: true }),
+      captured: keyOf({ onStalledCapture: true })
+    }
+  },
   submit: {
     phasedRegistrationNames: {
       bubbled: keyOf({ onSubmit: true }),
       captured: keyOf({ onSubmitCapture: true })
     }
   },
+  suspend: {
+    phasedRegistrationNames: {
+      bubbled: keyOf({ onSuspend: true }),
+      captured: keyOf({ onSuspendCapture: true })
+    }
+  },
+  timeUpdate: {
+    phasedRegistrationNames: {
+      bubbled: keyOf({ onTimeUpdate: true }),
+      captured: keyOf({ onTimeUpdateCapture: true })
+    }
+  },
   touchCancel: {
     phasedRegistrationNames: {
       bubbled: keyOf({ onTouchCancel: true }),
@@ -241,6 +361,18 @@ var eventTypes = {
       captured: keyOf({ onTouchStartCapture: true })
     }
   },
+  volumeChange: {
+    phasedRegistrationNames: {
+      bubbled: keyOf({ onVolumeChange: true }),
+      captured: keyOf({ onVolumeChangeCapture: true })
+    }
+  },
+  waiting: {
+    phasedRegistrationNames: {
+      bubbled: keyOf({ onWaiting: true }),
+      captured: keyOf({ onWaitingCapture: true })
+    }
+  },
   wheel: {
     phasedRegistrationNames: {
       bubbled: keyOf({ onWheel: true }),
@@ -250,7 +382,10 @@ var eventTypes = {
 };
 
 var topLevelEventsToDispatchConfig = {
+  topAbort: eventTypes.abort,
   topBlur: eventTypes.blur,
+  topCanPlay: eventTypes.canPlay,
+  topCanPlayThrough: eventTypes.canPlayThrough,
   topClick: eventTypes.click,
   topContextMenu: eventTypes.contextMenu,
   topCopy: eventTypes.copy,
@@ -264,6 +399,10 @@ var topLevelEventsToDispatchConfig = {
   topDragOver: eventTypes.dragOver,
   topDragStart: eventTypes.dragStart,
   topDrop: eventTypes.drop,
+  topDurationChange: eventTypes.durationChange,
+  topEmptied: eventTypes.emptied,
+  topEncrypted: eventTypes.encrypted,
+  topEnded: eventTypes.ended,
   topError: eventTypes.error,
   topFocus: eventTypes.focus,
   topInput: eventTypes.input,
@@ -271,19 +410,34 @@ var topLevelEventsToDispatchConfig = {
   topKeyPress: eventTypes.keyPress,
   topKeyUp: eventTypes.keyUp,
   topLoad: eventTypes.load,
+  topLoadedData: eventTypes.loadedData,
+  topLoadedMetadata: eventTypes.loadedMetadata,
+  topLoadStart: eventTypes.loadStart,
   topMouseDown: eventTypes.mouseDown,
   topMouseMove: eventTypes.mouseMove,
   topMouseOut: eventTypes.mouseOut,
   topMouseOver: eventTypes.mouseOver,
   topMouseUp: eventTypes.mouseUp,
+  topPause: eventTypes.pause,
   topPaste: eventTypes.paste,
+  topPlay: eventTypes.play,
+  topPlaying: eventTypes.playing,
+  topProgress: eventTypes.progress,
+  topRateChange: eventTypes.rateChange,
   topReset: eventTypes.reset,
+  topSeeked: eventTypes.seeked,
+  topSeeking: eventTypes.seeking,
   topScroll: eventTypes.scroll,
+  topStalled: eventTypes.stalled,
   topSubmit: eventTypes.submit,
+  topSuspend: eventTypes.suspend,
+  topTimeUpdate: eventTypes.timeUpdate,
   topTouchCancel: eventTypes.touchCancel,
   topTouchEnd: eventTypes.touchEnd,
   topTouchMove: eventTypes.touchMove,
   topTouchStart: eventTypes.touchStart,
+  topVolumeChange: eventTypes.volumeChange,
+  topWaiting: eventTypes.waiting,
   topWheel: eventTypes.wheel
 };
 
@@ -302,14 +456,14 @@ var SimpleEventPlugin = {
    * Same as the default implementation, except cancels the event when return
    * value is false. This behavior will be disabled in a future release.
    *
-   * @param {object} Event to be dispatched.
-   * @param {function} Application-level callback.
+   * @param {object} event Event to be dispatched.
+   * @param {function} listener Application-level callback.
    * @param {string} domID DOM ID to pass to the callback.
    */
   executeDispatch: function (event, listener, domID) {
     var returnValue = EventPluginUtils.executeDispatch(event, listener, domID);
 
-    'production' !== process.env.NODE_ENV ? warning(typeof returnValue !== 'boolean', 'Returning `false` from an event handler is deprecated and will be ' + 'ignored in a future release. Instead, manually call ' + 'e.stopPropagation() or e.preventDefault(), as appropriate.') : null;
+    process.env.NODE_ENV !== 'production' ? warning(typeof returnValue !== 'boolean', 'Returning `false` from an event handler is deprecated and will be ' + 'ignored in a future release. Instead, manually call ' + 'e.stopPropagation() or e.preventDefault(), as appropriate.') : undefined;
 
     if (returnValue === false) {
       event.stopPropagation();
@@ -325,18 +479,40 @@ var SimpleEventPlugin = {
    * @return {*} An accumulation of synthetic events.
    * @see {EventPluginHub.extractEvents}
    */
-  extractEvents: function (topLevelType, topLevelTarget, topLevelTargetID, nativeEvent) {
+  extractEvents: function (topLevelType, topLevelTarget, topLevelTargetID, nativeEvent, nativeEventTarget) {
     var dispatchConfig = topLevelEventsToDispatchConfig[topLevelType];
     if (!dispatchConfig) {
       return null;
     }
     var EventConstructor;
     switch (topLevelType) {
+      case topLevelTypes.topAbort:
+      case topLevelTypes.topCanPlay:
+      case topLevelTypes.topCanPlayThrough:
+      case topLevelTypes.topDurationChange:
+      case topLevelTypes.topEmptied:
+      case topLevelTypes.topEncrypted:
+      case topLevelTypes.topEnded:
+      case topLevelTypes.topError:
       case topLevelTypes.topInput:
       case topLevelTypes.topLoad:
-      case topLevelTypes.topError:
+      case topLevelTypes.topLoadedData:
+      case topLevelTypes.topLoadedMetadata:
+      case topLevelTypes.topLoadStart:
+      case topLevelTypes.topPause:
+      case topLevelTypes.topPlay:
+      case topLevelTypes.topPlaying:
+      case topLevelTypes.topProgress:
+      case topLevelTypes.topRateChange:
       case topLevelTypes.topReset:
+      case topLevelTypes.topSeeked:
+      case topLevelTypes.topSeeking:
+      case topLevelTypes.topStalled:
       case topLevelTypes.topSubmit:
+      case topLevelTypes.topSuspend:
+      case topLevelTypes.topTimeUpdate:
+      case topLevelTypes.topVolumeChange:
+      case topLevelTypes.topWaiting:
         // HTML Events
         // @see http://www.w3.org/TR/html5/index.html#events-0
         EventConstructor = SyntheticEvent;
@@ -401,8 +577,8 @@ var SimpleEventPlugin = {
         EventConstructor = SyntheticClipboardEvent;
         break;
     }
-    'production' !== process.env.NODE_ENV ? invariant(EventConstructor, 'SimpleEventPlugin: Unhandled event type, `%s`.', topLevelType) : invariant(EventConstructor);
-    var event = EventConstructor.getPooled(dispatchConfig, topLevelTargetID, nativeEvent);
+    !EventConstructor ? process.env.NODE_ENV !== 'production' ? invariant(false, 'SimpleEventPlugin: Unhandled event type, `%s`.', topLevelType) : invariant(false) : undefined;
+    var event = EventConstructor.getPooled(dispatchConfig, topLevelTargetID, nativeEvent, nativeEventTarget);
     EventPropagators.accumulateTwoPhaseDispatches(event);
     return event;
   },