react 0.13.3 → 0.14.0-alpha1

package/lib/ReactReconcileTransaction.js

@@ -16,7 +16,6 @@ var CallbackQueue = require("./CallbackQueue");
 var PooledClass = require("./PooledClass");
 var ReactBrowserEventEmitter = require("./ReactBrowserEventEmitter");
 var ReactInputSelection = require("./ReactInputSelection");
-var ReactPutListenerQueue = require("./ReactPutListenerQueue");
 var Transaction = require("./Transaction");
 
 var assign = require("./Object.assign");
@@ -46,7 +45,7 @@ var EVENT_SUPPRESSION = {
    * @return {boolean} The enabled status of `ReactBrowserEventEmitter` before
    * the reconciliation.
    */
-  initialize: function() {
+  initialize: function () {
     var currentlyEnabled = ReactBrowserEventEmitter.isEnabled();
     ReactBrowserEventEmitter.setEnabled(false);
     return currentlyEnabled;
@@ -57,7 +56,7 @@ var EVENT_SUPPRESSION = {
    *   `ReactBrowserEventEmitter` before the reconciliation occured. `close`
    *   restores the previous value.
    */
-  close: function(previouslyEnabled) {
+  close: function (previouslyEnabled) {
     ReactBrowserEventEmitter.setEnabled(previouslyEnabled);
   }
 };
@@ -70,39 +69,24 @@ var ON_DOM_READY_QUEUEING = {
   /**
    * Initializes the internal `onDOMReady` queue.
    */
-  initialize: function() {
+  initialize: function () {
     this.reactMountReady.reset();
   },
 
   /**
    * After DOM is flushed, invoke all registered `onDOMReady` callbacks.
    */
-  close: function() {
+  close: function () {
     this.reactMountReady.notifyAll();
   }
 };
 
-var PUT_LISTENER_QUEUEING = {
-  initialize: function() {
-    this.putListenerQueue.reset();
-  },
-
-  close: function() {
-    this.putListenerQueue.putListeners();
-  }
-};
-
 /**
  * Executed within the scope of the `Transaction` instance. Consider these as
  * being member methods, but with an implied ordering while being isolated from
  * each other.
  */
-var TRANSACTION_WRAPPERS = [
-  PUT_LISTENER_QUEUEING,
-  SELECTION_RESTORATION,
-  EVENT_SUPPRESSION,
-  ON_DOM_READY_QUEUEING
-];
+var TRANSACTION_WRAPPERS = [SELECTION_RESTORATION, EVENT_SUPPRESSION, ON_DOM_READY_QUEUEING];
 
 /**
  * Currently:
@@ -127,7 +111,6 @@ function ReactReconcileTransaction() {
   // `ReactTextComponent` checks it in `mountComponent`.`
   this.renderToStaticMarkup = false;
   this.reactMountReady = CallbackQueue.getPooled(null);
-  this.putListenerQueue = ReactPutListenerQueue.getPooled();
 }
 
 var Mixin = {
@@ -138,37 +121,29 @@ var Mixin = {
    * @return {array<object>} List of operation wrap proceedures.
    *   TODO: convert to array<TransactionWrapper>
    */
-  getTransactionWrappers: function() {
+  getTransactionWrappers: function () {
     return TRANSACTION_WRAPPERS;
   },
 
   /**
    * @return {object} The queue to collect `onDOMReady` callbacks with.
    */
-  getReactMountReady: function() {
+  getReactMountReady: function () {
     return this.reactMountReady;
   },
 
-  getPutListenerQueue: function() {
-    return this.putListenerQueue;
-  },
-
   /**
    * `PooledClass` looks for this, and will invoke this before allowing this
    * instance to be resused.
    */
-  destructor: function() {
+  destructor: function () {
     CallbackQueue.release(this.reactMountReady);
     this.reactMountReady = null;
-
-    ReactPutListenerQueue.release(this.putListenerQueue);
-    this.putListenerQueue = null;
   }
 };
 
-
 assign(ReactReconcileTransaction.prototype, Transaction.Mixin, Mixin);
 
 PooledClass.addPoolingTo(ReactReconcileTransaction);
 
-module.exports = ReactReconcileTransaction;
+module.exports = ReactReconcileTransaction;

package/lib/ReactReconciler.js

@@ -34,12 +34,10 @@ var ReactReconciler = {
    * @final
    * @internal
    */
-  mountComponent: function(internalInstance, rootID, transaction, context) {
+  mountComponent: function (internalInstance, rootID, transaction, context) {
     var markup = internalInstance.mountComponent(rootID, transaction, context);
-    if ("production" !== process.env.NODE_ENV) {
-      ReactElementValidator.checkAndWarnForMutatedProps(
-        internalInstance._currentElement
-      );
+    if ('production' !== process.env.NODE_ENV) {
+      ReactElementValidator.checkAndWarnForMutatedProps(internalInstance._currentElement);
     }
     transaction.getReactMountReady().enqueue(attachRefs, internalInstance);
     return markup;
@@ -51,7 +49,7 @@ var ReactReconciler = {
    * @final
    * @internal
    */
-  unmountComponent: function(internalInstance) {
+  unmountComponent: function (internalInstance) {
     ReactRef.detachRefs(internalInstance, internalInstance._currentElement);
     internalInstance.unmountComponent();
   },
@@ -65,9 +63,7 @@ var ReactReconciler = {
    * @param {object} context
    * @internal
    */
-  receiveComponent: function(
-    internalInstance, nextElement, transaction, context
-  ) {
+  receiveComponent: function (internalInstance, nextElement, transaction, context) {
     var prevElement = internalInstance._currentElement;
 
     if (nextElement === prevElement && nextElement._owner != null) {
@@ -81,14 +77,11 @@ var ReactReconciler = {
       return;
     }
 
-    if ("production" !== process.env.NODE_ENV) {
+    if ('production' !== process.env.NODE_ENV) {
       ReactElementValidator.checkAndWarnForMutatedProps(nextElement);
     }
 
-    var refsChanged = ReactRef.shouldUpdateRefs(
-      prevElement,
-      nextElement
-    );
+    var refsChanged = ReactRef.shouldUpdateRefs(prevElement, nextElement);
 
     if (refsChanged) {
       ReactRef.detachRefs(internalInstance, prevElement);
@@ -108,13 +101,10 @@ var ReactReconciler = {
    * @param {ReactReconcileTransaction} transaction
    * @internal
    */
-  performUpdateIfNecessary: function(
-    internalInstance,
-    transaction
-  ) {
+  performUpdateIfNecessary: function (internalInstance, transaction) {
     internalInstance.performUpdateIfNecessary(transaction);
   }
 
 };
 
-module.exports = ReactReconciler;
+module.exports = ReactReconciler;

package/lib/ReactRef.js

@@ -33,14 +33,14 @@ function detachRef(ref, component, owner) {
   }
 }
 
-ReactRef.attachRefs = function(instance, element) {
+ReactRef.attachRefs = function (instance, element) {
   var ref = element.ref;
   if (ref != null) {
     attachRef(ref, instance, element._owner);
   }
 };
 
-ReactRef.shouldUpdateRefs = function(prevElement, nextElement) {
+ReactRef.shouldUpdateRefs = function (prevElement, nextElement) {
   // If either the owner or a `ref` has changed, make sure the newest owner
   // has stored a reference to `this`, and the previous owner (if different)
   // has forgotten the reference to `this`. We use the element instead
@@ -53,17 +53,14 @@ ReactRef.shouldUpdateRefs = function(prevElement, nextElement) {
   // is made. It probably belongs where the key checking and
   // instantiateReactComponent is done.
 
-  return (
-    nextElement._owner !== prevElement._owner ||
-    nextElement.ref !== prevElement.ref
-  );
+  return nextElement._owner !== prevElement._owner || nextElement.ref !== prevElement.ref;
 };
 
-ReactRef.detachRefs = function(instance, element) {
+ReactRef.detachRefs = function (instance, element) {
   var ref = element.ref;
   if (ref != null) {
     detachRef(ref, instance, element._owner);
   }
 };
 
-module.exports = ReactRef;
+module.exports = ReactRef;

package/lib/ReactRootIndex.js

@@ -16,7 +16,7 @@ var ReactRootIndexInjection = {
   /**
    * @param {function} _createReactRootIndex
    */
-  injectCreateReactRootIndex: function(_createReactRootIndex) {
+  injectCreateReactRootIndex: function (_createReactRootIndex) {
     ReactRootIndex.createReactRootIndex = _createReactRootIndex;
   }
 };
@@ -26,4 +26,4 @@ var ReactRootIndex = {
   injection: ReactRootIndexInjection
 };
 
-module.exports = ReactRootIndex;
+module.exports = ReactRootIndex;

package/lib/ReactServerRendering.js

@@ -14,8 +14,7 @@
 var ReactElement = require("./ReactElement");
 var ReactInstanceHandles = require("./ReactInstanceHandles");
 var ReactMarkupChecksum = require("./ReactMarkupChecksum");
-var ReactServerRenderingTransaction =
-  require("./ReactServerRenderingTransaction");
+var ReactServerRenderingTransaction = require("./ReactServerRenderingTransaction");
 
 var emptyObject = require("./emptyObject");
 var instantiateReactComponent = require("./instantiateReactComponent");
@@ -26,20 +25,16 @@ var invariant = require("./invariant");
  * @return {string} the HTML markup
  */
 function renderToString(element) {
-  ("production" !== process.env.NODE_ENV ? invariant(
-    ReactElement.isValidElement(element),
-    'renderToString(): You must pass a valid ReactElement.'
-  ) : invariant(ReactElement.isValidElement(element)));
+  'production' !== process.env.NODE_ENV ? invariant(ReactElement.isValidElement(element), 'renderToString(): You must pass a valid ReactElement.') : invariant(ReactElement.isValidElement(element));
 
   var transaction;
   try {
     var id = ReactInstanceHandles.createReactRootID();
     transaction = ReactServerRenderingTransaction.getPooled(false);
 
-    return transaction.perform(function() {
+    return transaction.perform(function () {
       var componentInstance = instantiateReactComponent(element, null);
-      var markup =
-        componentInstance.mountComponent(id, transaction, emptyObject);
+      var markup = componentInstance.mountComponent(id, transaction, emptyObject);
       return ReactMarkupChecksum.addChecksumToMarkup(markup);
     }, null);
   } finally {
@@ -53,17 +48,14 @@ function renderToString(element) {
  * (for generating static pages)
  */
 function renderToStaticMarkup(element) {
-  ("production" !== process.env.NODE_ENV ? invariant(
-    ReactElement.isValidElement(element),
-    'renderToStaticMarkup(): You must pass a valid ReactElement.'
-  ) : invariant(ReactElement.isValidElement(element)));
+  'production' !== process.env.NODE_ENV ? invariant(ReactElement.isValidElement(element), 'renderToStaticMarkup(): You must pass a valid ReactElement.') : invariant(ReactElement.isValidElement(element));
 
   var transaction;
   try {
     var id = ReactInstanceHandles.createReactRootID();
     transaction = ReactServerRenderingTransaction.getPooled(true);
 
-    return transaction.perform(function() {
+    return transaction.perform(function () {
       var componentInstance = instantiateReactComponent(element, null);
       return componentInstance.mountComponent(id, transaction, emptyObject);
     }, null);
@@ -75,4 +67,4 @@ function renderToStaticMarkup(element) {
 module.exports = {
   renderToString: renderToString,
   renderToStaticMarkup: renderToStaticMarkup
-};
+};

package/lib/ReactServerRenderingTransaction.js

@@ -14,7 +14,6 @@
 
 var PooledClass = require("./PooledClass");
 var CallbackQueue = require("./CallbackQueue");
-var ReactPutListenerQueue = require("./ReactPutListenerQueue");
 var Transaction = require("./Transaction");
 
 var assign = require("./Object.assign");
@@ -28,30 +27,19 @@ var ON_DOM_READY_QUEUEING = {
   /**
    * Initializes the internal `onDOMReady` queue.
    */
-  initialize: function() {
+  initialize: function () {
     this.reactMountReady.reset();
   },
 
   close: emptyFunction
 };
 
-var PUT_LISTENER_QUEUEING = {
-  initialize: function() {
-    this.putListenerQueue.reset();
-  },
-
-  close: emptyFunction
-};
-
 /**
  * Executed within the scope of the `Transaction` instance. Consider these as
  * being member methods, but with an implied ordering while being isolated from
  * each other.
  */
-var TRANSACTION_WRAPPERS = [
-  PUT_LISTENER_QUEUEING,
-  ON_DOM_READY_QUEUEING
-];
+var TRANSACTION_WRAPPERS = [ON_DOM_READY_QUEUEING];
 
 /**
  * @class ReactServerRenderingTransaction
@@ -61,7 +49,6 @@ function ReactServerRenderingTransaction(renderToStaticMarkup) {
   this.reinitializeTransaction();
   this.renderToStaticMarkup = renderToStaticMarkup;
   this.reactMountReady = CallbackQueue.getPooled(null);
-  this.putListenerQueue = ReactPutListenerQueue.getPooled();
 }
 
 var Mixin = {
@@ -71,41 +58,29 @@ var Mixin = {
    * @final
    * @return {array} Empty list of operation wrap proceedures.
    */
-  getTransactionWrappers: function() {
+  getTransactionWrappers: function () {
     return TRANSACTION_WRAPPERS;
   },
 
   /**
    * @return {object} The queue to collect `onDOMReady` callbacks with.
    */
-  getReactMountReady: function() {
+  getReactMountReady: function () {
     return this.reactMountReady;
   },
 
-  getPutListenerQueue: function() {
-    return this.putListenerQueue;
-  },
-
   /**
    * `PooledClass` looks for this, and will invoke this before allowing this
    * instance to be resused.
    */
-  destructor: function() {
+  destructor: function () {
     CallbackQueue.release(this.reactMountReady);
     this.reactMountReady = null;
-
-    ReactPutListenerQueue.release(this.putListenerQueue);
-    this.putListenerQueue = null;
   }
 };
 
-
-assign(
-  ReactServerRenderingTransaction.prototype,
-  Transaction.Mixin,
-  Mixin
-);
+assign(ReactServerRenderingTransaction.prototype, Transaction.Mixin, Mixin);
 
 PooledClass.addPoolingTo(ReactServerRenderingTransaction);
 
-module.exports = ReactServerRenderingTransaction;
+module.exports = ReactServerRenderingTransaction;

package/lib/ReactStateSetters.js

@@ -22,8 +22,8 @@ var ReactStateSetters = {
    * @return {function} callback that when invoked uses funcReturningState to
    *                    determined the object literal to setState.
    */
-  createStateSetter: function(component, funcReturningState) {
-    return function(a, b, c, d, e, f) {
+  createStateSetter: function (component, funcReturningState) {
+    return function (a, b, c, d, e, f) {
       var partialState = funcReturningState.call(component, a, b, c, d, e, f);
       if (partialState) {
         component.setState(partialState);
@@ -42,7 +42,7 @@ var ReactStateSetters = {
    * @return {function} callback of 1 argument which calls setState() with
    *                    the provided keyName and callback argument.
    */
-  createStateKeySetter: function(component, key) {
+  createStateKeySetter: function (component, key) {
     // Memoize the setters.
     var cache = component.__keySetters || (component.__keySetters = {});
     return cache[key] || (cache[key] = createStateKeySetter(component, key));
@@ -77,7 +77,7 @@ ReactStateSetters.Mixin = {
    * @return {function} callback that when invoked uses funcReturningState to
    *                    determined the object literal to setState.
    */
-  createStateSetter: function(funcReturningState) {
+  createStateSetter: function (funcReturningState) {
     return ReactStateSetters.createStateSetter(this, funcReturningState);
   },
 
@@ -96,9 +96,9 @@ ReactStateSetters.Mixin = {
    * @return {function} callback of 1 argument which calls setState() with
    *                    the provided keyName and callback argument.
    */
-  createStateKeySetter: function(key) {
+  createStateKeySetter: function (key) {
     return ReactStateSetters.createStateKeySetter(this, key);
   }
 };
 
-module.exports = ReactStateSetters;
+module.exports = ReactStateSetters;

package/lib/ReactTestUtils.js

@@ -27,6 +27,7 @@ var SyntheticEvent = require("./SyntheticEvent");
 
 var assign = require("./Object.assign");
 var emptyObject = require("./emptyObject");
+var findDOMNode = require("./findDOMNode");
 
 var topLevelTypes = EventConstants.topLevelTypes;
 
@@ -42,7 +43,7 @@ function Event(suffix) {}
  * @lends ReactTestUtils
  */
 var ReactTestUtils = {
-  renderIntoDocument: function(instance) {
+  renderIntoDocument: function (instance) {
     var div = document.createElement('div');
     // None of our tests actually require attaching the container to the
     // DOM, and doing so creates a mess that we rely on test isolation to
@@ -52,58 +53,47 @@ var ReactTestUtils = {
     return React.render(instance, div);
   },
 
-  isElement: function(element) {
+  isElement: function (element) {
     return ReactElement.isValidElement(element);
   },
 
-  isElementOfType: function(inst, convenienceConstructor) {
-    return (
-      ReactElement.isValidElement(inst) &&
-      inst.type === convenienceConstructor
-    );
+  isElementOfType: function (inst, convenienceConstructor) {
+    return ReactElement.isValidElement(inst) && inst.type === convenienceConstructor;
   },
 
-  isDOMComponent: function(inst) {
+  isDOMComponent: function (inst) {
     // TODO: Fix this heuristic. It's just here because composites can currently
     // pretend to be DOM components.
     return !!(inst && inst.tagName && inst.getDOMNode);
   },
 
-  isDOMComponentElement: function(inst) {
-    return !!(inst &&
-              ReactElement.isValidElement(inst) &&
-              !!inst.tagName);
+  isDOMComponentElement: function (inst) {
+    return !!(inst && ReactElement.isValidElement(inst) && !!inst.tagName);
   },
 
-  isCompositeComponent: function(inst) {
-    return typeof inst.render === 'function' &&
-           typeof inst.setState === 'function';
+  isCompositeComponent: function (inst) {
+    return typeof inst.render === 'function' && typeof inst.setState === 'function';
   },
 
-  isCompositeComponentWithType: function(inst, type) {
-    return !!(ReactTestUtils.isCompositeComponent(inst) &&
-             (inst.constructor === type));
+  isCompositeComponentWithType: function (inst, type) {
+    return !!(ReactTestUtils.isCompositeComponent(inst) && inst.constructor === type);
   },
 
-  isCompositeComponentElement: function(inst) {
+  isCompositeComponentElement: function (inst) {
     if (!ReactElement.isValidElement(inst)) {
       return false;
     }
     // We check the prototype of the type that will get mounted, not the
     // instance itself. This is a future proof way of duck typing.
     var prototype = inst.type.prototype;
-    return (
-      typeof prototype.render === 'function' &&
-      typeof prototype.setState === 'function'
-    );
+    return typeof prototype.render === 'function' && typeof prototype.setState === 'function';
   },
 
-  isCompositeComponentElementWithType: function(inst, type) {
-    return !!(ReactTestUtils.isCompositeComponentElement(inst) &&
-             (inst.constructor === type));
+  isCompositeComponentElementWithType: function (inst, type) {
+    return !!(ReactTestUtils.isCompositeComponentElement(inst) && inst.constructor === type);
   },
 
-  getRenderedChildOfCompositeComponent: function(inst) {
+  getRenderedChildOfCompositeComponent: function (inst) {
     if (!ReactTestUtils.isCompositeComponent(inst)) {
       return null;
     }
@@ -111,16 +101,14 @@ var ReactTestUtils = {
     return internalInstance._renderedComponent.getPublicInstance();
   },
 
-  findAllInRenderedTree: function(inst, test) {
+  findAllInRenderedTree: function (inst, test) {
     if (!inst) {
       return [];
     }
     var ret = test(inst) ? [inst] : [];
     if (ReactTestUtils.isDOMComponent(inst)) {
       var internalInstance = ReactInstanceMap.get(inst);
-      var renderedChildren = internalInstance
-        ._renderedComponent
-        ._renderedChildren;
+      var renderedChildren = internalInstance._renderedComponent._renderedChildren;
       var key;
       for (key in renderedChildren) {
         if (!renderedChildren.hasOwnProperty(key)) {
@@ -129,20 +117,10 @@ var ReactTestUtils = {
         if (!renderedChildren[key].getPublicInstance) {
           continue;
         }
-        ret = ret.concat(
-          ReactTestUtils.findAllInRenderedTree(
-            renderedChildren[key].getPublicInstance(),
-            test
-          )
-        );
+        ret = ret.concat(ReactTestUtils.findAllInRenderedTree(renderedChildren[key].getPublicInstance(), test));
       }
     } else if (ReactTestUtils.isCompositeComponent(inst)) {
-      ret = ret.concat(
-        ReactTestUtils.findAllInRenderedTree(
-          ReactTestUtils.getRenderedChildOfCompositeComponent(inst),
-          test
-        )
-      );
+      ret = ret.concat(ReactTestUtils.findAllInRenderedTree(ReactTestUtils.getRenderedChildOfCompositeComponent(inst), test));
     }
     return ret;
   },
@@ -152,12 +130,10 @@ var ReactTestUtils = {
    * components with the class name matching `className`.
    * @return an array of all the matches.
    */
-  scryRenderedDOMComponentsWithClass: function(root, className) {
-    return ReactTestUtils.findAllInRenderedTree(root, function(inst) {
+  scryRenderedDOMComponentsWithClass: function (root, className) {
+    return ReactTestUtils.findAllInRenderedTree(root, function (inst) {
       var instClassName = inst.props.className;
-      return ReactTestUtils.isDOMComponent(inst) && (
-        (instClassName && (' ' + instClassName + ' ').indexOf(' ' + className + ' ') !== -1)
-      );
+      return ReactTestUtils.isDOMComponent(inst) && (instClassName && (' ' + instClassName + ' ').indexOf(' ' + className + ' ') !== -1);
     });
   },
 
@@ -167,27 +143,22 @@ var ReactTestUtils = {
    * number of matches besides one.
    * @return {!ReactDOMComponent} The one match.
    */
-  findRenderedDOMComponentWithClass: function(root, className) {
-    var all =
-      ReactTestUtils.scryRenderedDOMComponentsWithClass(root, className);
+  findRenderedDOMComponentWithClass: function (root, className) {
+    var all = ReactTestUtils.scryRenderedDOMComponentsWithClass(root, className);
     if (all.length !== 1) {
-      throw new Error('Did not find exactly one match ' +
-        '(found: ' + all.length + ') for class:' + className
-      );
+      throw new Error('Did not find exactly one match ' + '(found: ' + all.length + ') for class:' + className);
     }
     return all[0];
   },
 
-
   /**
    * Finds all instance of components in the rendered tree that are DOM
    * components with the tag name matching `tagName`.
    * @return an array of all the matches.
    */
-  scryRenderedDOMComponentsWithTag: function(root, tagName) {
-    return ReactTestUtils.findAllInRenderedTree(root, function(inst) {
-      return ReactTestUtils.isDOMComponent(inst) &&
-            inst.tagName === tagName.toUpperCase();
+  scryRenderedDOMComponentsWithTag: function (root, tagName) {
+    return ReactTestUtils.findAllInRenderedTree(root, function (inst) {
+      return ReactTestUtils.isDOMComponent(inst) && inst.tagName === tagName.toUpperCase();
     });
   },
 
@@ -197,7 +168,7 @@ var ReactTestUtils = {
    * number of matches besides one.
    * @return {!ReactDOMComponent} The one match.
    */
-  findRenderedDOMComponentWithTag: function(root, tagName) {
+  findRenderedDOMComponentWithTag: function (root, tagName) {
     var all = ReactTestUtils.scryRenderedDOMComponentsWithTag(root, tagName);
     if (all.length !== 1) {
       throw new Error('Did not find exactly one match for tag:' + tagName);
@@ -205,17 +176,13 @@ var ReactTestUtils = {
     return all[0];
   },
 
-
   /**
    * Finds all instances of components with type equal to `componentType`.
    * @return an array of all the matches.
    */
-  scryRenderedComponentsWithType: function(root, componentType) {
-    return ReactTestUtils.findAllInRenderedTree(root, function(inst) {
-      return ReactTestUtils.isCompositeComponentWithType(
-        inst,
-        componentType
-      );
+  scryRenderedComponentsWithType: function (root, componentType) {
+    return ReactTestUtils.findAllInRenderedTree(root, function (inst) {
+      return ReactTestUtils.isCompositeComponentWithType(inst, componentType);
     });
   },
 
@@ -225,15 +192,10 @@ var ReactTestUtils = {
    * number of matches besides one.
    * @return {!ReactComponent} The one match.
    */
-  findRenderedComponentWithType: function(root, componentType) {
-    var all = ReactTestUtils.scryRenderedComponentsWithType(
-      root,
-      componentType
-    );
+  findRenderedComponentWithType: function (root, componentType) {
+    var all = ReactTestUtils.scryRenderedComponentsWithType(root, componentType);
     if (all.length !== 1) {
-      throw new Error(
-        'Did not find exactly one match for componentType:' + componentType
-      );
+      throw new Error('Did not find exactly one match for componentType:' + componentType);
     }
     return all[0];
   },
@@ -251,15 +213,11 @@ var ReactTestUtils = {
    *                              module.mockTagName if provided)
    * @return {object} the ReactTestUtils object (for chaining)
    */
-  mockComponent: function(module, mockTagName) {
-    mockTagName = mockTagName || module.mockTagName || "div";
-
-    module.prototype.render.mockImplementation(function() {
-      return React.createElement(
-        mockTagName,
-        null,
-        this.props.children
-      );
+  mockComponent: function (module, mockTagName) {
+    mockTagName = mockTagName || module.mockTagName || 'div';
+
+    module.prototype.render.mockImplementation(function () {
+      return React.createElement(mockTagName, null, this.props.children);
     });
 
     return this;
@@ -272,12 +230,9 @@ var ReactTestUtils = {
    * @param {!Element} node The dom to simulate an event occurring on.
    * @param {?Event} fakeNativeEvent Fake native event to use in SyntheticEvent.
    */
-  simulateNativeEventOnNode: function(topLevelType, node, fakeNativeEvent) {
+  simulateNativeEventOnNode: function (topLevelType, node, fakeNativeEvent) {
     fakeNativeEvent.target = node;
-    ReactBrowserEventEmitter.ReactEventListener.dispatchEvent(
-      topLevelType,
-      fakeNativeEvent
-    );
+    ReactBrowserEventEmitter.ReactEventListener.dispatchEvent(topLevelType, fakeNativeEvent);
   },
 
   /**
@@ -287,26 +242,17 @@ var ReactTestUtils = {
    * @param comp {!ReactDOMComponent}
    * @param {?Event} fakeNativeEvent Fake native event to use in SyntheticEvent.
    */
-  simulateNativeEventOnDOMComponent: function(
-      topLevelType,
-      comp,
-      fakeNativeEvent) {
-    ReactTestUtils.simulateNativeEventOnNode(
-      topLevelType,
-      comp.getDOMNode(),
-      fakeNativeEvent
-    );
+  simulateNativeEventOnDOMComponent: function (topLevelType, comp, fakeNativeEvent) {
+    ReactTestUtils.simulateNativeEventOnNode(topLevelType, findDOMNode(comp), fakeNativeEvent);
   },
 
-  nativeTouchData: function(x, y) {
+  nativeTouchData: function (x, y) {
     return {
-      touches: [
-        {pageX: x, pageY: y}
-      ]
+      touches: [{ pageX: x, pageY: y }]
     };
   },
 
-  createRenderer: function() {
+  createRenderer: function () {
     return new ReactShallowRenderer();
   },
 
@@ -317,57 +263,42 @@ var ReactTestUtils = {
 /**
  * @class ReactShallowRenderer
  */
-var ReactShallowRenderer = function() {
+var ReactShallowRenderer = function () {
   this._instance = null;
 };
 
-ReactShallowRenderer.prototype.getRenderOutput = function() {
-  return (
-    (this._instance && this._instance._renderedComponent &&
-     this._instance._renderedComponent._renderedOutput)
-    || null
-  );
+ReactShallowRenderer.prototype.getRenderOutput = function () {
+  return this._instance && this._instance._renderedComponent && this._instance._renderedComponent._renderedOutput || null;
 };
 
-var NoopInternalComponent = function(element) {
+var NoopInternalComponent = function (element) {
   this._renderedOutput = element;
-  this._currentElement = element === null || element === false ?
-    ReactEmptyComponent.emptyElement :
-    element;
+  this._currentElement = element === null || element === false ? ReactEmptyComponent.emptyElement : element;
 };
 
 NoopInternalComponent.prototype = {
 
-  mountComponent: function() {
-  },
+  mountComponent: function () {},
 
-  receiveComponent: function(element) {
+  receiveComponent: function (element) {
     this._renderedOutput = element;
-    this._currentElement = element === null || element === false ?
-      ReactEmptyComponent.emptyElement :
-      element;
+    this._currentElement = element === null || element === false ? ReactEmptyComponent.emptyElement : element;
   },
 
-  unmountComponent: function() {
-  }
+  unmountComponent: function () {}
 
 };
 
-var ShallowComponentWrapper = function() { };
-assign(
-  ShallowComponentWrapper.prototype,
-  ReactCompositeComponent.Mixin, {
-    _instantiateReactComponent: function(element) {
-      return new NoopInternalComponent(element);
-    },
-    _replaceNodeWithMarkupByID: function() {},
-    _renderValidatedComponent:
-      ReactCompositeComponent.Mixin.
-        _renderValidatedComponentWithoutOwnerOrContext
-  }
-);
+var ShallowComponentWrapper = function () {};
+assign(ShallowComponentWrapper.prototype, ReactCompositeComponent.Mixin, {
+  _instantiateReactComponent: function (element) {
+    return new NoopInternalComponent(element);
+  },
+  _replaceNodeWithMarkupByID: function () {},
+  _renderValidatedComponent: ReactCompositeComponent.Mixin._renderValidatedComponentWithoutOwnerOrContext
+});
 
-ReactShallowRenderer.prototype.render = function(element, context) {
+ReactShallowRenderer.prototype.render = function (element, context) {
   if (!context) {
     context = emptyObject;
   }
@@ -376,13 +307,13 @@ ReactShallowRenderer.prototype.render = function(element, context) {
   ReactUpdates.ReactReconcileTransaction.release(transaction);
 };
 
-ReactShallowRenderer.prototype.unmount = function() {
+ReactShallowRenderer.prototype.unmount = function () {
   if (this._instance) {
     this._instance.unmountComponent();
   }
 };
 
-ReactShallowRenderer.prototype._render = function(element, transaction, context) {
+ReactShallowRenderer.prototype._render = function (element, transaction, context) {
   if (!this._instance) {
     var rootID = ReactInstanceHandles.createReactRootID();
     var instance = new ShallowComponentWrapper(element.type);
@@ -405,27 +336,30 @@ ReactShallowRenderer.prototype._render = function(element, transaction, context)
  * - ... (All keys from event plugin `eventTypes` objects)
  */
 function makeSimulator(eventType) {
-  return function(domComponentOrNode, eventData) {
+  return function (domComponentOrNode, eventData) {
     var node;
     if (ReactTestUtils.isDOMComponent(domComponentOrNode)) {
-      node = domComponentOrNode.getDOMNode();
+      node = findDOMNode(domComponentOrNode);
     } else if (domComponentOrNode.tagName) {
       node = domComponentOrNode;
     }
 
+    var dispatchConfig = ReactBrowserEventEmitter.eventNameDispatchConfigs[eventType];
+
     var fakeNativeEvent = new Event();
     fakeNativeEvent.target = node;
     // We don't use SyntheticEvent.getPooled in order to not have to worry about
     // properly destroying any properties assigned from `eventData` upon release
-    var event = new SyntheticEvent(
-      ReactBrowserEventEmitter.eventNameDispatchConfigs[eventType],
-      ReactMount.getID(node),
-      fakeNativeEvent
-    );
+    var event = new SyntheticEvent(dispatchConfig, ReactMount.getID(node), fakeNativeEvent);
     assign(event, eventData);
-    EventPropagators.accumulateTwoPhaseDispatches(event);
 
-    ReactUpdates.batchedUpdates(function() {
+    if (dispatchConfig.phasedRegistrationNames) {
+      EventPropagators.accumulateTwoPhaseDispatches(event);
+    } else {
+      EventPropagators.accumulateDirectDispatches(event);
+    }
+
+    ReactUpdates.batchedUpdates(function () {
       EventPluginHub.enqueueEvents(event);
       EventPluginHub.processEventQueue();
     });
@@ -447,12 +381,12 @@ function buildSimulators() {
 
 // Rebuild ReactTestUtils.Simulate whenever event plugins are injected
 var oldInjectEventPluginOrder = EventPluginHub.injection.injectEventPluginOrder;
-EventPluginHub.injection.injectEventPluginOrder = function() {
+EventPluginHub.injection.injectEventPluginOrder = function () {
   oldInjectEventPluginOrder.apply(this, arguments);
   buildSimulators();
 };
 var oldInjectEventPlugins = EventPluginHub.injection.injectEventPluginsByName;
-EventPluginHub.injection.injectEventPluginsByName = function() {
+EventPluginHub.injection.injectEventPluginsByName = function () {
   oldInjectEventPlugins.apply(this, arguments);
   buildSimulators();
 };
@@ -476,22 +410,14 @@ buildSimulators();
  */
 
 function makeNativeSimulator(eventType) {
-  return function(domComponentOrNode, nativeEventData) {
+  return function (domComponentOrNode, nativeEventData) {
     var fakeNativeEvent = new Event(eventType);
     assign(fakeNativeEvent, nativeEventData);
     if (ReactTestUtils.isDOMComponent(domComponentOrNode)) {
-      ReactTestUtils.simulateNativeEventOnDOMComponent(
-        eventType,
-        domComponentOrNode,
-        fakeNativeEvent
-      );
+      ReactTestUtils.simulateNativeEventOnDOMComponent(eventType, domComponentOrNode, fakeNativeEvent);
     } else if (!!domComponentOrNode.tagName) {
       // Will allow on actual dom nodes.
-      ReactTestUtils.simulateNativeEventOnNode(
-        eventType,
-        domComponentOrNode,
-        fakeNativeEvent
-      );
+      ReactTestUtils.simulateNativeEventOnNode(eventType, domComponentOrNode, fakeNativeEvent);
     }
   };
 }
@@ -499,14 +425,12 @@ function makeNativeSimulator(eventType) {
 var eventType;
 for (eventType in topLevelTypes) {
   // Event type is stored as 'topClick' - we transform that to 'click'
-  var convenienceName = eventType.indexOf('top') === 0 ?
-    eventType.charAt(3).toLowerCase() + eventType.substr(4) : eventType;
+  var convenienceName = eventType.indexOf('top') === 0 ? eventType.charAt(3).toLowerCase() + eventType.substr(4) : eventType;
   /**
    * @param {!Element || ReactDOMComponent} domComponentOrNode
    * @param {?Event} nativeEventData Fake native event to use in SyntheticEvent.
    */
-  ReactTestUtils.SimulateNative[convenienceName] =
-    makeNativeSimulator(eventType);
+  ReactTestUtils.SimulateNative[convenienceName] = makeNativeSimulator(eventType);
 }
 
-module.exports = ReactTestUtils;
+module.exports = ReactTestUtils;