text: /**
   * 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 ReactReconciler
   */
  
  'use strict';
  
  var ReactRef = require('./ReactRef');
  
  /**
   * Helper to call ReactRef.attachRefs with this composite component, split out
   * to avoid allocations in the transaction mount-ready queue.
   */
  function attachRefs() {
    ReactRef.attachRefs(this, this._currentElement);
  }
  
  var ReactReconciler = {
  
    /**
     * Initializes the component, renders markup, and registers event listeners.
     *
     * @param {ReactComponent} internalInstance
     * @param {string} rootID DOM ID of the root node.
     * @param {ReactReconcileTransaction|ReactServerRenderingTransaction} transaction
     * @return {?string} Rendered markup to be inserted into the DOM.
     * @final
     * @internal
     */
    mountComponent: function (internalInstance, rootID, transaction, context) {
      var markup = internalInstance.mountComponent(rootID, transaction, context);
      if (internalInstance._currentElement.ref != null) {
        transaction.getReactMountReady().enqueue(attachRefs, internalInstance);
      }
      return markup;
    },
  
    /**
     * Releases any resources allocated by `mountComponent`.
     *
     * @final
     * @internal
     */
    unmountComponent: function (internalInstance) {
      ReactRef.detachRefs(internalInstance, internalInstance._currentElement);
      internalInstance.unmountComponent();
    },
  
    /**
     * Update a component using a new element.
     *
     * @param {ReactComponent} internalInstance
     * @param {ReactElement} nextElement
     * @param {ReactReconcileTransaction} transaction
     * @param {object} context
     * @internal
     */
    receiveComponent: function (internalInstance, nextElement, transaction, context) {
      var prevElement = internalInstance._currentElement;
      if (nextElement === prevElement && nextElement._owner != null
      // TODO: Shouldn't we need to do this: `&& context === internalInstance._context`
      ) {
          // Since elements are immutable after the owner is rendered,
          // we can do a cheap identity compare here to determine if this is a
          // superfluous reconcile. It's possible for state to be mutable but such
          // change should trigger an update of the owner which would recreate
          // the element. We explicitly check for the existence of an owner since
          // it's possible for an element created outside a composite to be
          // deeply mutated and reused.
  
          // TODO: Bailing out early is just a perf optimization right?
          // TODO: Removing the return statement should affect correctness?
          return;
        }
  
      var refsChanged = ReactRef.shouldUpdateRefs(prevElement, nextElement);
  
      if (refsChanged) {
        ReactRef.detachRefs(internalInstance, prevElement);
      }
  
      internalInstance.receiveComponent(nextElement, transaction, context);
  
      if (refsChanged) {
        transaction.getReactMountReady().enqueue(attachRefs, internalInstance);
      }
    },
  
    /**
     * Flush any dirty changes in a component.
     *
     * @param {ReactComponent} internalInstance
     * @param {ReactReconcileTransaction} transaction
     * @internal
     */
    performUpdateIfNecessary: function (internalInstance, transaction) {
      internalInstance.performUpdateIfNecessary(transaction);
    }
  
  };
  
  module.exports = ReactReconciler;