text: /**
   * Copyright 2013-2014, 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 instantiateReactComponent
   * @typechecks static-only
   */
  
  "use strict";
  
  var warning = require("./warning");
  
  var ReactElement = require("./ReactElement");
  var ReactLegacyElement = require("./ReactLegacyElement");
  var ReactNativeComponent = require("./ReactNativeComponent");
  var ReactEmptyComponent = require("./ReactEmptyComponent");
  
  /**
   * Given an `element` create an instance that will actually be mounted.
   *
   * @param {object} element
   * @param {*} parentCompositeType The composite type that resolved this.
   * @return {object} A new instance of the element's constructor.
   * @protected
   */
  function instantiateReactComponent(element, parentCompositeType) {
    var instance;
  
    if ("production" !== process.env.NODE_ENV) {
      ("production" !== process.env.NODE_ENV ? warning(
        element && (typeof element.type === 'function' ||
                       typeof element.type === 'string'),
        'Only functions or strings can be mounted as React components.'
      ) : null);
  
      // Resolve mock instances
      if (element.type._mockedReactClassConstructor) {
        // If this is a mocked class, we treat the legacy factory as if it was the
        // class constructor for future proofing unit tests. Because this might
        // be mocked as a legacy factory, we ignore any warnings triggerd by
        // this temporary hack.
        ReactLegacyElement._isLegacyCallWarningEnabled = false;
        try {
          instance = new element.type._mockedReactClassConstructor(
            element.props
          );
        } finally {
          ReactLegacyElement._isLegacyCallWarningEnabled = true;
        }
  
        // If the mock implementation was a legacy factory, then it returns a
        // element. We need to turn this into a real component instance.
        if (ReactElement.isValidElement(instance)) {
          instance = new instance.type(instance.props);
        }
  
        var render = instance.render;
        if (!render) {
          // For auto-mocked factories, the prototype isn't shimmed and therefore
          // there is no render function on the instance. We replace the whole
          // component with an empty component instance instead.
          element = ReactEmptyComponent.getEmptyComponent();
        } else {
          if (render._isMockFunction && !render._getMockImplementation()) {
            // Auto-mocked components may have a prototype with a mocked render
            // function. For those, we'll need to mock the result of the render
            // since we consider undefined to be invalid results from render.
            render.mockImplementation(
              ReactEmptyComponent.getEmptyComponent
            );
          }
          instance.construct(element);
          return instance;
        }
      }
    }
  
    // Special case string values
    if (typeof element.type === 'string') {
      instance = ReactNativeComponent.createInstanceForTag(
        element.type,
        element.props,
        parentCompositeType
      );
    } else {
      // Normal case for non-mocks and non-strings
      instance = new element.type(element.props);
    }
  
    if ("production" !== process.env.NODE_ENV) {
      ("production" !== process.env.NODE_ENV ? warning(
        typeof instance.construct === 'function' &&
        typeof instance.mountComponent === 'function' &&
        typeof instance.receiveComponent === 'function',
        'Only React Components can be mounted.'
      ) : null);
    }
  
    // This actually sets up the internal instance. This will become decoupled
    // from the public instance in a future diff.
    instance.construct(element);
  
    return instance;
  }
  
  module.exports = instantiateReactComponent;
  