'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _object = require('object.assign');

var _object2 = _interopRequireDefault(_object);

var _arrayPrototype = require('array.prototype.flat');

var _arrayPrototype2 = _interopRequireDefault(_arrayPrototype);

var _has = require('has');

var _has2 = _interopRequireDefault(_has);

var _Utils = require('./Utils');

var _getAdapter = require('./getAdapter');

var _getAdapter2 = _interopRequireDefault(_getAdapter);

var _Debug = require('./Debug');

var _RSTTraversal = require('./RSTTraversal');

var _selectors = require('./selectors');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var NODE = (0, _Utils.sym)('__node__');
var NODES = (0, _Utils.sym)('__nodes__');
var RENDERER = (0, _Utils.sym)('__renderer__');
var UNRENDERED = (0, _Utils.sym)('__unrendered__');
var ROOT = (0, _Utils.sym)('__root__');
var OPTIONS = (0, _Utils.sym)('__options__');
var ROOT_NODES = (0, _Utils.sym)('__rootNodes__');
var WRAPPING_COMPONENT = (0, _Utils.sym)('__wrappingComponent__');
var LINKED_ROOTS = (0, _Utils.sym)('__linkedRoots__');
var UPDATED_BY = (0, _Utils.sym)('__updatedBy__');

/**
 * Finds all nodes in the current wrapper nodes' render trees that match the provided predicate
 * function.
 *
 * @param {ReactWrapper} wrapper
 * @param {Function} predicate
 * @param {Function} filter
 * @returns {ReactWrapper}
 */
function findWhereUnwrapped(wrapper, predicate) {
  var filter = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : _RSTTraversal.treeFilter;

  return wrapper.flatMap(function (n) {
    return filter(n.getNodeInternal(), predicate);
  });
}

/**
 * Returns a new wrapper instance with only the nodes of the current wrapper instance that match
 * the provided predicate function.
 *
 * @param {ReactWrapper} wrapper
 * @param {Function} predicate
 * @returns {ReactWrapper}
 */
function filterWhereUnwrapped(wrapper, predicate) {
  return wrapper.wrap(wrapper.getNodesInternal().filter(predicate).filter(Boolean));
}

function getRootNodeInternal(wrapper) {
  if (wrapper[ROOT].length !== 1) {
    throw new Error('getRootNodeInternal(wrapper) can only be called when wrapper wraps one node');
  }
  if (wrapper[ROOT] !== wrapper) {
    return wrapper[ROOT_NODES][0];
  }
  return wrapper[ROOT][NODE];
}

function nodeParents(wrapper, node) {
  return (0, _RSTTraversal.parentsOfNode)(node, getRootNodeInternal(wrapper));
}

function privateSetNodes(wrapper, nodes) {
  if (!nodes) {
    (0, _Utils.privateSet)(wrapper, NODE, null);
    (0, _Utils.privateSet)(wrapper, NODES, []);
  } else if (!Array.isArray(nodes)) {
    (0, _Utils.privateSet)(wrapper, NODE, nodes);
    (0, _Utils.privateSet)(wrapper, NODES, [nodes]);
  } else {
    (0, _Utils.privateSet)(wrapper, NODE, nodes[0]);
    (0, _Utils.privateSet)(wrapper, NODES, nodes);
  }
  (0, _Utils.privateSet)(wrapper, 'length', wrapper[NODES].length);
}

/**
 * @class ReactWrapper
 */

var ReactWrapper = function () {
  function ReactWrapper(nodes, root) {
    var passedOptions = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};

    _classCallCheck(this, ReactWrapper);

    if (!global.window && !global.document) {
      throw new Error('It looks like you called `mount()` without a global document being loaded.');
    }
    var options = (0, _Utils.makeOptions)(passedOptions);

    if (!root) {
      var adapter = (0, _getAdapter2['default'])(options);
      if (!adapter.isValidElement(nodes)) {
        throw new TypeError('ReactWrapper can only wrap valid elements');
      }

      var renderer = adapter.createRenderer((0, _object2['default'])({ mode: 'mount' }, options));
      (0, _Utils.privateSet)(this, RENDERER, renderer);
      renderer.render(nodes, options.context);
      (0, _Utils.privateSet)(this, ROOT, this);
      privateSetNodes(this, this[RENDERER].getNode());
      (0, _Utils.privateSet)(this, OPTIONS, options);
      (0, _Utils.privateSet)(this, LINKED_ROOTS, []);

      if ((0, _Utils.isCustomComponent)(options.wrappingComponent, adapter)) {
        if (typeof this[RENDERER].getWrappingComponentRenderer !== 'function') {
          throw new TypeError('your adapter does not support `wrappingComponent`. Try upgrading it!');
        }

        // eslint-disable-next-line no-use-before-define
        (0, _Utils.privateSet)(this, WRAPPING_COMPONENT, new WrappingComponentWrapper(this, this[RENDERER].getWrappingComponentRenderer()));
        this[LINKED_ROOTS].push(this[WRAPPING_COMPONENT]);
      }
    } else {
      (0, _Utils.privateSet)(this, RENDERER, root[RENDERER]);
      (0, _Utils.privateSet)(this, ROOT, root);
      privateSetNodes(this, nodes);
      (0, _Utils.privateSet)(this, ROOT_NODES, root[NODES]);
      (0, _Utils.privateSet)(this, OPTIONS, root[OPTIONS]);
      (0, _Utils.privateSet)(this, LINKED_ROOTS, []);
    }
    (0, _Utils.privateSet)(this, UNRENDERED, nodes);
    (0, _Utils.privateSet)(this, UPDATED_BY, null);
  }

  /**
   * Returns the root wrapper
   *
   * @return {ReactWrapper}
   */


  _createClass(ReactWrapper, [{
    key: 'root',
    value: function () {
      function root() {
        return this[ROOT];
      }

      return root;
    }()

    /**
     * Returns the wrapped component.
     *
     * @return {ReactComponent}
     */

  }, {
    key: 'getNodeInternal',
    value: function () {
      function getNodeInternal() {
        if (this.length !== 1) {
          throw new Error('ReactWrapper::getNode() can only be called when wrapping one node');
        }
        return this[NODES][0];
      }

      return getNodeInternal;
    }()

    /**
     * Returns the the wrapped components.
     *
     * @return {Array<ReactComponent>}
     */

  }, {
    key: 'getNodesInternal',
    value: function () {
      function getNodesInternal() {
        return this[NODES];
      }

      return getNodesInternal;
    }()

    /**
     * Returns the wrapped ReactElement.
     *
     * @return {ReactElement}
     */

  }, {
    key: 'getElement',
    value: function () {
      function getElement() {
        var _this = this;

        return this.single('getElement', function () {
          return (0, _getAdapter2['default'])(_this[OPTIONS]).nodeToElement(_this[NODE]);
        });
      }

      return getElement;
    }()

    /**
     * Returns the wrapped ReactElements.
     *
     * @return {Array<ReactElement>}
     */

  }, {
    key: 'getElements',
    value: function () {
      function getElements() {
        var _this2 = this;

        return this[NODES].map(function (n) {
          return (0, _getAdapter2['default'])(_this2[OPTIONS]).nodeToElement(n);
        });
      }

      return getElements;
    }()

    // eslint-disable-next-line class-methods-use-this

  }, {
    key: 'getNode',
    value: function () {
      function getNode() {
        throw new Error('ReactWrapper::getNode() is no longer supported. Use ReactWrapper::instance() instead');
      }

      return getNode;
    }()

    // eslint-disable-next-line class-methods-use-this

  }, {
    key: 'getNodes',
    value: function () {
      function getNodes() {
        throw new Error('ReactWrapper::getNodes() is no longer supported.');
      }

      return getNodes;
    }()

    /**
     * Returns the outer most DOMComponent of the current wrapper.
     *
     * NOTE: can only be called on a wrapper of a single node.
     *
     * @returns {DOMComponent}
     */

  }, {
    key: 'getDOMNode',
    value: function () {
      function getDOMNode() {
        var adapter = (0, _getAdapter2['default'])(this[OPTIONS]);
        return this.single('getDOMNode', function (n) {
          return adapter.nodeToHostNode(n, true);
        });
      }

      return getDOMNode;
    }()

    /**
     * If the root component contained a ref, you can access it here and get the relevant
     * react component instance or HTML element instance.
     *
     * NOTE: can only be called on a wrapper instance that is also the root instance.
     *
     * @param {String} refname
     * @returns {ReactComponent | HTMLElement}
     */

  }, {
    key: 'ref',
    value: function () {
      function ref(refname) {
        if (this[ROOT] !== this) {
          throw new Error('ReactWrapper::ref(refname) can only be called on the root');
        }
        return this.instance().refs[refname];
      }

      return ref;
    }()

    /**
     * Returns the wrapper's underlying instance.
     *
     * Example:
     * ```
     * const wrapper = mount(<MyComponent />);
     * const inst = wrapper.instance();
     * expect(inst).to.be.instanceOf(MyComponent);
     * ```
     * @returns {ReactComponent|DOMComponent}
     */

  }, {
    key: 'instance',
    value: function () {
      function instance() {
        var _this3 = this;

        return this.single('instance', function () {
          return _this3[NODE].instance;
        });
      }

      return instance;
    }()

    /**
     * If a `wrappingComponent` was passed in `options`, this methods returns a `ReactWrapper` around
     * the rendered `wrappingComponent`. This `ReactWrapper` can be used to update the
     * `wrappingComponent`'s props, state, etc.
     *
     * @returns ReactWrapper
     */

  }, {
    key: 'getWrappingComponent',
    value: function () {
      function getWrappingComponent() {
        if (this[ROOT] !== this) {
          throw new Error('ReactWrapper::getWrappingComponent() can only be called on the root');
        }
        if (!this[OPTIONS].wrappingComponent) {
          throw new Error('ReactWrapper::getWrappingComponent() can only be called on a wrapper that was originally passed a `wrappingComponent` option');
        }
        return this[WRAPPING_COMPONENT];
      }

      return getWrappingComponent;
    }()

    /**
     * Forces a re-render. Useful to run before checking the render output if something external
     * may be updating the state of the component somewhere.
     *
     * NOTE: no matter what instance this is called on, it will always update the root.
     *
     * @returns {ReactWrapper}
     */

  }, {
    key: 'update',
    value: function () {
      function update() {
        var _this4 = this;

        var root = this[ROOT];
        if (this !== root) {
          return root.update();
        }
        privateSetNodes(this, this[RENDERER].getNode());
        this[LINKED_ROOTS].forEach(function (linkedRoot) {
          if (linkedRoot !== _this4[UPDATED_BY]) {
            /* eslint-disable no-param-reassign */
            // Only update a linked it root if it is not the originator of our update().
            // This is needed to prevent infinite recursion when there is a bi-directional
            // link between two roots.
            linkedRoot[UPDATED_BY] = _this4;
            try {
              linkedRoot.update();
            } finally {
              linkedRoot[UPDATED_BY] = null;
            }
          }
        });
        return this;
      }

      return update;
    }()

    /**
     * A method that unmounts the component. This can be used to simulate a component going through
     * and unmount/mount lifecycle.
     *
     * @returns {ReactWrapper}
     */

  }, {
    key: 'unmount',
    value: function () {
      function unmount() {
        var _this5 = this;

        if (this[ROOT] !== this) {
          throw new Error('ReactWrapper::unmount() can only be called on the root');
        }
        this.single('unmount', function () {
          _this5[RENDERER].unmount();
          _this5.update();
        });
        return this;
      }

      return unmount;
    }()

    /**
     * A method that re-mounts the component, if it is not currently mounted.
     * This can be used to simulate a component going through
     * an unmount/mount lifecycle.
     *
     * @returns {ReactWrapper}
     */

  }, {
    key: 'mount',
    value: function () {
      function mount() {
        var _this6 = this;

        if (this[ROOT] !== this) {
          throw new Error('ReactWrapper::mount() can only be called on the root');
        }
        this[RENDERER].render(this[UNRENDERED], this[OPTIONS].context, function () {
          return _this6.update();
        });
        return this;
      }

      return mount;
    }()

    /**
     * A method that sets the props of the root component, and re-renders. Useful for when you are
     * wanting to test how the component behaves over time with changing props. Calling this, for
     * instance, will call the `componentWillReceiveProps` lifecycle method.
     *
     * Similar to `setState`, this method accepts a props object and will merge it in with the already
     * existing props.
     *
     * NOTE: can only be called on a wrapper instance that is also the root instance.
     *
     * @param {Object} props object
     * @param {Function} cb - callback function
     * @returns {ReactWrapper}
     */

  }, {
    key: 'setProps',
    value: function () {
      function setProps(props) {
        var _this7 = this;

        var callback = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : undefined;

        if (this[ROOT] !== this) {
          throw new Error('ReactWrapper::setProps() can only be called on the root');
        }
        if (arguments.length > 1 && typeof callback !== 'function') {
          throw new TypeError('ReactWrapper::setProps() expects a function as its second argument');
        }
        var adapter = (0, _getAdapter2['default'])(this[OPTIONS]);
        this[UNRENDERED] = (0, _Utils.cloneElement)(adapter, this[UNRENDERED], props);
        this[RENDERER].render(this[UNRENDERED], null, function () {
          _this7.update();
          if (callback) {
            callback();
          }
        });
        return this;
      }

      return setProps;
    }()

    /**
     * A method to invoke `setState` on the root component instance similar to how you might in the
     * definition of the component, and re-renders.  This method is useful for testing your component
     * in hard to achieve states, however should be used sparingly. If possible, you should utilize
     * your component's external API in order to get it into whatever state you want to test, in order
     * to be as accurate of a test as possible. This is not always practical, however.
     *
     * NOTE: can only be called on a wrapper instance that is also the root instance.
     *
     * @param {Object} state to merge
     * @param {Function} cb - callback function
     * @returns {ReactWrapper}
     */

  }, {
    key: 'setState',
    value: function () {
      function setState(state) {
        var _this8 = this;

        var callback = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : undefined;

        if (this.instance() === null || this.getNodeInternal().nodeType !== 'class') {
          throw new Error('ReactWrapper::setState() can only be called on class components');
        }
        if (arguments.length > 1 && typeof callback !== 'function') {
          throw new TypeError('ReactWrapper::setState() expects a function as its second argument');
        }
        this.instance().setState(state, function () {
          _this8.update();
          if (callback) {
            var adapter = (0, _getAdapter2['default'])(_this8[OPTIONS]);
            var instance = _this8.instance();
            if (adapter.invokeSetStateCallback) {
              adapter.invokeSetStateCallback(instance, callback);
            } else {
              callback.call(instance);
            }
          }
        });
        return this;
      }

      return setState;
    }()

    /**
     * A method that sets the context of the root component, and re-renders. Useful for when you are
     * wanting to test how the component behaves over time with changing contexts.
     *
     * NOTE: can only be called on a wrapper instance that is also the root instance.
     *
     * @param {Object} context object
     * @returns {ReactWrapper}
     */

  }, {
    key: 'setContext',
    value: function () {
      function setContext(context) {
        var _this9 = this;

        if (this[ROOT] !== this) {
          throw new Error('ReactWrapper::setContext() can only be called on the root');
        }
        if (!this[OPTIONS].context) {
          throw new Error('ReactWrapper::setContext() can only be called on a wrapper that was originally passed a context option');
        }
        this[RENDERER].render(this[UNRENDERED], context, function () {
          return _this9.update();
        });
        return this;
      }

      return setContext;
    }()

    /**
     * Whether or not a given react element exists in the mount render tree.
     *
     * Example:
     * ```
     * const wrapper = mount(<MyComponent />);
     * expect(wrapper.contains(<div className="foo bar" />)).to.equal(true);
     * ```
     *
     * @param {ReactElement|Array<ReactElement>} nodeOrNodes
     * @returns {Boolean}
     */

  }, {
    key: 'contains',
    value: function () {
      function contains(nodeOrNodes) {
        var adapter = (0, _getAdapter2['default'])(this[OPTIONS]);

        var predicate = Array.isArray(nodeOrNodes) ? function (other) {
          return (0, _Utils.containsChildrenSubArray)(_Utils.nodeEqual, other, nodeOrNodes.map(function (node) {
            return adapter.elementToNode(node);
          }));
        } : function (other) {
          return (0, _Utils.nodeEqual)(adapter.elementToNode(nodeOrNodes), other);
        };

        return findWhereUnwrapped(this, predicate).length > 0;
      }

      return contains;
    }()

    /**
     * Whether or not a given react element exists in the current render tree.
     * It will determine if one of the wrappers element "looks like" the expected
     * element by checking if all props of the expected element are present
     * on the wrappers element and equals to each other.
     *
     * Example:
     * ```
     * // MyComponent outputs <div><div class="foo">Hello</div></div>
     * const wrapper = mount(<MyComponent />);
     * expect(wrapper.containsMatchingElement(<div>Hello</div>)).to.equal(true);
     * ```
     *
     * @param {ReactElement} node
     * @returns {Boolean}
     */

  }, {
    key: 'containsMatchingElement',
    value: function () {
      function containsMatchingElement(node) {
        var rstNode = (0, _getAdapter2['default'])(this[OPTIONS]).elementToNode(node);
        var predicate = function () {
          function predicate(other) {
            return (0, _Utils.nodeMatches)(rstNode, other, function (a, b) {
              return a <= b;
            });
          }

          return predicate;
        }();
        return findWhereUnwrapped(this, predicate).length > 0;
      }

      return containsMatchingElement;
    }()

    /**
     * Whether or not all the given react elements exist in the current render tree.
     * It will determine if one of the wrappers element "looks like" the expected
     * element by checking if all props of the expected element are present
     * on the wrappers element and equals to each other.
     *
     * Example:
     * ```
     * const wrapper = mount(<MyComponent />);
     * expect(wrapper.containsAllMatchingElements([
     *   <div>Hello</div>,
     *   <div>Goodbye</div>,
     * ])).to.equal(true);
     * ```
     *
     * @param {Array<ReactElement>} nodes
     * @returns {Boolean}
     */

  }, {
    key: 'containsAllMatchingElements',
    value: function () {
      function containsAllMatchingElements(nodes) {
        var _this10 = this;

        if (!Array.isArray(nodes)) {
          throw new TypeError('nodes should be an Array');
        }

        return nodes.every(function (node) {
          return _this10.containsMatchingElement(node);
        });
      }

      return containsAllMatchingElements;
    }()

    /**
     * Whether or not one of the given react elements exists in the current render tree.
     * It will determine if one of the wrappers element "looks like" the expected
     * element by checking if all props of the expected element are present
     * on the wrappers element and equals to each other.
     *
     * Example:
     * ```
     * const wrapper = mount(<MyComponent />);
     * expect(wrapper.containsAnyMatchingElements([
     *   <div>Hello</div>,
     *   <div>Goodbye</div>,
     * ])).to.equal(true);
     * ```
     *
     * @param {Array<ReactElement>} nodes
     * @returns {Boolean}
     */

  }, {
    key: 'containsAnyMatchingElements',
    value: function () {
      function containsAnyMatchingElements(nodes) {
        var _this11 = this;

        return Array.isArray(nodes) && nodes.some(function (node) {
          return _this11.containsMatchingElement(node);
        });
      }

      return containsAnyMatchingElements;
    }()

    /**
     * Whether or not a given react element exists in the render tree.
     *
     * Example:
     * ```
     * const wrapper = mount(<MyComponent />);
     * expect(wrapper.contains(<div className="foo bar" />)).to.equal(true);
     * ```
     *
     * @param {ReactElement} node
     * @returns {Boolean}
     */

  }, {
    key: 'equals',
    value: function () {
      function equals(node) {
        var _this12 = this;

        return this.single('equals', function () {
          return (0, _Utils.nodeEqual)(_this12.getNodeInternal(), node);
        });
      }

      return equals;
    }()

    /**
     * Whether or not a given react element matches the render tree.
     * Match is based on the expected element and not on wrapper root node.
     * It will determine if the wrapper root node "looks like" the expected
     * element by checking if all props of the expected element are present
     * on the wrapper root node and equals to each other.
     *
     * Example:
     * ```
     * // MyComponent outputs <div class="foo">Hello</div>
     * const wrapper = mount(<MyComponent />);
     * expect(wrapper.matchesElement(<div>Hello</div>)).to.equal(true);
     * ```
     *
     * @param {ReactElement} node
     * @returns {Boolean}
     */

  }, {
    key: 'matchesElement',
    value: function () {
      function matchesElement(node) {
        var _this13 = this;

        return this.single('matchesElement', function () {
          var adapter = (0, _getAdapter2['default'])(_this13[OPTIONS]);
          var rstNode = adapter.elementToNode(node);
          return (0, _Utils.nodeMatches)(rstNode, _this13.getNodeInternal(), function (a, b) {
            return a <= b;
          });
        });
      }

      return matchesElement;
    }()

    /**
     * Finds every node in the render tree of the current wrapper that matches the provided selector.
     *
     * @param {EnzymeSelector} selector
     * @returns {ReactWrapper}
     */

  }, {
    key: 'find',
    value: function () {
      function find(selector) {
        return this.wrap((0, _selectors.reduceTreesBySelector)(selector, this.getNodesInternal()));
      }

      return find;
    }()

    /**
     * Returns whether or not current node matches a provided selector.
     *
     * NOTE: can only be called on a wrapper of a single node.
     *
     * @param {EnzymeSelector} selector
     * @returns {boolean}
     */

  }, {
    key: 'is',
    value: function () {
      function is(selector) {
        var predicate = (0, _selectors.buildPredicate)(selector);
        return this.single('is', function (n) {
          return predicate(n);
        });
      }

      return is;
    }()

    /**
     * Returns true if the component rendered nothing, i.e., null or false.
     *
     * @returns {boolean}
     */

  }, {
    key: 'isEmptyRender',
    value: function () {
      function isEmptyRender() {
        var nodes = this.getNodeInternal();

        return (0, _Utils.renderedDive)(nodes);
      }

      return isEmptyRender;
    }()

    /**
     * Returns a new wrapper instance with only the nodes of the current wrapper instance that match
     * the provided predicate function.
     *
     * @param {Function} predicate
     * @returns {ReactWrapper}
     */

  }, {
    key: 'filterWhere',
    value: function () {
      function filterWhere(predicate) {
        var _this14 = this;

        return filterWhereUnwrapped(this, function (n) {
          return predicate(_this14.wrap(n));
        });
      }

      return filterWhere;
    }()

    /**
     * Returns a new wrapper instance with only the nodes of the current wrapper instance that match
     * the provided selector.
     *
     * @param {EnzymeSelector} selector
     * @returns {ReactWrapper}
     */

  }, {
    key: 'filter',
    value: function () {
      function filter(selector) {
        var predicate = (0, _selectors.buildPredicate)(selector);
        return filterWhereUnwrapped(this, predicate);
      }

      return filter;
    }()

    /**
     * Returns a new wrapper instance with only the nodes of the current wrapper that did not match
     * the provided selector. Essentially the inverse of `filter`.
     *
     * @param {EnzymeSelector} selector
     * @returns {ReactWrapper}
     */

  }, {
    key: 'not',
    value: function () {
      function not(selector) {
        var predicate = (0, _selectors.buildPredicate)(selector);
        return filterWhereUnwrapped(this, function (n) {
          return !predicate(n);
        });
      }

      return not;
    }()

    /**
     * Returns a string of the rendered text of the current render tree.  This function should be
     * looked at with skepticism if being used to test what the actual HTML output of the component
     * will be. If that is what you would like to test, use enzyme's `render` function instead.
     *
     * NOTE: can only be called on a wrapper of a single node.
     *
     * @returns {String}
     */

  }, {
    key: 'text',
    value: function () {
      function text() {
        var adapter = (0, _getAdapter2['default'])(this[OPTIONS]);
        return this.single('text', function (n) {
          return (0, _RSTTraversal.getTextFromHostNodes)(n, adapter);
        });
      }

      return text;
    }()

    /**
     * Returns the HTML of the node.
     *
     * NOTE: can only be called on a wrapper of a single node.
     *
     * @returns {String}
     */

  }, {
    key: 'html',
    value: function () {
      function html() {
        var adapter = (0, _getAdapter2['default'])(this[OPTIONS]);
        return this.single('html', function (n) {
          return (0, _RSTTraversal.getHTMLFromHostNodes)(n, adapter);
        });
      }

      return html;
    }()

    /**
     * Returns the current node rendered to HTML and wrapped in a CheerioWrapper.
     *
     * NOTE: can only be called on a wrapper of a single node.
     *
     * @returns {CheerioWrapper}
     */

  }, {
    key: 'render',
    value: function () {
      function render() {
        var html = this.html();
        return (0, _Utils.loadCheerioRoot)(html);
      }

      return render;
    }()

    /**
     * Used to simulate events. Pass an eventname and (optionally) event arguments. This method of
     * testing events should be met with some skepticism.
     *
     * @param {String} event
     * @param {Object} mock (optional)
     * @returns {ReactWrapper}
     */

  }, {
    key: 'simulate',
    value: function () {
      function simulate(event) {
        var _this15 = this;

        var mock = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

        return this.single('simulate', function (n) {
          _this15[RENDERER].simulateEvent(n, event, mock);
          _this15[ROOT].update();
          return _this15;
        });
      }

      return simulate;
    }()

    /**
     * Used to simulate throwing a rendering error. Pass an error to throw.
     *
     * @param {String} error
     * @returns {ReactWrapper}
     */

  }, {
    key: 'simulateError',
    value: function () {
      function simulateError(error) {
        var _this16 = this;

        if (this[ROOT] === this) {
          throw new Error('ReactWrapper::simulateError() may not be called on the root');
        }

        return this.single('simulateError', function (thisNode) {
          if (thisNode.nodeType === 'host') {
            throw new Error('ReactWrapper::simulateError() can only be called on custom components');
          }

          var renderer = _this16[RENDERER];
          if (typeof renderer.simulateError !== 'function') {
            throw new TypeError('your adapter does not support `simulateError`. Try upgrading it!');
          }

          var rootNode = getRootNodeInternal(_this16);
          var nodeHierarchy = [thisNode].concat(nodeParents(_this16, thisNode));
          renderer.simulateError(nodeHierarchy, rootNode, error);

          _this16[ROOT].update();
          return _this16;
        });
      }

      return simulateError;
    }()

    /**
     * Returns the props hash for the root node of the wrapper.
     *
     * NOTE: can only be called on a wrapper of a single node.
     *
     * @returns {Object}
     */

  }, {
    key: 'props',
    value: function () {
      function props() {
        return this.single('props', _RSTTraversal.propsOfNode);
      }

      return props;
    }()

    /**
     * Returns the state hash for the root node of the wrapper. Optionally pass in a prop name and it
     * will return just that value.
     *
     * NOTE: can only be called on a wrapper of a single node.
     *
     * @param {String} name (optional)
     * @returns {*}
     */

  }, {
    key: 'state',
    value: function () {
      function state(name) {
        var _this17 = this;

        var thisNode = this[ROOT] === this ? this[RENDERER].getNode() : this.getNodeInternal();
        if (this.instance() === null || thisNode.nodeType !== 'class') {
          throw new Error('ReactWrapper::state() can only be called on class components');
        }
        var _state = this.single('state', function () {
          return _this17.instance().state;
        });
        if (typeof name !== 'undefined') {
          if (_state == null) {
            throw new TypeError('ReactWrapper::state("' + String(name) + '") requires that `state` not be `null` or `undefined`');
          }
          return _state[name];
        }
        return _state;
      }

      return state;
    }()

    /**
     * Returns the context hash for the root node of the wrapper.
     * Optionally pass in a prop name and it will return just that value.
     *
     * NOTE: can only be called on a wrapper of a single node.
     *
     * @param {String} name (optional)
     * @returns {*}
     */

  }, {
    key: 'context',
    value: function () {
      function context(name) {
        var _this18 = this;

        if (this[ROOT] !== this) {
          throw new Error('ReactWrapper::context() can only be called on the root');
        }
        var instance = this.single('context', function () {
          return _this18.instance();
        });
        if (instance === null) {
          throw new Error('ReactWrapper::context() can only be called on components with instances');
        }
        var _context = instance.context;
        if (typeof name !== 'undefined') {
          return _context[name];
        }
        return _context;
      }

      return context;
    }()

    /**
     * Returns a new wrapper with all of the children of the current wrapper.
     *
     * @param {EnzymeSelector} [selector]
     * @returns {ReactWrapper}
     */

  }, {
    key: 'children',
    value: function () {
      function children(selector) {
        var allChildren = this.flatMap(function (n) {
          return (0, _RSTTraversal.childrenOfNode)(n.getNodeInternal());
        });
        return selector ? allChildren.filter(selector) : allChildren;
      }

      return children;
    }()

    /**
     * Returns a new wrapper with a specific child
     *
     * @param {Number} [index]
     * @returns {ReactWrapper}
     */

  }, {
    key: 'childAt',
    value: function () {
      function childAt(index) {
        var _this19 = this;

        return this.single('childAt', function () {
          return _this19.children().at(index);
        });
      }

      return childAt;
    }()

    /**
     * Returns a wrapper around all of the parents/ancestors of the wrapper. Does not include the node
     * in the current wrapper.
     *
     * NOTE: can only be called on a wrapper of a single node.
     *
     * @param {EnzymeSelector} [selector]
     * @returns {ReactWrapper}
     */

  }, {
    key: 'parents',
    value: function () {
      function parents(selector) {
        var _this20 = this;

        return this.single('parents', function (n) {
          var allParents = _this20.wrap(nodeParents(_this20, n));
          return selector ? allParents.filter(selector) : allParents;
        });
      }

      return parents;
    }()

    /**
     * Returns a wrapper around the immediate parent of the current node.
     *
     * @returns {ReactWrapper}
     */

  }, {
    key: 'parent',
    value: function () {
      function parent() {
        return this.flatMap(function (n) {
          return [n.parents().get(0)];
        });
      }

      return parent;
    }()

    /**
     *
     * @param {EnzymeSelector} selector
     * @returns {ReactWrapper}
     */

  }, {
    key: 'closest',
    value: function () {
      function closest(selector) {
        if (this.is(selector)) {
          return this;
        }
        var matchingAncestors = this.parents().filter(selector);
        return matchingAncestors.length > 0 ? matchingAncestors.first() : this.findWhere(function () {
          return false;
        });
      }

      return closest;
    }()

    /**
     * Returns the value of  prop with the given name of the root node.
     *
     * @param {String} propName
     * @returns {*}
     */

  }, {
    key: 'prop',
    value: function () {
      function prop(propName) {
        return this.props()[propName];
      }

      return prop;
    }()

    /**
     * Used to invoke a function prop.
     * Will invoke an function prop and return its value.
     *
     * @param {String} propName
     * @returns {Any}
     */

  }, {
    key: 'invoke',
    value: function () {
      function invoke(propName) {
        var _this21 = this;

        return this.single('invoke', function () {
          var handler = _this21.prop(propName);
          if (typeof handler !== 'function') {
            throw new TypeError('ReactWrapper::invoke() requires the name of a prop whose value is a function');
          }
          return function () {
            for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
              args[_key] = arguments[_key];
            }

            var response = typeof _this21[RENDERER].wrapInvoke === 'function' ? _this21[RENDERER].wrapInvoke(function () {
              return handler.apply(undefined, args);
            }) : handler.apply(undefined, args);
            _this21[ROOT].update();
            return response;
          };
        });
      }

      return invoke;
    }()

    /**
     * Returns a wrapper of the node rendered by the provided render prop.
     *
     * @param {String} propName
     * @returns {Function}
     */

  }, {
    key: 'renderProp',
    value: function () {
      function renderProp(propName) {
        var _this22 = this;

        var adapter = (0, _getAdapter2['default'])(this[OPTIONS]);
        if (typeof adapter.wrap !== 'function') {
          throw new RangeError('your adapter does not support `wrap`. Try upgrading it!');
        }

        return this.single('renderProp', function (n) {
          if (n.nodeType === 'host') {
            throw new TypeError('ReactWrapper::renderProp() can only be called on custom components');
          }
          if (typeof propName !== 'string') {
            throw new TypeError('ReactWrapper::renderProp(): `propName` must be a string');
          }
          var props = _this22.props();
          if (!(0, _has2['default'])(props, propName)) {
            throw new Error('ReactWrapper::renderProp(): no prop called \u201C' + String(propName) + '\u201C found');
          }
          var propValue = props[propName];
          if (typeof propValue !== 'function') {
            throw new TypeError('ReactWrapper::renderProp(): expected prop \u201C' + String(propName) + '\u201C to contain a function, but it holds \u201C' + (typeof propValue === 'undefined' ? 'undefined' : _typeof(propValue)) + '\u201C');
          }

          return function () {
            var element = propValue.apply(undefined, arguments);
            var wrapped = adapter.wrap(element);
            return _this22.wrap(wrapped, null, _this22[OPTIONS]);
          };
        });
      }

      return renderProp;
    }()

    /**
     * Returns the key assigned to the current node.
     *
     * @returns {String}
     */

  }, {
    key: 'key',
    value: function () {
      function key() {
        return this.single('key', function (n) {
          return n.key === undefined ? null : n.key;
        });
      }

      return key;
    }()

    /**
     * Returns the type of the root node of this wrapper. If it's a composite component, this will be
     * the component constructor. If it's native DOM node, it will be a string.
     *
     * @returns {String|Function}
     */

  }, {
    key: 'type',
    value: function () {
      function type() {
        return this.single('type', function (n) {
          return (0, _Utils.typeOfNode)(n);
        });
      }

      return type;
    }()

    /**
     * Returns the name of the root node of this wrapper.
     *
     * In order of precedence => type.displayName -> type.name -> type.
     *
     * @returns {String}
     */

  }, {
    key: 'name',
    value: function () {
      function name() {
        var adapter = (0, _getAdapter2['default'])(this[OPTIONS]);
        return this.single('name', function (n) {
          return adapter.displayNameOfNode ? adapter.displayNameOfNode(n) : (0, _Utils.displayNameOfNode)(n);
        });
      }

      return name;
    }()

    /**
     * Returns whether or not the current root node has the given class name or not.
     *
     * NOTE: can only be called on a wrapper of a single node.
     *
     * @param {String} className
     * @returns {Boolean}
     */

  }, {
    key: 'hasClass',
    value: function () {
      function hasClass(className) {
        if (typeof className === 'string' && className.indexOf('.') !== -1) {
          // eslint-disable-next-line no-console
          console.warn('It looks like you\'re calling `ReactWrapper::hasClass()` with a CSS selector. hasClass() expects a class name, not a CSS selector.');
        }
        return this.single('hasClass', function (n) {
          return (0, _RSTTraversal.hasClassName)(n, className);
        });
      }

      return hasClass;
    }()

    /**
     * Iterates through each node of the current wrapper and executes the provided function with a
     * wrapper around the corresponding node passed in as the first argument.
     *
     * @param {Function} fn
     * @returns {ReactWrapper}
     */

  }, {
    key: 'forEach',
    value: function () {
      function forEach(fn) {
        var _this23 = this;

        this.getNodesInternal().forEach(function (n, i) {
          return fn.call(_this23, _this23.wrap(n), i);
        });
        return this;
      }

      return forEach;
    }()

    /**
     * Maps the current array of nodes to another array. Each node is passed in as a `ReactWrapper`
     * to the map function.
     *
     * @param {Function} fn
     * @returns {Array}
     */

  }, {
    key: 'map',
    value: function () {
      function map(fn) {
        var _this24 = this;

        return this.getNodesInternal().map(function (n, i) {
          return fn.call(_this24, _this24.wrap(n), i);
        });
      }

      return map;
    }()

    /**
     * Reduces the current array of nodes to another array.
     * Each node is passed in as a `ShallowWrapper` to the reducer function.
     *
     * @param {Function} fn - the reducer function
     * @param {*} initialValue - the initial value
     * @returns {*}
     */

  }, {
    key: 'reduce',
    value: function () {
      function reduce(fn) {
        var _this25 = this;

        var initialValue = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : undefined;

        if (arguments.length > 1) {
          return this.getNodesInternal().reduce(function (accum, n, i) {
            return fn.call(_this25, accum, _this25.wrap(n), i);
          }, initialValue);
        }
        return this.getNodesInternal().reduce(function (accum, n, i) {
          return fn.call(_this25, i === 1 ? _this25.wrap(accum) : accum, _this25.wrap(n), i);
        });
      }

      return reduce;
    }()

    /**
     * Reduces the current array of nodes to another array, from right to left. Each node is passed
     * in as a `ShallowWrapper` to the reducer function.
     *
     * @param {Function} fn - the reducer function
     * @param {*} initialValue - the initial value
     * @returns {*}
     */

  }, {
    key: 'reduceRight',
    value: function () {
      function reduceRight(fn) {
        var _this26 = this;

        var initialValue = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : undefined;

        if (arguments.length > 1) {
          return this.getNodesInternal().reduceRight(function (accum, n, i) {
            return fn.call(_this26, accum, _this26.wrap(n), i);
          }, initialValue);
        }
        return this.getNodesInternal().reduceRight(function (accum, n, i) {
          return fn.call(_this26, i === 1 ? _this26.wrap(accum) : accum, _this26.wrap(n), i);
        });
      }

      return reduceRight;
    }()

    /**
     * Returns a new wrapper with a subset of the nodes of the original wrapper, according to the
     * rules of `Array#slice`.
     *
     * @param {Number} begin
     * @param {Number} end
     * @returns {ShallowWrapper}
     */

  }, {
    key: 'slice',
    value: function () {
      function slice(begin, end) {
        return this.wrap(this.getNodesInternal().slice(begin, end));
      }

      return slice;
    }()

    /**
     * Returns whether or not any of the nodes in the wrapper match the provided selector.
     *
     * @param {EnzymeSelector} selector
     * @returns {Boolean}
     */

  }, {
    key: 'some',
    value: function () {
      function some(selector) {
        if (this[ROOT] === this) {
          throw new Error('ReactWrapper::some() can not be called on the root');
        }
        var predicate = (0, _selectors.buildPredicate)(selector);
        return this.getNodesInternal().some(predicate);
      }

      return some;
    }()

    /**
     * Returns whether or not any of the nodes in the wrapper pass the provided predicate function.
     *
     * @param {Function} predicate
     * @returns {Boolean}
     */

  }, {
    key: 'someWhere',
    value: function () {
      function someWhere(predicate) {
        var _this27 = this;

        return this.getNodesInternal().some(function (n, i) {
          return predicate.call(_this27, _this27.wrap(n), i);
        });
      }

      return someWhere;
    }()

    /**
     * Returns whether or not all of the nodes in the wrapper match the provided selector.
     *
     * @param {EnzymeSelector} selector
     * @returns {Boolean}
     */

  }, {
    key: 'every',
    value: function () {
      function every(selector) {
        var predicate = (0, _selectors.buildPredicate)(selector);
        return this.getNodesInternal().every(predicate);
      }

      return every;
    }()

    /**
     * Returns whether or not any of the nodes in the wrapper pass the provided predicate function.
     *
     * @param {Function} predicate
     * @returns {Boolean}
     */

  }, {
    key: 'everyWhere',
    value: function () {
      function everyWhere(predicate) {
        var _this28 = this;

        return this.getNodesInternal().every(function (n, i) {
          return predicate.call(_this28, _this28.wrap(n), i);
        });
      }

      return everyWhere;
    }()

    /**
     * Utility method used to create new wrappers with a mapping function that returns an array of
     * nodes in response to a single node wrapper. The returned wrapper is a single wrapper around
     * all of the mapped nodes flattened (and de-duplicated).
     *
     * @param {Function} fn
     * @returns {ReactWrapper}
     */

  }, {
    key: 'flatMap',
    value: function () {
      function flatMap(fn) {
        var _this29 = this;

        var nodes = this.getNodesInternal().map(function (n, i) {
          return fn.call(_this29, _this29.wrap(n), i);
        });
        var flattened = (0, _arrayPrototype2['default'])(nodes, 1);
        return this.wrap(flattened.filter(Boolean));
      }

      return flatMap;
    }()

    /**
     * Finds all nodes in the current wrapper nodes' render trees that match the provided predicate
     * function.
     *
     * @param {Function} predicate
     * @returns {ReactWrapper}
     */

  }, {
    key: 'findWhere',
    value: function () {
      function findWhere(predicate) {
        var _this30 = this;

        return findWhereUnwrapped(this, function (n) {
          var node = _this30.wrap(n);
          return node.length > 0 && predicate(node);
        });
      }

      return findWhere;
    }()

    /**
     * Returns the node at a given index of the current wrapper.
     *
     * @param {Number} index
     * @returns {ReactElement}
     */

  }, {
    key: 'get',
    value: function () {
      function get(index) {
        return this.getElements()[index];
      }

      return get;
    }()

    /**
     * Returns a wrapper around the node at a given index of the current wrapper.
     *
     * @param {Number} index
     * @returns {ReactWrapper}
     */

  }, {
    key: 'at',
    value: function () {
      function at(index) {
        var nodes = this.getNodesInternal();
        if (index < nodes.length) {
          return this.wrap(nodes[index]);
        }
        return this.wrap([]);
      }

      return at;
    }()

    /**
     * Returns a wrapper around the first node of the current wrapper.
     *
     * @returns {ReactWrapper}
     */

  }, {
    key: 'first',
    value: function () {
      function first() {
        return this.at(0);
      }

      return first;
    }()

    /**
     * Returns a wrapper around the last node of the current wrapper.
     *
     * @returns {ReactWrapper}
     */

  }, {
    key: 'last',
    value: function () {
      function last() {
        return this.at(this.length - 1);
      }

      return last;
    }()

    /**
     * Delegates to exists()
     *
     * @returns {boolean}
     */

  }, {
    key: 'isEmpty',
    value: function () {
      function isEmpty() {
        // eslint-disable-next-line no-console
        console.warn('Enzyme::Deprecated method isEmpty() called, use exists() instead.');
        return !this.exists();
      }

      return isEmpty;
    }()

    /**
     * Returns true if the current wrapper has nodes. False otherwise.
     * If called with a selector it returns `.find(selector).exists()` instead.
     *
     * @param {EnzymeSelector} selector (optional)
     * @returns {boolean}
     */

  }, {
    key: 'exists',
    value: function () {
      function exists() {
        var selector = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;

        return arguments.length > 0 ? this.find(selector).exists() : this.length > 0;
      }

      return exists;
    }()

    /**
     * Utility method that throws an error if the current instance has a length other than one.
     * This is primarily used to enforce that certain methods are only run on a wrapper when it is
     * wrapping a single node.
     *
     * @param {Function} fn
     * @returns {*}
     */

  }, {
    key: 'single',
    value: function () {
      function single(name, fn) {
        var fnName = typeof name === 'string' ? name : 'unknown';
        var callback = typeof fn === 'function' ? fn : name;
        if (this.length !== 1) {
          throw new Error('Method \u201C' + fnName + '\u201D is meant to be run on 1 node. ' + String(this.length) + ' found instead.');
        }
        return callback.call(this, this.getNodeInternal());
      }

      return single;
    }()

    /**
     * Helpful utility method to create a new wrapper with the same root as the current wrapper, with
     * any nodes passed in as the first parameter automatically wrapped.
     *
     * @param {ReactWrapper|ReactElement|Array<ReactElement>} node
     * @returns {ReactWrapper}
     */

  }, {
    key: 'wrap',
    value: function () {
      function wrap(node) {
        var root = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this[ROOT];

        if (node instanceof ReactWrapper) {
          return node;
        }

        for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
          args[_key2 - 2] = arguments[_key2];
        }

        return new (Function.prototype.bind.apply(ReactWrapper, [null].concat([node, root], args)))();
      }

      return wrap;
    }()

    /**
     * Returns an HTML-like string of the shallow render for debugging purposes.
     *
     * @param {Object} [options] - Property bag of additional options.
     * @param {boolean} [options.ignoreProps] - if true, props are omitted from the string.
     * @param {boolean} [options.verbose] - if true, arrays and objects to be verbosely printed.
     * @returns {String}
     */

  }, {
    key: 'debug',
    value: function () {
      function debug() {
        var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

        return (0, _Debug.debugNodes)(this.getNodesInternal(), options);
      }

      return debug;
    }()

    /**
     * Invokes intercepter and returns itself. intercepter is called with itself.
     * This is helpful when debugging nodes in method chains.
     * @param fn
     * @returns {ReactWrapper}
     */

  }, {
    key: 'tap',
    value: function () {
      function tap(intercepter) {
        intercepter(this);
        return this;
      }

      return tap;
    }()

    /**
     * Detaches the react tree from the DOM. Runs `ReactDOM.unmountComponentAtNode()` under the hood.
     *
     * This method will most commonly be used as a "cleanup" method if you decide to use the
     * `attachTo` option in `mount(node, options)`.
     *
     * The method is intentionally not "fluent" (in that it doesn't return `this`) because you should
     * not be doing anything with this wrapper after this method is called.
     */

  }, {
    key: 'detach',
    value: function () {
      function detach() {
        if (this[ROOT] !== this) {
          throw new Error('ReactWrapper::detach() can only be called on the root');
        }
        if (!this[OPTIONS].attachTo) {
          throw new Error('ReactWrapper::detach() can only be called on when the `attachTo` option was passed into `mount()`.');
        }
        this[RENDERER].unmount();
      }

      return detach;
    }()

    /**
     * Strips out all the not host-nodes from the list of nodes
     *
     * This method is useful if you want to check for the presence of host nodes
     * (actually rendered HTML elements) ignoring the React nodes.
     */

  }, {
    key: 'hostNodes',
    value: function () {
      function hostNodes() {
        return this.filterWhere(function (n) {
          return typeof n.type() === 'string';
        });
      }

      return hostNodes;
    }()
  }]);

  return ReactWrapper;
}();

/**
 * A *special* "root" wrapper that represents the component passed as `wrappingComponent`.
 * It is linked to the primary root such that updates to it will update the primary,
 * and vice versa.
 *
 * @class WrappingComponentWrapper
 */


var WrappingComponentWrapper = function (_ReactWrapper) {
  _inherits(WrappingComponentWrapper, _ReactWrapper);

  /* eslint-disable class-methods-use-this */
  function WrappingComponentWrapper(root, renderer) {
    _classCallCheck(this, WrappingComponentWrapper);

    var _this31 = _possibleConstructorReturn(this, (WrappingComponentWrapper.__proto__ || Object.getPrototypeOf(WrappingComponentWrapper)).call(this, renderer.getNode(), root));

    (0, _Utils.privateSet)(_this31, ROOT, _this31);
    (0, _Utils.privateSet)(_this31, RENDERER, renderer);
    _this31[LINKED_ROOTS].push(root);
    return _this31;
  }

  _createClass(WrappingComponentWrapper, [{
    key: 'getWrappingComponent',
    value: function () {
      function getWrappingComponent() {
        throw new TypeError('ReactWrapper::getWrappingComponent() can only be called on the root');
      }

      return getWrappingComponent;
    }()
  }]);

  return WrappingComponentWrapper;
}(ReactWrapper);

if (_Utils.ITERATOR_SYMBOL) {
  Object.defineProperty(ReactWrapper.prototype, _Utils.ITERATOR_SYMBOL, {
    configurable: true,
    value: function () {
      function iterator() {
        var _ref;

        var iter = this[NODES][_Utils.ITERATOR_SYMBOL]();
        var adapter = (0, _getAdapter2['default'])(this[OPTIONS]);
        return _ref = {}, _defineProperty(_ref, _Utils.ITERATOR_SYMBOL, function () {
          return this;
        }), _defineProperty(_ref, 'next', function () {
          function next() {
            var next = iter.next();
            if (next.done) {
              return { done: true };
            }
            return {
              done: false,
              value: adapter.nodeToElement(next.value)
            };
          }

          return next;
        }()), _ref;
      }

      return iterator;
    }()
  });
}

function privateWarning(prop, extraMessage) {
  Object.defineProperty(ReactWrapper.prototype, prop, {
    get: function () {
      function get() {
        throw new Error('\n        Attempted to access ReactWrapper::' + String(prop) + ', which was previously a private property on\n        Enzyme ReactWrapper instances, but is no longer and should not be relied upon.\n        ' + String(extraMessage) + '\n      ');
      }

      return get;
    }(),

    enumerable: false,
    configurable: false
  });
}

privateWarning('node', 'Consider using the getElement() method instead.');
privateWarning('nodes', 'Consider using the getElements() method instead.');
privateWarning('renderer', '');
privateWarning('options', '');
privateWarning('complexSelector', '');

exports['default'] = ReactWrapper;
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/ReactWrapper.js"],"names":["NODE","NODES","RENDERER","UNRENDERED","ROOT","OPTIONS","ROOT_NODES","WRAPPING_COMPONENT","LINKED_ROOTS","UPDATED_BY","findWhereUnwrapped","wrapper","predicate","filter","treeFilter","flatMap","n","getNodeInternal","filterWhereUnwrapped","wrap","getNodesInternal","Boolean","getRootNodeInternal","length","Error","nodeParents","node","privateSetNodes","nodes","Array","isArray","ReactWrapper","root","passedOptions","global","window","document","options","adapter","isValidElement","TypeError","renderer","createRenderer","mode","render","context","getNode","wrappingComponent","getWrappingComponentRenderer","WrappingComponentWrapper","push","single","nodeToElement","map","nodeToHostNode","refname","instance","refs","update","forEach","linkedRoot","unmount","props","callback","undefined","arguments","state","nodeType","setState","invokeSetStateCallback","call","nodeOrNodes","other","nodeEqual","elementToNode","rstNode","a","b","every","containsMatchingElement","some","selector","html","event","mock","simulateEvent","error","thisNode","simulateError","rootNode","nodeHierarchy","concat","propsOfNode","name","_state","_context","allChildren","index","children","at","allParents","parents","get","is","matchingAncestors","first","findWhere","propName","handler","prop","args","response","wrapInvoke","RangeError","propValue","element","wrapped","key","displayNameOfNode","className","indexOf","console","warn","fn","i","initialValue","reduce","accum","reduceRight","begin","end","slice","flattened","getElements","exists","find","fnName","intercepter","attachTo","filterWhere","type","ITERATOR_SYMBOL","Object","defineProperty","prototype","configurable","value","iterator","iter","next","done","privateWarning","extraMessage","enumerable"],"mappings":"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","file":"ReactWrapper.js","sourcesContent":["import flat from 'array.prototype.flat';\nimport has from 'has';\n\nimport {\n  containsChildrenSubArray,\n  typeOfNode,\n  displayNameOfNode,\n  ITERATOR_SYMBOL,\n  nodeEqual,\n  nodeMatches,\n  makeOptions,\n  sym,\n  privateSet,\n  cloneElement,\n  renderedDive,\n  isCustomComponent,\n  loadCheerioRoot,\n} from './Utils';\nimport getAdapter from './getAdapter';\nimport { debugNodes } from './Debug';\nimport {\n  propsOfNode,\n  hasClassName,\n  childrenOfNode,\n  parentsOfNode,\n  treeFilter,\n  getTextFromHostNodes,\n  getHTMLFromHostNodes,\n} from './RSTTraversal';\n\nimport { buildPredicate, reduceTreesBySelector } from './selectors';\n\nconst NODE = sym('__node__');\nconst NODES = sym('__nodes__');\nconst RENDERER = sym('__renderer__');\nconst UNRENDERED = sym('__unrendered__');\nconst ROOT = sym('__root__');\nconst OPTIONS = sym('__options__');\nconst ROOT_NODES = sym('__rootNodes__');\nconst WRAPPING_COMPONENT = sym('__wrappingComponent__');\nconst LINKED_ROOTS = sym('__linkedRoots__');\nconst UPDATED_BY = sym('__updatedBy__');\n\n/**\n * Finds all nodes in the current wrapper nodes' render trees that match the provided predicate\n * function.\n *\n * @param {ReactWrapper} wrapper\n * @param {Function} predicate\n * @param {Function} filter\n * @returns {ReactWrapper}\n */\nfunction findWhereUnwrapped(wrapper, predicate, filter = treeFilter) {\n  return wrapper.flatMap((n) => filter(n.getNodeInternal(), predicate));\n}\n\n/**\n * Returns a new wrapper instance with only the nodes of the current wrapper instance that match\n * the provided predicate function.\n *\n * @param {ReactWrapper} wrapper\n * @param {Function} predicate\n * @returns {ReactWrapper}\n */\nfunction filterWhereUnwrapped(wrapper, predicate) {\n  return wrapper.wrap(wrapper.getNodesInternal().filter(predicate).filter(Boolean));\n}\n\nfunction getRootNodeInternal(wrapper) {\n  if (wrapper[ROOT].length !== 1) {\n    throw new Error('getRootNodeInternal(wrapper) can only be called when wrapper wraps one node');\n  }\n  if (wrapper[ROOT] !== wrapper) {\n    return wrapper[ROOT_NODES][0];\n  }\n  return wrapper[ROOT][NODE];\n}\n\nfunction nodeParents(wrapper, node) {\n  return parentsOfNode(node, getRootNodeInternal(wrapper));\n}\n\nfunction privateSetNodes(wrapper, nodes) {\n  if (!nodes) {\n    privateSet(wrapper, NODE, null);\n    privateSet(wrapper, NODES, []);\n  } else if (!Array.isArray(nodes)) {\n    privateSet(wrapper, NODE, nodes);\n    privateSet(wrapper, NODES, [nodes]);\n  } else {\n    privateSet(wrapper, NODE, nodes[0]);\n    privateSet(wrapper, NODES, nodes);\n  }\n  privateSet(wrapper, 'length', wrapper[NODES].length);\n}\n\n/**\n * @class ReactWrapper\n */\nclass ReactWrapper {\n  constructor(nodes, root, passedOptions = {}) {\n    if (!global.window && !global.document) {\n      throw new Error('It looks like you called `mount()` without a global document being loaded.');\n    }\n    const options = makeOptions(passedOptions);\n\n    if (!root) {\n      const adapter = getAdapter(options);\n      if (!adapter.isValidElement(nodes)) {\n        throw new TypeError('ReactWrapper can only wrap valid elements');\n      }\n\n      const renderer = adapter.createRenderer({ mode: 'mount', ...options });\n      privateSet(this, RENDERER, renderer);\n      renderer.render(nodes, options.context);\n      privateSet(this, ROOT, this);\n      privateSetNodes(this, this[RENDERER].getNode());\n      privateSet(this, OPTIONS, options);\n      privateSet(this, LINKED_ROOTS, []);\n\n      if (isCustomComponent(options.wrappingComponent, adapter)) {\n        if (typeof this[RENDERER].getWrappingComponentRenderer !== 'function') {\n          throw new TypeError('your adapter does not support `wrappingComponent`. Try upgrading it!');\n        }\n\n        // eslint-disable-next-line no-use-before-define\n        privateSet(this, WRAPPING_COMPONENT, new WrappingComponentWrapper(\n          this, this[RENDERER].getWrappingComponentRenderer(),\n        ));\n        this[LINKED_ROOTS].push(this[WRAPPING_COMPONENT]);\n      }\n    } else {\n      privateSet(this, RENDERER, root[RENDERER]);\n      privateSet(this, ROOT, root);\n      privateSetNodes(this, nodes);\n      privateSet(this, ROOT_NODES, root[NODES]);\n      privateSet(this, OPTIONS, root[OPTIONS]);\n      privateSet(this, LINKED_ROOTS, []);\n    }\n    privateSet(this, UNRENDERED, nodes);\n    privateSet(this, UPDATED_BY, null);\n  }\n\n  /**\n   * Returns the root wrapper\n   *\n   * @return {ReactWrapper}\n   */\n  root() {\n    return this[ROOT];\n  }\n\n  /**\n   * Returns the wrapped component.\n   *\n   * @return {ReactComponent}\n   */\n  getNodeInternal() {\n    if (this.length !== 1) {\n      throw new Error('ReactWrapper::getNode() can only be called when wrapping one node');\n    }\n    return this[NODES][0];\n  }\n\n  /**\n   * Returns the the wrapped components.\n   *\n   * @return {Array<ReactComponent>}\n   */\n  getNodesInternal() {\n    return this[NODES];\n  }\n\n  /**\n   * Returns the wrapped ReactElement.\n   *\n   * @return {ReactElement}\n   */\n  getElement() {\n    return this.single('getElement', () => getAdapter(this[OPTIONS]).nodeToElement(this[NODE]));\n  }\n\n  /**\n   * Returns the wrapped ReactElements.\n   *\n   * @return {Array<ReactElement>}\n   */\n  getElements() {\n    return this[NODES].map((n) => getAdapter(this[OPTIONS]).nodeToElement(n));\n  }\n\n  // eslint-disable-next-line class-methods-use-this\n  getNode() {\n    throw new Error('ReactWrapper::getNode() is no longer supported. Use ReactWrapper::instance() instead');\n  }\n\n  // eslint-disable-next-line class-methods-use-this\n  getNodes() {\n    throw new Error('ReactWrapper::getNodes() is no longer supported.');\n  }\n\n  /**\n   * Returns the outer most DOMComponent of the current wrapper.\n   *\n   * NOTE: can only be called on a wrapper of a single node.\n   *\n   * @returns {DOMComponent}\n   */\n  getDOMNode() {\n    const adapter = getAdapter(this[OPTIONS]);\n    return this.single('getDOMNode', (n) => adapter.nodeToHostNode(n, true));\n  }\n\n  /**\n   * If the root component contained a ref, you can access it here and get the relevant\n   * react component instance or HTML element instance.\n   *\n   * NOTE: can only be called on a wrapper instance that is also the root instance.\n   *\n   * @param {String} refname\n   * @returns {ReactComponent | HTMLElement}\n   */\n  ref(refname) {\n    if (this[ROOT] !== this) {\n      throw new Error('ReactWrapper::ref(refname) can only be called on the root');\n    }\n    return this.instance().refs[refname];\n  }\n\n  /**\n   * Returns the wrapper's underlying instance.\n   *\n   * Example:\n   * ```\n   * const wrapper = mount(<MyComponent />);\n   * const inst = wrapper.instance();\n   * expect(inst).to.be.instanceOf(MyComponent);\n   * ```\n   * @returns {ReactComponent|DOMComponent}\n   */\n  instance() {\n    return this.single('instance', () => this[NODE].instance);\n  }\n\n  /**\n   * If a `wrappingComponent` was passed in `options`, this methods returns a `ReactWrapper` around\n   * the rendered `wrappingComponent`. This `ReactWrapper` can be used to update the\n   * `wrappingComponent`'s props, state, etc.\n   *\n   * @returns ReactWrapper\n   */\n  getWrappingComponent() {\n    if (this[ROOT] !== this) {\n      throw new Error('ReactWrapper::getWrappingComponent() can only be called on the root');\n    }\n    if (!this[OPTIONS].wrappingComponent) {\n      throw new Error('ReactWrapper::getWrappingComponent() can only be called on a wrapper that was originally passed a `wrappingComponent` option');\n    }\n    return this[WRAPPING_COMPONENT];\n  }\n\n  /**\n   * Forces a re-render. Useful to run before checking the render output if something external\n   * may be updating the state of the component somewhere.\n   *\n   * NOTE: no matter what instance this is called on, it will always update the root.\n   *\n   * @returns {ReactWrapper}\n   */\n  update() {\n    const root = this[ROOT];\n    if (this !== root) {\n      return root.update();\n    }\n    privateSetNodes(this, this[RENDERER].getNode());\n    this[LINKED_ROOTS].forEach((linkedRoot) => {\n      if (linkedRoot !== this[UPDATED_BY]) {\n        /* eslint-disable no-param-reassign */\n        // Only update a linked it root if it is not the originator of our update().\n        // This is needed to prevent infinite recursion when there is a bi-directional\n        // link between two roots.\n        linkedRoot[UPDATED_BY] = this;\n        try {\n          linkedRoot.update();\n        } finally {\n          linkedRoot[UPDATED_BY] = null;\n        }\n      }\n    });\n    return this;\n  }\n\n  /**\n   * A method that unmounts the component. This can be used to simulate a component going through\n   * and unmount/mount lifecycle.\n   *\n   * @returns {ReactWrapper}\n   */\n  unmount() {\n    if (this[ROOT] !== this) {\n      throw new Error('ReactWrapper::unmount() can only be called on the root');\n    }\n    this.single('unmount', () => {\n      this[RENDERER].unmount();\n      this.update();\n    });\n    return this;\n  }\n\n  /**\n   * A method that re-mounts the component, if it is not currently mounted.\n   * This can be used to simulate a component going through\n   * an unmount/mount lifecycle.\n   *\n   * @returns {ReactWrapper}\n   */\n  mount() {\n    if (this[ROOT] !== this) {\n      throw new Error('ReactWrapper::mount() can only be called on the root');\n    }\n    this[RENDERER].render(this[UNRENDERED], this[OPTIONS].context, () => this.update());\n    return this;\n  }\n\n  /**\n   * A method that sets the props of the root component, and re-renders. Useful for when you are\n   * wanting to test how the component behaves over time with changing props. Calling this, for\n   * instance, will call the `componentWillReceiveProps` lifecycle method.\n   *\n   * Similar to `setState`, this method accepts a props object and will merge it in with the already\n   * existing props.\n   *\n   * NOTE: can only be called on a wrapper instance that is also the root instance.\n   *\n   * @param {Object} props object\n   * @param {Function} cb - callback function\n   * @returns {ReactWrapper}\n   */\n  setProps(props, callback = undefined) {\n    if (this[ROOT] !== this) {\n      throw new Error('ReactWrapper::setProps() can only be called on the root');\n    }\n    if (arguments.length > 1 && typeof callback !== 'function') {\n      throw new TypeError('ReactWrapper::setProps() expects a function as its second argument');\n    }\n    const adapter = getAdapter(this[OPTIONS]);\n    this[UNRENDERED] = cloneElement(adapter, this[UNRENDERED], props);\n    this[RENDERER].render(this[UNRENDERED], null, () => {\n      this.update();\n      if (callback) {\n        callback();\n      }\n    });\n    return this;\n  }\n\n  /**\n   * A method to invoke `setState` on the root component instance similar to how you might in the\n   * definition of the component, and re-renders.  This method is useful for testing your component\n   * in hard to achieve states, however should be used sparingly. If possible, you should utilize\n   * your component's external API in order to get it into whatever state you want to test, in order\n   * to be as accurate of a test as possible. This is not always practical, however.\n   *\n   * NOTE: can only be called on a wrapper instance that is also the root instance.\n   *\n   * @param {Object} state to merge\n   * @param {Function} cb - callback function\n   * @returns {ReactWrapper}\n   */\n  setState(state, callback = undefined) {\n    if (this.instance() === null || this.getNodeInternal().nodeType !== 'class') {\n      throw new Error('ReactWrapper::setState() can only be called on class components');\n    }\n    if (arguments.length > 1 && typeof callback !== 'function') {\n      throw new TypeError('ReactWrapper::setState() expects a function as its second argument');\n    }\n    this.instance().setState(state, () => {\n      this.update();\n      if (callback) {\n        const adapter = getAdapter(this[OPTIONS]);\n        const instance = this.instance();\n        if (adapter.invokeSetStateCallback) {\n          adapter.invokeSetStateCallback(instance, callback);\n        } else {\n          callback.call(instance);\n        }\n      }\n    });\n    return this;\n  }\n\n  /**\n   * A method that sets the context of the root component, and re-renders. Useful for when you are\n   * wanting to test how the component behaves over time with changing contexts.\n   *\n   * NOTE: can only be called on a wrapper instance that is also the root instance.\n   *\n   * @param {Object} context object\n   * @returns {ReactWrapper}\n   */\n  setContext(context) {\n    if (this[ROOT] !== this) {\n      throw new Error('ReactWrapper::setContext() can only be called on the root');\n    }\n    if (!this[OPTIONS].context) {\n      throw new Error('ReactWrapper::setContext() can only be called on a wrapper that was originally passed a context option');\n    }\n    this[RENDERER].render(this[UNRENDERED], context, () => this.update());\n    return this;\n  }\n\n  /**\n   * Whether or not a given react element exists in the mount render tree.\n   *\n   * Example:\n   * ```\n   * const wrapper = mount(<MyComponent />);\n   * expect(wrapper.contains(<div className=\"foo bar\" />)).to.equal(true);\n   * ```\n   *\n   * @param {ReactElement|Array<ReactElement>} nodeOrNodes\n   * @returns {Boolean}\n   */\n  contains(nodeOrNodes) {\n    const adapter = getAdapter(this[OPTIONS]);\n\n    const predicate = Array.isArray(nodeOrNodes)\n      ? (other) => containsChildrenSubArray(\n        nodeEqual,\n        other,\n        nodeOrNodes.map((node) => adapter.elementToNode(node)),\n      )\n      : (other) => nodeEqual(adapter.elementToNode(nodeOrNodes), other);\n\n    return findWhereUnwrapped(this, predicate).length > 0;\n  }\n\n  /**\n   * Whether or not a given react element exists in the current render tree.\n   * It will determine if one of the wrappers element \"looks like\" the expected\n   * element by checking if all props of the expected element are present\n   * on the wrappers element and equals to each other.\n   *\n   * Example:\n   * ```\n   * // MyComponent outputs <div><div class=\"foo\">Hello</div></div>\n   * const wrapper = mount(<MyComponent />);\n   * expect(wrapper.containsMatchingElement(<div>Hello</div>)).to.equal(true);\n   * ```\n   *\n   * @param {ReactElement} node\n   * @returns {Boolean}\n   */\n  containsMatchingElement(node) {\n    const rstNode = getAdapter(this[OPTIONS]).elementToNode(node);\n    const predicate = (other) => nodeMatches(rstNode, other, (a, b) => a <= b);\n    return findWhereUnwrapped(this, predicate).length > 0;\n  }\n\n  /**\n   * Whether or not all the given react elements exist in the current render tree.\n   * It will determine if one of the wrappers element \"looks like\" the expected\n   * element by checking if all props of the expected element are present\n   * on the wrappers element and equals to each other.\n   *\n   * Example:\n   * ```\n   * const wrapper = mount(<MyComponent />);\n   * expect(wrapper.containsAllMatchingElements([\n   *   <div>Hello</div>,\n   *   <div>Goodbye</div>,\n   * ])).to.equal(true);\n   * ```\n   *\n   * @param {Array<ReactElement>} nodes\n   * @returns {Boolean}\n   */\n  containsAllMatchingElements(nodes) {\n    if (!Array.isArray(nodes)) {\n      throw new TypeError('nodes should be an Array');\n    }\n\n    return nodes.every((node) => this.containsMatchingElement(node));\n  }\n\n  /**\n   * Whether or not one of the given react elements exists in the current render tree.\n   * It will determine if one of the wrappers element \"looks like\" the expected\n   * element by checking if all props of the expected element are present\n   * on the wrappers element and equals to each other.\n   *\n   * Example:\n   * ```\n   * const wrapper = mount(<MyComponent />);\n   * expect(wrapper.containsAnyMatchingElements([\n   *   <div>Hello</div>,\n   *   <div>Goodbye</div>,\n   * ])).to.equal(true);\n   * ```\n   *\n   * @param {Array<ReactElement>} nodes\n   * @returns {Boolean}\n   */\n  containsAnyMatchingElements(nodes) {\n    return Array.isArray(nodes) && nodes.some((node) => this.containsMatchingElement(node));\n  }\n\n  /**\n   * Whether or not a given react element exists in the render tree.\n   *\n   * Example:\n   * ```\n   * const wrapper = mount(<MyComponent />);\n   * expect(wrapper.contains(<div className=\"foo bar\" />)).to.equal(true);\n   * ```\n   *\n   * @param {ReactElement} node\n   * @returns {Boolean}\n   */\n  equals(node) {\n    return this.single('equals', () => nodeEqual(this.getNodeInternal(), node));\n  }\n\n  /**\n   * Whether or not a given react element matches the render tree.\n   * Match is based on the expected element and not on wrapper root node.\n   * It will determine if the wrapper root node \"looks like\" the expected\n   * element by checking if all props of the expected element are present\n   * on the wrapper root node and equals to each other.\n   *\n   * Example:\n   * ```\n   * // MyComponent outputs <div class=\"foo\">Hello</div>\n   * const wrapper = mount(<MyComponent />);\n   * expect(wrapper.matchesElement(<div>Hello</div>)).to.equal(true);\n   * ```\n   *\n   * @param {ReactElement} node\n   * @returns {Boolean}\n   */\n  matchesElement(node) {\n    return this.single('matchesElement', () => {\n      const adapter = getAdapter(this[OPTIONS]);\n      const rstNode = adapter.elementToNode(node);\n      return nodeMatches(rstNode, this.getNodeInternal(), (a, b) => a <= b);\n    });\n  }\n\n  /**\n   * Finds every node in the render tree of the current wrapper that matches the provided selector.\n   *\n   * @param {EnzymeSelector} selector\n   * @returns {ReactWrapper}\n   */\n  find(selector) {\n    return this.wrap(reduceTreesBySelector(selector, this.getNodesInternal()));\n  }\n\n  /**\n   * Returns whether or not current node matches a provided selector.\n   *\n   * NOTE: can only be called on a wrapper of a single node.\n   *\n   * @param {EnzymeSelector} selector\n   * @returns {boolean}\n   */\n  is(selector) {\n    const predicate = buildPredicate(selector);\n    return this.single('is', (n) => predicate(n));\n  }\n\n  /**\n   * Returns true if the component rendered nothing, i.e., null or false.\n   *\n   * @returns {boolean}\n   */\n  isEmptyRender() {\n    const nodes = this.getNodeInternal();\n\n    return renderedDive(nodes);\n  }\n\n  /**\n   * Returns a new wrapper instance with only the nodes of the current wrapper instance that match\n   * the provided predicate function.\n   *\n   * @param {Function} predicate\n   * @returns {ReactWrapper}\n   */\n  filterWhere(predicate) {\n    return filterWhereUnwrapped(this, (n) => predicate(this.wrap(n)));\n  }\n\n  /**\n   * Returns a new wrapper instance with only the nodes of the current wrapper instance that match\n   * the provided selector.\n   *\n   * @param {EnzymeSelector} selector\n   * @returns {ReactWrapper}\n   */\n  filter(selector) {\n    const predicate = buildPredicate(selector);\n    return filterWhereUnwrapped(this, predicate);\n  }\n\n  /**\n   * Returns a new wrapper instance with only the nodes of the current wrapper that did not match\n   * the provided selector. Essentially the inverse of `filter`.\n   *\n   * @param {EnzymeSelector} selector\n   * @returns {ReactWrapper}\n   */\n  not(selector) {\n    const predicate = buildPredicate(selector);\n    return filterWhereUnwrapped(this, (n) => !predicate(n));\n  }\n\n  /**\n   * Returns a string of the rendered text of the current render tree.  This function should be\n   * looked at with skepticism if being used to test what the actual HTML output of the component\n   * will be. If that is what you would like to test, use enzyme's `render` function instead.\n   *\n   * NOTE: can only be called on a wrapper of a single node.\n   *\n   * @returns {String}\n   */\n  text() {\n    const adapter = getAdapter(this[OPTIONS]);\n    return this.single('text', (n) => getTextFromHostNodes(n, adapter));\n  }\n\n  /**\n   * Returns the HTML of the node.\n   *\n   * NOTE: can only be called on a wrapper of a single node.\n   *\n   * @returns {String}\n   */\n  html() {\n    const adapter = getAdapter(this[OPTIONS]);\n    return this.single('html', (n) => getHTMLFromHostNodes(n, adapter));\n  }\n\n  /**\n   * Returns the current node rendered to HTML and wrapped in a CheerioWrapper.\n   *\n   * NOTE: can only be called on a wrapper of a single node.\n   *\n   * @returns {CheerioWrapper}\n   */\n  render() {\n    const html = this.html();\n    return loadCheerioRoot(html);\n  }\n\n  /**\n   * Used to simulate events. Pass an eventname and (optionally) event arguments. This method of\n   * testing events should be met with some skepticism.\n   *\n   * @param {String} event\n   * @param {Object} mock (optional)\n   * @returns {ReactWrapper}\n   */\n  simulate(event, mock = {}) {\n    return this.single('simulate', (n) => {\n      this[RENDERER].simulateEvent(n, event, mock);\n      this[ROOT].update();\n      return this;\n    });\n  }\n\n  /**\n   * Used to simulate throwing a rendering error. Pass an error to throw.\n   *\n   * @param {String} error\n   * @returns {ReactWrapper}\n   */\n  simulateError(error) {\n    if (this[ROOT] === this) {\n      throw new Error('ReactWrapper::simulateError() may not be called on the root');\n    }\n\n    return this.single('simulateError', (thisNode) => {\n      if (thisNode.nodeType === 'host') {\n        throw new Error('ReactWrapper::simulateError() can only be called on custom components');\n      }\n\n      const renderer = this[RENDERER];\n      if (typeof renderer.simulateError !== 'function') {\n        throw new TypeError('your adapter does not support `simulateError`. Try upgrading it!');\n      }\n\n      const rootNode = getRootNodeInternal(this);\n      const nodeHierarchy = [thisNode].concat(nodeParents(this, thisNode));\n      renderer.simulateError(nodeHierarchy, rootNode, error);\n\n      this[ROOT].update();\n      return this;\n    });\n  }\n\n  /**\n   * Returns the props hash for the root node of the wrapper.\n   *\n   * NOTE: can only be called on a wrapper of a single node.\n   *\n   * @returns {Object}\n   */\n  props() {\n    return this.single('props', propsOfNode);\n  }\n\n  /**\n   * Returns the state hash for the root node of the wrapper. Optionally pass in a prop name and it\n   * will return just that value.\n   *\n   * NOTE: can only be called on a wrapper of a single node.\n   *\n   * @param {String} name (optional)\n   * @returns {*}\n   */\n  state(name) {\n    const thisNode = this[ROOT] === this ? this[RENDERER].getNode() : this.getNodeInternal();\n    if (this.instance() === null || thisNode.nodeType !== 'class') {\n      throw new Error('ReactWrapper::state() can only be called on class components');\n    }\n    const _state = this.single('state', () => this.instance().state);\n    if (typeof name !== 'undefined') {\n      if (_state == null) {\n        throw new TypeError(`ReactWrapper::state(\"${name}\") requires that \\`state\\` not be \\`null\\` or \\`undefined\\``);\n      }\n      return _state[name];\n    }\n    return _state;\n  }\n\n  /**\n   * Returns the context hash for the root node of the wrapper.\n   * Optionally pass in a prop name and it will return just that value.\n   *\n   * NOTE: can only be called on a wrapper of a single node.\n   *\n   * @param {String} name (optional)\n   * @returns {*}\n   */\n  context(name) {\n    if (this[ROOT] !== this) {\n      throw new Error('ReactWrapper::context() can only be called on the root');\n    }\n    const instance = this.single('context', () => this.instance());\n    if (instance === null) {\n      throw new Error('ReactWrapper::context() can only be called on components with instances');\n    }\n    const _context = instance.context;\n    if (typeof name !== 'undefined') {\n      return _context[name];\n    }\n    return _context;\n  }\n\n  /**\n   * Returns a new wrapper with all of the children of the current wrapper.\n   *\n   * @param {EnzymeSelector} [selector]\n   * @returns {ReactWrapper}\n   */\n  children(selector) {\n    const allChildren = this.flatMap((n) => childrenOfNode(n.getNodeInternal()));\n    return selector ? allChildren.filter(selector) : allChildren;\n  }\n\n  /**\n   * Returns a new wrapper with a specific child\n   *\n   * @param {Number} [index]\n   * @returns {ReactWrapper}\n   */\n  childAt(index) {\n    return this.single('childAt', () => this.children().at(index));\n  }\n\n  /**\n   * Returns a wrapper around all of the parents/ancestors of the wrapper. Does not include the node\n   * in the current wrapper.\n   *\n   * NOTE: can only be called on a wrapper of a single node.\n   *\n   * @param {EnzymeSelector} [selector]\n   * @returns {ReactWrapper}\n   */\n  parents(selector) {\n    return this.single('parents', (n) => {\n      const allParents = this.wrap(nodeParents(this, n));\n      return selector ? allParents.filter(selector) : allParents;\n    });\n  }\n\n  /**\n   * Returns a wrapper around the immediate parent of the current node.\n   *\n   * @returns {ReactWrapper}\n   */\n  parent() {\n    return this.flatMap((n) => [n.parents().get(0)]);\n  }\n\n  /**\n   *\n   * @param {EnzymeSelector} selector\n   * @returns {ReactWrapper}\n   */\n  closest(selector) {\n    if (this.is(selector)) {\n      return this;\n    }\n    const matchingAncestors = this.parents().filter(selector);\n    return matchingAncestors.length > 0 ? matchingAncestors.first() : this.findWhere(() => false);\n  }\n\n  /**\n   * Returns the value of  prop with the given name of the root node.\n   *\n   * @param {String} propName\n   * @returns {*}\n   */\n  prop(propName) {\n    return this.props()[propName];\n  }\n\n  /**\n   * Used to invoke a function prop.\n   * Will invoke an function prop and return its value.\n   *\n   * @param {String} propName\n   * @returns {Any}\n   */\n  invoke(propName) {\n    return this.single('invoke', () => {\n      const handler = this.prop(propName);\n      if (typeof handler !== 'function') {\n        throw new TypeError('ReactWrapper::invoke() requires the name of a prop whose value is a function');\n      }\n      return (...args) => {\n        const response = typeof this[RENDERER].wrapInvoke === 'function'\n          ? this[RENDERER].wrapInvoke(() => handler(...args))\n          : handler(...args);\n        this[ROOT].update();\n        return response;\n      };\n    });\n  }\n\n  /**\n   * Returns a wrapper of the node rendered by the provided render prop.\n   *\n   * @param {String} propName\n   * @returns {Function}\n   */\n  renderProp(propName) {\n    const adapter = getAdapter(this[OPTIONS]);\n    if (typeof adapter.wrap !== 'function') {\n      throw new RangeError('your adapter does not support `wrap`. Try upgrading it!');\n    }\n\n    return this.single('renderProp', (n) => {\n      if (n.nodeType === 'host') {\n        throw new TypeError('ReactWrapper::renderProp() can only be called on custom components');\n      }\n      if (typeof propName !== 'string') {\n        throw new TypeError('ReactWrapper::renderProp(): `propName` must be a string');\n      }\n      const props = this.props();\n      if (!has(props, propName)) {\n        throw new Error(`ReactWrapper::renderProp(): no prop called “${propName}“ found`);\n      }\n      const propValue = props[propName];\n      if (typeof propValue !== 'function') {\n        throw new TypeError(`ReactWrapper::renderProp(): expected prop “${propName}“ to contain a function, but it holds “${typeof propValue}“`);\n      }\n\n      return (...args) => {\n        const element = propValue(...args);\n        const wrapped = adapter.wrap(element);\n        return this.wrap(wrapped, null, this[OPTIONS]);\n      };\n    });\n  }\n\n  /**\n   * Returns the key assigned to the current node.\n   *\n   * @returns {String}\n   */\n  key() {\n    return this.single('key', (n) => (n.key === undefined ? null : n.key));\n  }\n\n  /**\n   * Returns the type of the root node of this wrapper. If it's a composite component, this will be\n   * the component constructor. If it's native DOM node, it will be a string.\n   *\n   * @returns {String|Function}\n   */\n  type() {\n    return this.single('type', (n) => typeOfNode(n));\n  }\n\n  /**\n   * Returns the name of the root node of this wrapper.\n   *\n   * In order of precedence => type.displayName -> type.name -> type.\n   *\n   * @returns {String}\n   */\n  name() {\n    const adapter = getAdapter(this[OPTIONS]);\n    return this.single('name', (n) => (\n      adapter.displayNameOfNode ? adapter.displayNameOfNode(n) : displayNameOfNode(n)\n    ));\n  }\n\n  /**\n   * Returns whether or not the current root node has the given class name or not.\n   *\n   * NOTE: can only be called on a wrapper of a single node.\n   *\n   * @param {String} className\n   * @returns {Boolean}\n   */\n  hasClass(className) {\n    if (typeof className === 'string' && className.indexOf('.') !== -1) {\n      // eslint-disable-next-line no-console\n      console.warn('It looks like you\\'re calling `ReactWrapper::hasClass()` with a CSS selector. hasClass() expects a class name, not a CSS selector.');\n    }\n    return this.single('hasClass', (n) => hasClassName(n, className));\n  }\n\n  /**\n   * Iterates through each node of the current wrapper and executes the provided function with a\n   * wrapper around the corresponding node passed in as the first argument.\n   *\n   * @param {Function} fn\n   * @returns {ReactWrapper}\n   */\n  forEach(fn) {\n    this.getNodesInternal().forEach((n, i) => fn.call(this, this.wrap(n), i));\n    return this;\n  }\n\n  /**\n   * Maps the current array of nodes to another array. Each node is passed in as a `ReactWrapper`\n   * to the map function.\n   *\n   * @param {Function} fn\n   * @returns {Array}\n   */\n  map(fn) {\n    return this.getNodesInternal().map((n, i) => fn.call(this, this.wrap(n), i));\n  }\n\n  /**\n   * Reduces the current array of nodes to another array.\n   * Each node is passed in as a `ShallowWrapper` to the reducer function.\n   *\n   * @param {Function} fn - the reducer function\n   * @param {*} initialValue - the initial value\n   * @returns {*}\n   */\n  reduce(fn, initialValue = undefined) {\n    if (arguments.length > 1) {\n      return this.getNodesInternal().reduce(\n        (accum, n, i) => fn.call(this, accum, this.wrap(n), i),\n        initialValue,\n      );\n    }\n    return this.getNodesInternal().reduce((accum, n, i) => fn.call(\n      this,\n      i === 1 ? this.wrap(accum) : accum,\n      this.wrap(n),\n      i,\n    ));\n  }\n\n  /**\n   * Reduces the current array of nodes to another array, from right to left. Each node is passed\n   * in as a `ShallowWrapper` to the reducer function.\n   *\n   * @param {Function} fn - the reducer function\n   * @param {*} initialValue - the initial value\n   * @returns {*}\n   */\n  reduceRight(fn, initialValue = undefined) {\n    if (arguments.length > 1) {\n      return this.getNodesInternal().reduceRight(\n        (accum, n, i) => fn.call(this, accum, this.wrap(n), i),\n        initialValue,\n      );\n    }\n    return this.getNodesInternal().reduceRight((accum, n, i) => fn.call(\n      this,\n      i === 1 ? this.wrap(accum) : accum,\n      this.wrap(n),\n      i,\n    ));\n  }\n\n  /**\n   * Returns a new wrapper with a subset of the nodes of the original wrapper, according to the\n   * rules of `Array#slice`.\n   *\n   * @param {Number} begin\n   * @param {Number} end\n   * @returns {ShallowWrapper}\n   */\n  slice(begin, end) {\n    return this.wrap(this.getNodesInternal().slice(begin, end));\n  }\n\n  /**\n   * Returns whether or not any of the nodes in the wrapper match the provided selector.\n   *\n   * @param {EnzymeSelector} selector\n   * @returns {Boolean}\n   */\n  some(selector) {\n    if (this[ROOT] === this) {\n      throw new Error('ReactWrapper::some() can not be called on the root');\n    }\n    const predicate = buildPredicate(selector);\n    return this.getNodesInternal().some(predicate);\n  }\n\n  /**\n   * Returns whether or not any of the nodes in the wrapper pass the provided predicate function.\n   *\n   * @param {Function} predicate\n   * @returns {Boolean}\n   */\n  someWhere(predicate) {\n    return this.getNodesInternal().some((n, i) => predicate.call(this, this.wrap(n), i));\n  }\n\n  /**\n   * Returns whether or not all of the nodes in the wrapper match the provided selector.\n   *\n   * @param {EnzymeSelector} selector\n   * @returns {Boolean}\n   */\n  every(selector) {\n    const predicate = buildPredicate(selector);\n    return this.getNodesInternal().every(predicate);\n  }\n\n  /**\n   * Returns whether or not any of the nodes in the wrapper pass the provided predicate function.\n   *\n   * @param {Function} predicate\n   * @returns {Boolean}\n   */\n  everyWhere(predicate) {\n    return this.getNodesInternal().every((n, i) => predicate.call(this, this.wrap(n), i));\n  }\n\n  /**\n   * Utility method used to create new wrappers with a mapping function that returns an array of\n   * nodes in response to a single node wrapper. The returned wrapper is a single wrapper around\n   * all of the mapped nodes flattened (and de-duplicated).\n   *\n   * @param {Function} fn\n   * @returns {ReactWrapper}\n   */\n  flatMap(fn) {\n    const nodes = this.getNodesInternal().map((n, i) => fn.call(this, this.wrap(n), i));\n    const flattened = flat(nodes, 1);\n    return this.wrap(flattened.filter(Boolean));\n  }\n\n  /**\n   * Finds all nodes in the current wrapper nodes' render trees that match the provided predicate\n   * function.\n   *\n   * @param {Function} predicate\n   * @returns {ReactWrapper}\n   */\n  findWhere(predicate) {\n    return findWhereUnwrapped(this, (n) => {\n      const node = this.wrap(n);\n      return node.length > 0 && predicate(node);\n    });\n  }\n\n  /**\n   * Returns the node at a given index of the current wrapper.\n   *\n   * @param {Number} index\n   * @returns {ReactElement}\n   */\n  get(index) {\n    return this.getElements()[index];\n  }\n\n  /**\n   * Returns a wrapper around the node at a given index of the current wrapper.\n   *\n   * @param {Number} index\n   * @returns {ReactWrapper}\n   */\n  at(index) {\n    const nodes = this.getNodesInternal();\n    if (index < nodes.length) {\n      return this.wrap(nodes[index]);\n    }\n    return this.wrap([]);\n  }\n\n  /**\n   * Returns a wrapper around the first node of the current wrapper.\n   *\n   * @returns {ReactWrapper}\n   */\n  first() {\n    return this.at(0);\n  }\n\n  /**\n   * Returns a wrapper around the last node of the current wrapper.\n   *\n   * @returns {ReactWrapper}\n   */\n  last() {\n    return this.at(this.length - 1);\n  }\n\n  /**\n   * Delegates to exists()\n   *\n   * @returns {boolean}\n   */\n  isEmpty() {\n    // eslint-disable-next-line no-console\n    console.warn('Enzyme::Deprecated method isEmpty() called, use exists() instead.');\n    return !this.exists();\n  }\n\n  /**\n   * Returns true if the current wrapper has nodes. False otherwise.\n   * If called with a selector it returns `.find(selector).exists()` instead.\n   *\n   * @param {EnzymeSelector} selector (optional)\n   * @returns {boolean}\n   */\n  exists(selector = null) {\n    return arguments.length > 0 ? this.find(selector).exists() : this.length > 0;\n  }\n\n  /**\n   * Utility method that throws an error if the current instance has a length other than one.\n   * This is primarily used to enforce that certain methods are only run on a wrapper when it is\n   * wrapping a single node.\n   *\n   * @param {Function} fn\n   * @returns {*}\n   */\n  single(name, fn) {\n    const fnName = typeof name === 'string' ? name : 'unknown';\n    const callback = typeof fn === 'function' ? fn : name;\n    if (this.length !== 1) {\n      throw new Error(`Method “${fnName}” is meant to be run on 1 node. ${this.length} found instead.`);\n    }\n    return callback.call(this, this.getNodeInternal());\n  }\n\n  /**\n   * Helpful utility method to create a new wrapper with the same root as the current wrapper, with\n   * any nodes passed in as the first parameter automatically wrapped.\n   *\n   * @param {ReactWrapper|ReactElement|Array<ReactElement>} node\n   * @returns {ReactWrapper}\n   */\n  wrap(node, root = this[ROOT], ...args) {\n    if (node instanceof ReactWrapper) {\n      return node;\n    }\n    return new ReactWrapper(node, root, ...args);\n  }\n\n  /**\n   * Returns an HTML-like string of the shallow render for debugging purposes.\n   *\n   * @param {Object} [options] - Property bag of additional options.\n   * @param {boolean} [options.ignoreProps] - if true, props are omitted from the string.\n   * @param {boolean} [options.verbose] - if true, arrays and objects to be verbosely printed.\n   * @returns {String}\n   */\n  debug(options = {}) {\n    return debugNodes(this.getNodesInternal(), options);\n  }\n\n  /**\n   * Invokes intercepter and returns itself. intercepter is called with itself.\n   * This is helpful when debugging nodes in method chains.\n   * @param fn\n   * @returns {ReactWrapper}\n   */\n  tap(intercepter) {\n    intercepter(this);\n    return this;\n  }\n\n  /**\n   * Detaches the react tree from the DOM. Runs `ReactDOM.unmountComponentAtNode()` under the hood.\n   *\n   * This method will most commonly be used as a \"cleanup\" method if you decide to use the\n   * `attachTo` option in `mount(node, options)`.\n   *\n   * The method is intentionally not \"fluent\" (in that it doesn't return `this`) because you should\n   * not be doing anything with this wrapper after this method is called.\n   */\n  detach() {\n    if (this[ROOT] !== this) {\n      throw new Error('ReactWrapper::detach() can only be called on the root');\n    }\n    if (!this[OPTIONS].attachTo) {\n      throw new Error('ReactWrapper::detach() can only be called on when the `attachTo` option was passed into `mount()`.');\n    }\n    this[RENDERER].unmount();\n  }\n\n  /**\n   * Strips out all the not host-nodes from the list of nodes\n   *\n   * This method is useful if you want to check for the presence of host nodes\n   * (actually rendered HTML elements) ignoring the React nodes.\n   */\n  hostNodes() {\n    return this.filterWhere((n) => typeof n.type() === 'string');\n  }\n}\n\n/**\n * A *special* \"root\" wrapper that represents the component passed as `wrappingComponent`.\n * It is linked to the primary root such that updates to it will update the primary,\n * and vice versa.\n *\n * @class WrappingComponentWrapper\n */\nclass WrappingComponentWrapper extends ReactWrapper {\n  /* eslint-disable class-methods-use-this */\n  constructor(root, renderer) {\n    super(renderer.getNode(), root);\n\n    privateSet(this, ROOT, this);\n    privateSet(this, RENDERER, renderer);\n    this[LINKED_ROOTS].push(root);\n  }\n\n  getWrappingComponent() {\n    throw new TypeError('ReactWrapper::getWrappingComponent() can only be called on the root');\n  }\n}\n\nif (ITERATOR_SYMBOL) {\n  Object.defineProperty(ReactWrapper.prototype, ITERATOR_SYMBOL, {\n    configurable: true,\n    value: function iterator() {\n      const iter = this[NODES][ITERATOR_SYMBOL]();\n      const adapter = getAdapter(this[OPTIONS]);\n      return {\n        [ITERATOR_SYMBOL]() { return this; },\n        next() {\n          const next = iter.next();\n          if (next.done) {\n            return { done: true };\n          }\n          return {\n            done: false,\n            value: adapter.nodeToElement(next.value),\n          };\n        },\n      };\n    },\n  });\n}\n\nfunction privateWarning(prop, extraMessage) {\n  Object.defineProperty(ReactWrapper.prototype, prop, {\n    get() {\n      throw new Error(`\n        Attempted to access ReactWrapper::${prop}, which was previously a private property on\n        Enzyme ReactWrapper instances, but is no longer and should not be relied upon.\n        ${extraMessage}\n      `);\n    },\n    enumerable: false,\n    configurable: false,\n  });\n}\n\nprivateWarning('node', 'Consider using the getElement() method instead.');\nprivateWarning('nodes', 'Consider using the getElements() method instead.');\nprivateWarning('renderer', '');\nprivateWarning('options', '');\nprivateWarning('complexSelector', '');\n\nexport default ReactWrapper;\n"]}
//# sourceMappingURL=ReactWrapper.js.map