'use strict';

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

var _get = function () {
  function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } }

  return get;
}();

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 _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 _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 _enzymeShallowEqual = require('enzyme-shallow-equal');

var _enzymeShallowEqual2 = _interopRequireDefault(_enzymeShallowEqual);

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 _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 _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }

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

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; }

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 SET_STATE = (0, _Utils.sym)('__setState__');
var ROOT_NODES = (0, _Utils.sym)('__rootNodes__');
var CHILD_CONTEXT = (0, _Utils.sym)('__childContext__');
var WRAPPING_COMPONENT = (0, _Utils.sym)('__wrappingComponent__');
var PRIMARY_WRAPPER = (0, _Utils.sym)('__primaryWrapper__');
var ROOT_FINDER = (0, _Utils.sym)('__rootFinder__');
var PROVIDER_VALUES = (0, _Utils.sym)('__providerValues__');

/**
 * Finds all nodes in the current wrapper nodes' render trees that match the provided predicate
 * function.
 *
 * @param {ShallowWrapper} wrapper
 * @param {Function} predicate
 * @param {Function} filter
 * @returns {ShallowWrapper}
 */
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 {ShallowWrapper} wrapper
 * @param {Function} predicate
 * @returns {ShallowWrapper}
 */
function filterWhereUnwrapped(wrapper, predicate) {
  return wrapper.wrap(wrapper.getNodesInternal().filter(predicate).filter(Boolean));
}

/**
 * Ensure options passed to ShallowWrapper are valid. Throws otherwise.
 * @param {Object} options
 */
function validateOptions(options) {
  var lifecycleExperimental = options.lifecycleExperimental,
      disableLifecycleMethods = options.disableLifecycleMethods,
      enableComponentDidUpdateOnSetState = options.enableComponentDidUpdateOnSetState,
      supportPrevContextArgumentOfComponentDidUpdate = options.supportPrevContextArgumentOfComponentDidUpdate,
      lifecycles = options.lifecycles;

  if (typeof lifecycleExperimental !== 'undefined' && typeof lifecycleExperimental !== 'boolean') {
    throw new Error('lifecycleExperimental must be either true or false if provided');
  }

  if (typeof disableLifecycleMethods !== 'undefined' && typeof disableLifecycleMethods !== 'boolean') {
    throw new Error('disableLifecycleMethods must be either true or false if provided');
  }

  if (lifecycleExperimental != null && disableLifecycleMethods != null && lifecycleExperimental === disableLifecycleMethods) {
    throw new Error('lifecycleExperimental and disableLifecycleMethods cannot be set to the same value');
  }

  if (typeof enableComponentDidUpdateOnSetState !== 'undefined' && lifecycles.componentDidUpdate && lifecycles.componentDidUpdate.onSetState !== enableComponentDidUpdateOnSetState) {
    throw new TypeError('the legacy enableComponentDidUpdateOnSetState option should be matched by `lifecycles: { componentDidUpdate: { onSetState: true } }`, for compatibility');
  }

  if (typeof supportPrevContextArgumentOfComponentDidUpdate !== 'undefined' && lifecycles.componentDidUpdate && lifecycles.componentDidUpdate.prevContext !== supportPrevContextArgumentOfComponentDidUpdate) {
    throw new TypeError('the legacy supportPrevContextArgumentOfComponentDidUpdate option should be matched by `lifecycles: { componentDidUpdate: { prevContext: true } }`, for compatibility');
  }
}

function getAdapterLifecycles(_ref) {
  var options = _ref.options;
  var _options$lifecycles = options.lifecycles,
      lifecycles = _options$lifecycles === undefined ? {} : _options$lifecycles,
      enableComponentDidUpdateOnSetState = options.enableComponentDidUpdateOnSetState,
      supportPrevContextArgumentOfComponentDidUpdate = options.supportPrevContextArgumentOfComponentDidUpdate;


  var hasLegacySetStateArg = typeof enableComponentDidUpdateOnSetState !== 'undefined';
  var hasLegacyPrevContextArg = typeof supportPrevContextArgumentOfComponentDidUpdate !== 'undefined';
  var componentDidUpdate = hasLegacySetStateArg || hasLegacyPrevContextArg ? (0, _object2['default'])({}, hasLegacySetStateArg && {
    onSetState: !!enableComponentDidUpdateOnSetState
  }, hasLegacyPrevContextArg && {
    prevContext: !!supportPrevContextArgumentOfComponentDidUpdate
  }) : null;
  var originalGDSFP = lifecycles.getDerivedStateFromProps;

  var getDerivedStateFromProps = originalGDSFP ? {
    hasShouldComponentUpdateBug: !!originalGDSFP.hasShouldComponentUpdateBug
  } : false;

  return (0, _object2['default'])({}, lifecycles, {
    setState: (0, _object2['default'])({}, lifecycles.setState),
    getChildContext: (0, _object2['default'])({
      calledByRenderer: true
    }, lifecycles.getChildContext)
  }, componentDidUpdate && { componentDidUpdate: componentDidUpdate }, {
    getDerivedStateFromProps: getDerivedStateFromProps
  });
}

function getRootNode(node) {
  if (node.nodeType === 'host') {
    return node;
  }
  return node.rendered;
}

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 (!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);
}

function pureComponentShouldComponentUpdate(prevProps, props, prevState, state) {
  return !(0, _enzymeShallowEqual2['default'])(prevProps, props) || !(0, _enzymeShallowEqual2['default'])(prevState, state);
}

function isPureComponent(instance) {
  return instance && instance.isPureReactComponent;
}

function getChildContext(node, hierarchy, renderer) {
  var instance = node.instance,
      Component = node.type;

  var componentName = (0, _Utils.displayNameOfNode)(node);
  // Warn like react if childContextTypes is not defined:
  // https://github.com/facebook/react/blob/1454a8be03794f5e0b23a7e7696cbbbdcf8b0f5d/packages/react-dom/src/server/ReactPartialRenderer.js#L639-L646
  if (_typeof(Component.childContextTypes) !== 'object') {
    // eslint-disable-next-line no-console
    console.warn(String(componentName) + '.getChildContext(): childContextTypes must be defined in order to use getChildContext().');
    return {};
  }
  // Check childContextTypes like react:
  // https://github.com/facebook/react/blob/1454a8be03794f5e0b23a7e7696cbbbdcf8b0f5d/packages/react-dom/src/server/ReactPartialRenderer.js#L630-L637
  var childContext = instance.getChildContext();
  Object.keys(childContext).forEach(function (key) {
    if (!(key in Component.childContextTypes)) {
      throw new Error(String(componentName) + '.getChildContext(): key "' + String(key) + '" is not defined in childContextTypes.');
    }
  });
  if (typeof renderer.checkPropTypes === 'function') {
    renderer.checkPropTypes(Component.childContextTypes, childContext, 'child context', hierarchy);
  }
  return childContext;
}

function spyOnGetChildContextInitialRender(nodes, adapter) {
  if (!(0, _Utils.isCustomComponentElement)(nodes, adapter) || !nodes.type.prototype || typeof nodes.type.prototype.getChildContext !== 'function') {
    return null;
  }

  return (0, _Utils.spyMethod)(nodes.type.prototype, 'getChildContext');
}

function privateSetChildContext(adapter, wrapper, instance, renderedNode, getChildContextSpy) {
  var renderer = wrapper[RENDERER];
  // We only support parent-based context.
  if (adapter.options.legacyContextMode !== 'parent') {
    return;
  }
  if (getChildContextSpy) {
    (0, _Utils.privateSet)(wrapper, CHILD_CONTEXT, getChildContextSpy.getLastReturnValue());
    getChildContextSpy.restore();
  } else if (typeof instance.getChildContext === 'function') {
    // If there's no spy but getChildContext is a function, that means our renderer
    // is not going to call it for us, so we need to call it ourselves.
    var nodeHierarchy = [wrapper[NODE]].concat(nodeParents(wrapper, wrapper[NODE]));
    var childContext = getChildContext(renderedNode, nodeHierarchy, renderer);
    (0, _Utils.privateSet)(wrapper, CHILD_CONTEXT, childContext);
  } else {
    (0, _Utils.privateSet)(wrapper, CHILD_CONTEXT, null);
  }
}

function mockSCUIfgDSFPReturnNonNull(node, state) {
  var getDerivedStateFromProps = node.type.getDerivedStateFromProps;


  if (typeof getDerivedStateFromProps === 'function') {
    // we try to fix a React shallow renderer bug here.
    // (facebook/react#14607, which has been fixed in react 16.8):
    // when gDSFP return derived state, it will set instance state in shallow renderer before SCU,
    // this will cause `this.state` in sCU be the updated state, which is wrong behavior.
    // so we have to wrap sCU to pass the old state to original sCU.
    var instance = node.instance;

    var _spyMethod = (0, _Utils.spyMethod)(instance, 'shouldComponentUpdate', function (originalSCU) {
      return function () {
        function shouldComponentUpdate() {
          instance.state = state;

          for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
            args[_key] = arguments[_key];
          }

          var sCUResult = originalSCU.apply(instance, args);
          var nextState = args[1];

          instance.state = nextState;
          restore();
          return sCUResult;
        }

        return shouldComponentUpdate;
      }();
    }),
        restore = _spyMethod.restore;
  }
}

/**
 * Recursively dive()s every custom component in a wrapper until
 * the target component is found.
 *
 * @param {ShallowWrapper} wrapper A ShallowWrapper to search
 * @param {ComponentType} target A react custom component that, when found, will end recursion
 * @param {Adapter} adapter An Enzyme adapter
 * @returns {ShallowWrapper|undefined} A ShallowWrapper for the target, or
 *  undefined if it can't be found
 */
function deepRender(wrapper, target, adapter) {
  var node = wrapper[NODE];
  var element = node && adapter.nodeToElement(node);
  if (wrapper.type() === target) {
    return wrapper.dive();
  }
  if (element && (0, _Utils.isCustomComponentElement)(element, adapter)) {
    return deepRender(wrapper.dive(), target, adapter);
  }
  var children = wrapper.children();
  for (var i = 0; i < children.length; i += 1) {
    var found = deepRender(children.at(i), target, adapter);
    if (typeof found !== 'undefined') {
      return found;
    }
  }
  return undefined;
}

/**
 * Deep-renders the `wrappingComponent` and returns the context that should
 * be accessible to the primary wrapper.
 *
 * @param {WrappingComponentWrapper} wrapper The `WrappingComponentWrapper` for a
 *  `wrappingComponent`
 * @param {Adapter} adapter An Enzyme adapter
 * @returns {object} An object containing an object of legacy context values and a Map of
 *  `createContext()` Provider values.
 */
function getContextFromWrappingComponent(wrapper, adapter) {
  var rootFinder = deepRender(wrapper, wrapper[ROOT_FINDER], adapter);
  if (!rootFinder) {
    throw new Error('`wrappingComponent` must render its children!');
  }
  return {
    legacyContext: rootFinder[OPTIONS].context,
    providerValues: rootFinder[PROVIDER_VALUES]
  };
}

/**
 * Makes options specifically for `ShallowWrapper`. Most of the logic here is around rendering
 * a `wrappingComponent` (if one was provided) and adding the child context of that component
 * to `options.context`.
 *
 * @param {ReactElement} nodes the nodes passed to `ShallowWrapper`
 * @param {ShallowWrapper} root this `ShallowWrapper`'s parent. If this is passed, options are
 *  not transformed.
 * @param {*} passedOptions the options passed to `ShallowWrapper`.
 * @param {*} wrapper the `ShallowWrapper` itself
 * @returns {Object} the decorated and transformed options
 */
function makeShallowOptions(nodes, root, passedOptions, wrapper) {
  var options = (0, _Utils.makeOptions)(passedOptions);
  var adapter = (0, _getAdapter2['default'])(passedOptions);
  (0, _Utils.privateSet)(options, PROVIDER_VALUES, passedOptions[PROVIDER_VALUES]);
  if (root || !(0, _Utils.isCustomComponent)(options.wrappingComponent, adapter)) {
    return options;
  }
  if (typeof adapter.wrapWithWrappingComponent !== 'function') {
    throw new TypeError('your adapter does not support `wrappingComponent`. Try upgrading it!');
  }

  var _adapter$wrapWithWrap = adapter.wrapWithWrappingComponent(nodes, options),
      wrappedNode = _adapter$wrapWithWrap.node,
      RootFinder = _adapter$wrapWithWrap.RootFinder;
  // eslint-disable-next-line no-use-before-define


  var wrappingComponent = new WrappingComponentWrapper(wrappedNode, wrapper, RootFinder);

  var _getContextFromWrappi = getContextFromWrappingComponent(wrappingComponent, adapter),
      wrappingComponentLegacyContext = _getContextFromWrappi.legacyContext,
      wrappingComponentProviderValues = _getContextFromWrappi.providerValues;

  (0, _Utils.privateSet)(wrapper, WRAPPING_COMPONENT, wrappingComponent);
  return (0, _object2['default'])({}, options, _defineProperty({
    context: (0, _object2['default'])({}, options.context, wrappingComponentLegacyContext)
  }, PROVIDER_VALUES, wrappingComponentProviderValues));
}

function makeInheritedChildOptions(wrapper) {
  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

  var childOptions = (0, _object2['default'])({}, wrapper[OPTIONS], options, {
    context: options.context || (0, _object2['default'])({}, wrapper[OPTIONS].context, wrapper[ROOT][CHILD_CONTEXT])
  });
  (0, _Utils.privateSet)(childOptions, PROVIDER_VALUES, wrapper[ROOT][PROVIDER_VALUES]);
  return childOptions;
}

/**
 * @class ShallowWrapper
 */

var ShallowWrapper = function () {
  function ShallowWrapper(nodes, root) {
    var _this = this;

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

    _classCallCheck(this, ShallowWrapper);

    validateOptions(passedOptions);

    var options = makeShallowOptions(nodes, root, passedOptions, this);
    var adapter = (0, _getAdapter2['default'])(options);
    var lifecycles = getAdapterLifecycles(adapter);

    // mounting a ShallowRender component
    if (!root) {
      if (!adapter.isValidElement(nodes)) {
        throw new TypeError('ShallowWrapper can only wrap valid elements');
      }

      var getChildContextSpy = lifecycles.getChildContext.calledByRenderer ? spyOnGetChildContextInitialRender(nodes, adapter) : null;
      (0, _Utils.privateSet)(this, ROOT, this);
      (0, _Utils.privateSet)(this, UNRENDERED, nodes);
      var renderer = adapter.createRenderer((0, _object2['default'])({ mode: 'shallow' }, options));
      (0, _Utils.privateSet)(this, RENDERER, renderer);
      var providerValues = new Map(options[PROVIDER_VALUES] || []);
      this[RENDERER].render(nodes, options.context, { providerValues: providerValues });
      var renderedNode = this[RENDERER].getNode();
      privateSetNodes(this, getRootNode(renderedNode));
      (0, _Utils.privateSet)(this, OPTIONS, options);
      (0, _Utils.privateSet)(this, PROVIDER_VALUES, providerValues);

      var instance = renderedNode.instance;

      if (instance && !options.disableLifecycleMethods) {
        // Ensure to call componentDidUpdate when instance.setState is called
        if (lifecycles.componentDidUpdate.onSetState && !instance[SET_STATE]) {
          (0, _Utils.privateSet)(instance, SET_STATE, instance.setState);
          instance.setState = function (updater) {
            var callback = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : undefined;
            return _this.setState.apply(_this, _toConsumableArray(callback == null ? [updater] : [updater, callback]));
          };
        }

        if (typeof instance.componentDidMount === 'function') {
          this[RENDERER].batchedUpdates(function () {
            instance.componentDidMount();
          });
        }
        privateSetChildContext(adapter, this, instance, renderedNode, getChildContextSpy);
      }
      // creating a child component through enzyme's ShallowWrapper APIs.
    } else {
      (0, _Utils.privateSet)(this, ROOT, root);
      (0, _Utils.privateSet)(this, UNRENDERED, null);
      (0, _Utils.privateSet)(this, RENDERER, root[RENDERER]);
      privateSetNodes(this, nodes);
      (0, _Utils.privateSet)(this, OPTIONS, root[OPTIONS]);
      (0, _Utils.privateSet)(this, ROOT_NODES, root[NODES]);
      (0, _Utils.privateSet)(this, PROVIDER_VALUES, null);
    }
  }

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


  _createClass(ShallowWrapper, [{
    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('ShallowWrapper::getNode() can only be called when wrapping one node');
        }
        if (this[ROOT] === this) {
          this.update();
        }
        return this[NODE];
      }

      return getNodeInternal;
    }()

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

  }, {
    key: 'getNodesInternal',
    value: function () {
      function getNodesInternal() {
        if (this[ROOT] === this && this.length === 1) {
          this.update();
        }
        return this[NODES];
      }

      return getNodesInternal;
    }()

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

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

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

      return getElement;
    }()

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

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

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

      return getElements;
    }()

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

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

      return getNode;
    }()

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

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

      return getNodes;
    }()

    /**
     * Gets the instance of the component being rendered as the root node passed into `shallow()`.
     *
     * NOTE: can only be called on a wrapper instance that is also the root instance.
     *
     * Example:
     * ```
     * const wrapper = shallow(<MyComponent />);
     * const inst = wrapper.instance();
     * expect(inst).to.be.instanceOf(MyComponent);
     * ```
     * @returns {ReactComponent}
     */

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

      return instance;
    }()

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

  }, {
    key: 'getWrappingComponent',
    value: function () {
      function getWrappingComponent() {
        if (this[ROOT] !== this) {
          throw new Error('ShallowWrapper::getWrappingComponent() can only be called on the root');
        }
        if (!this[OPTIONS].wrappingComponent) {
          throw new Error('ShallowWrapper::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: can only be called on a wrapper instance that is also the root instance.
     *
     * @returns {ShallowWrapper}
     */

  }, {
    key: 'update',
    value: function () {
      function update() {
        if (this[ROOT] !== this) {
          throw new Error('ShallowWrapper::update() can only be called on the root');
        }
        if (this.length !== 1) {
          throw new Error('ShallowWrapper::update() can only be called when wrapping one node');
        }
        privateSetNodes(this, getRootNode(this[RENDERER].getNode()));
        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 {ShallowWrapper}
     */

  }, {
    key: 'unmount',
    value: function () {
      function unmount() {
        this[RENDERER].unmount();
        if (this[ROOT][WRAPPING_COMPONENT]) {
          this[ROOT][WRAPPING_COMPONENT].unmount();
        }
        return this;
      }

      return unmount;
    }()

    /**
     * A method is for re-render with new props and context.
     * This calls componentDidUpdate method if disableLifecycleMethods is not enabled.
     *
     * NOTE: can only be called on a wrapper instance that is also the root instance.
     *
     * @param {Object} props
     * @param {Object} context
     * @returns {ShallowWrapper}
     */

  }, {
    key: 'rerender',
    value: function () {
      function rerender(props, context) {
        var _this4 = this;

        var adapter = (0, _getAdapter2['default'])(this[OPTIONS]);
        this.single('rerender', function () {
          (0, _Utils.withSetStateAllowed)(function () {
            // NOTE(lmr): In react 16, instances will be null for SFCs, but
            // rerendering with props/context is still a valid thing to do. In
            // this case, state will be undefined, but props/context will exist.
            var node = _this4[RENDERER].getNode();
            var instance = node.instance || {};
            var type = node.type || {};
            var state = instance.state;

            var prevProps = instance.props || _this4[UNRENDERED].props;
            var prevContext = instance.context || _this4[OPTIONS].context;
            var nextContext = context || prevContext;
            if (context) {
              _this4[OPTIONS] = (0, _object2['default'])({}, _this4[OPTIONS], { context: nextContext });
            }
            _this4[RENDERER].batchedUpdates(function () {
              // When shouldComponentUpdate returns false we shouldn't call componentDidUpdate.
              // so we spy shouldComponentUpdate to get the result.
              var lifecycles = getAdapterLifecycles(adapter);
              var shouldRender = true;
              var shouldComponentUpdateSpy = void 0;
              var getChildContextSpy = void 0;
              if (!_this4[OPTIONS].disableLifecycleMethods && instance) {
                if (typeof instance.shouldComponentUpdate === 'function') {
                  var gDSFP = lifecycles.getDerivedStateFromProps;

                  if (gDSFP && gDSFP.hasShouldComponentUpdateBug) {
                    mockSCUIfgDSFPReturnNonNull(node, state);
                  }
                  shouldComponentUpdateSpy = (0, _Utils.spyMethod)(instance, 'shouldComponentUpdate');
                }
                if (lifecycles.getChildContext.calledByRenderer && typeof instance.getChildContext === 'function') {
                  getChildContextSpy = (0, _Utils.spyMethod)(instance, 'getChildContext');
                }
              }
              if (!shouldComponentUpdateSpy && isPureComponent(instance)) {
                shouldRender = pureComponentShouldComponentUpdate(prevProps, props, state, instance.state);
              }
              if (props) _this4[UNRENDERED] = (0, _Utils.cloneElement)(adapter, _this4[UNRENDERED], props);
              _this4[RENDERER].render(_this4[UNRENDERED], nextContext, {
                providerValues: _this4[PROVIDER_VALUES]
              });
              if (shouldComponentUpdateSpy) {
                shouldRender = shouldComponentUpdateSpy.getLastReturnValue();
                shouldComponentUpdateSpy.restore();
              }
              if (shouldRender && !_this4[OPTIONS].disableLifecycleMethods && instance) {
                privateSetChildContext(adapter, _this4, instance, node, getChildContextSpy);
                if (lifecycles.getSnapshotBeforeUpdate) {
                  var snapshot = void 0;
                  if (typeof instance.getSnapshotBeforeUpdate === 'function') {
                    snapshot = instance.getSnapshotBeforeUpdate(prevProps, state);
                  }
                  if (lifecycles.componentDidUpdate && typeof instance.componentDidUpdate === 'function' && (!state || (0, _enzymeShallowEqual2['default'])(state, _this4.instance().state) || typeof type.getDerivedStateFromProps === 'function')) {
                    instance.componentDidUpdate(prevProps, state, snapshot);
                  }
                } else if (lifecycles.componentDidUpdate && typeof instance.componentDidUpdate === 'function') {
                  if (lifecycles.componentDidUpdate.prevContext) {
                    instance.componentDidUpdate(prevProps, state, prevContext);
                  } else if (!state || (0, _enzymeShallowEqual2['default'])(_this4.instance().state, state)) {
                    instance.componentDidUpdate(prevProps, state);
                  }
                }
                // If it doesn't need to rerender, update only its props.
              } else if (!(0, _enzymeShallowEqual2['default'])(props, instance.props)) {
                instance.props = (Object.freeze || Object)((0, _object2['default'])({}, instance.props, props));
              }
              _this4.update();
            });
          });
        });
        return this;
      }

      return rerender;
    }()

    /**
     * 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 {ShallowWrapper}
     */

  }, {
    key: 'setProps',
    value: function () {
      function setProps(props) {
        var callback = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : undefined;

        if (this[ROOT] !== this) {
          throw new Error('ShallowWrapper::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');
        }
        this.rerender(props);
        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 {ShallowWrapper}
     */

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

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

        if (this[ROOT] !== this) {
          throw new Error('ShallowWrapper::setState() can only be called on the root');
        }
        if (this.instance() === null || this[RENDERER].getNode().nodeType !== 'class') {
          throw new Error('ShallowWrapper::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.single('setState', function () {
          (0, _Utils.withSetStateAllowed)(function () {
            var adapter = (0, _getAdapter2['default'])(_this5[OPTIONS]);

            var lifecycles = getAdapterLifecycles(adapter);

            var node = _this5[RENDERER].getNode();
            var instance = node.instance;

            var prevProps = instance.props;
            var prevState = instance.state;
            var prevContext = instance.context;

            var statePayload = typeof state === 'function' ? state.call(instance, prevState, prevProps) : state;

            // returning null or undefined prevents the update in React 16+
            // https://github.com/facebook/react/pull/12756
            var maybeHasUpdate = !lifecycles.setState.skipsComponentDidUpdateOnNullish || statePayload != null;

            // When shouldComponentUpdate returns false we shouldn't call componentDidUpdate.
            // so we spy shouldComponentUpdate to get the result.
            var shouldComponentUpdateSpy = void 0;
            var getChildContextSpy = void 0;
            var shouldRender = true;
            if (!_this5[OPTIONS].disableLifecycleMethods && instance) {
              if (lifecycles.componentDidUpdate && lifecycles.componentDidUpdate.onSetState && typeof instance.shouldComponentUpdate === 'function') {
                var gDSFP = lifecycles.getDerivedStateFromProps;

                if (gDSFP && gDSFP.hasShouldComponentUpdateBug) {
                  mockSCUIfgDSFPReturnNonNull(node, state);
                }
                shouldComponentUpdateSpy = (0, _Utils.spyMethod)(instance, 'shouldComponentUpdate');
              }
              if (lifecycles.getChildContext.calledByRenderer && typeof instance.getChildContext === 'function') {
                getChildContextSpy = (0, _Utils.spyMethod)(instance, 'getChildContext');
              }
            }
            if (!shouldComponentUpdateSpy && isPureComponent(instance)) {
              shouldRender = pureComponentShouldComponentUpdate(prevProps, instance.props, prevState, (0, _object2['default'])({}, prevState, statePayload));
            }

            // We don't pass the setState callback here
            // to guarantee to call the callback after finishing the render
            if (instance[SET_STATE]) {
              instance[SET_STATE](statePayload);
            } else {
              instance.setState(statePayload);
            }
            if (shouldComponentUpdateSpy) {
              shouldRender = shouldComponentUpdateSpy.getLastReturnValue();
              shouldComponentUpdateSpy.restore();
            }
            if (maybeHasUpdate && shouldRender && !_this5[OPTIONS].disableLifecycleMethods) {
              privateSetChildContext(adapter, _this5, instance, node, getChildContextSpy);
              if (lifecycles.componentDidUpdate && lifecycles.componentDidUpdate.onSetState) {
                if (lifecycles.getSnapshotBeforeUpdate && typeof instance.getSnapshotBeforeUpdate === 'function') {
                  var snapshot = instance.getSnapshotBeforeUpdate(prevProps, prevState);
                  if (typeof instance.componentDidUpdate === 'function') {
                    instance.componentDidUpdate(prevProps, prevState, snapshot);
                  }
                } else if (typeof instance.componentDidUpdate === 'function') {
                  if (lifecycles.componentDidUpdate.prevContext) {
                    instance.componentDidUpdate(prevProps, prevState, prevContext);
                  } else {
                    instance.componentDidUpdate(prevProps, prevState);
                  }
                }
              }
            }
            _this5.update();
            // call the setState callback
            if (callback) {
              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 {ShallowWrapper}
     */

  }, {
    key: 'setContext',
    value: function () {
      function setContext(context) {
        if (this[ROOT] !== this) {
          throw new Error('ShallowWrapper::setContext() can only be called on the root');
        }
        if (!this[OPTIONS].context) {
          throw new Error('ShallowWrapper::setContext() can only be called on a wrapper that was originally passed a context option');
        }
        return this.rerender(null, context);
      }

      return setContext;
    }()

    /**
     * Whether or not a given react element exists in the shallow render tree.
     *
     * Example:
     * ```
     * const wrapper = shallow(<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]);
        if (!(0, _Utils.isReactElementAlike)(nodeOrNodes, adapter)) {
          throw new Error('ShallowWrapper::contains() can only be called with a ReactElement (or an array of them), a string, or a number as an argument.');
        }
        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 shallow render tree.
     * Match is based on the expected element and not on wrappers element.
     * 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 = shallow(<MyComponent />);
     * expect(wrapper.containsMatchingElement(<div>Hello</div>)).to.equal(true);
     * ```
     *
     * @param {ReactElement} node
     * @returns {Boolean}
     */

  }, {
    key: 'containsMatchingElement',
    value: function () {
      function containsMatchingElement(node) {
        var adapter = (0, _getAdapter2['default'])(this[OPTIONS]);
        var rstNode = adapter.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 shallow render tree.
     * Match is based on the expected element and not on wrappers element.
     * 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 = shallow(<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 _this6 = this;

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

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

      return containsAllMatchingElements;
    }()

    /**
     * Whether or not one of the given react elements exists in the shallow render tree.
     * Match is based on the expected element and not on wrappers element.
     * 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 = shallow(<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 _this7 = this;

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

      return containsAnyMatchingElements;
    }()

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

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

        return this.single('equals', function () {
          return (0, _Utils.nodeEqual)(_this8.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 = shallow(<MyComponent />);
     * expect(wrapper.matchesElement(<div>Hello</div>)).to.equal(true);
     * ```
     *
     * @param {ReactElement} node
     * @returns {Boolean}
     */

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

        return this.single('matchesElement', function () {
          var adapter = (0, _getAdapter2['default'])(_this9[OPTIONS]);
          var rstNode = adapter.elementToNode(node);
          return (0, _Utils.nodeMatches)(rstNode, _this9.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 {ShallowWrapper}
     */

  }, {
    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.getNodesInternal();

        return nodes.every(function (n) {
          return (0, _Utils.isEmptyValue)(n);
        });
      }

      return isEmptyRender;
    }()

    /**
     * Returns a new wrapper instance with only the nodes of the current wrapper instance that match
     * the provided predicate function. The predicate should receive a wrapped node as its first
     * argument.
     *
     * @param {Function} predicate
     * @returns {ShallowWrapper}
     */

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

        return filterWhereUnwrapped(this, function (n) {
          return predicate(_this10.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 {ShallowWrapper}
     */

  }, {
    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 {ShallowWrapper}
     */

  }, {
    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() {
        return this.single('text', _RSTTraversal.getTextFromNode);
      }

      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 _this11 = this;

        return this.single('html', function (n) {
          if (_this11.type() === null) return null;
          var adapter = (0, _getAdapter2['default'])(_this11[OPTIONS]);
          var renderer = adapter.createRenderer((0, _object2['default'])({}, _this11[OPTIONS], { mode: 'string' }));
          return renderer.render(adapter.nodeToElement(n));
        });
      }

      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 {Array} args
     * @returns {ShallowWrapper}
     */

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

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

        return this.single('simulate', function (n) {
          var _RENDERER;

          (_RENDERER = _this12[RENDERER]).simulateEvent.apply(_RENDERER, [n, event].concat(args));
          _this12[ROOT].update();
          return _this12;
        });
      }

      return simulate;
    }()

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

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

        // in shallow, the "root" is the "rendered" thing.

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

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

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

          return _this13;
        });
      }

      return simulateError;
    }()

    /**
     * Returns the props hash for the current 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 _this14 = this;

        if (this[ROOT] !== this) {
          throw new Error('ShallowWrapper::state() can only be called on the root');
        }
        if (this.instance() === null || this[RENDERER].getNode().nodeType !== 'class') {
          throw new Error('ShallowWrapper::state() can only be called on class components');
        }
        var _state = this.single('state', function () {
          return _this14.instance().state;
        });
        if (typeof name !== 'undefined') {
          if (_state == null) {
            throw new TypeError('ShallowWrapper::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 _this15 = this;

        if (this[ROOT] !== this) {
          throw new Error('ShallowWrapper::context() can only be called on the root');
        }
        if (!this[OPTIONS].context) {
          throw new Error('ShallowWrapper::context() can only be called on a wrapper that was originally passed a context option');
        }
        if (this.instance() === null) {
          throw new Error('ShallowWrapper::context() can only be called on wrapped nodes that have a non-null instance');
        }
        var _context = this.single('context', function () {
          return _this15.instance().context;
        });
        if (name) {
          return _context[name];
        }
        return _context;
      }

      return context;
    }()

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

  }, {
    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 {ShallowWrapper}
     */

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

        return this.single('childAt', function () {
          return _this16.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 {ShallowWrapper}
     */

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

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

      return parents;
    }()

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

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

      return parent;
    }()

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

  }, {
    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;
    }()

    /**
     * Shallow renders the current node and returns a shallow wrapper around it.
     *
     * NOTE: can only be called on wrapper of a single node.
     *
     * @param {Object} options
     * @returns {ShallowWrapper}
     */

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

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

        return this.single('shallow', function (n) {
          var childOptions = makeInheritedChildOptions(_this18, options);
          return _this18.wrap((0, _getAdapter2['default'])(_this18[OPTIONS]).nodeToElement(n), null, childOptions);
        });
      }

      return shallow;
    }()

    /**
     * Returns the value of prop with the given name of the current node.
     *
     * @param 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 _this19 = this;

        return this.single('invoke', function () {
          var handler = _this19.prop(propName);
          if (typeof handler !== 'function') {
            throw new TypeError('ShallowWrapper::invoke() requires the name of a prop whose value is a function');
          }
          return function () {
            var response = handler.apply(undefined, arguments);
            _this19[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 _this20 = 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('ShallowWrapper::renderProp() can only be called on custom components');
          }
          if (typeof propName !== 'string') {
            throw new TypeError('ShallowWrapper::renderProp(): `propName` must be a string');
          }
          var props = _this20.props();
          if (!(0, _has2['default'])(props, propName)) {
            throw new Error('ShallowWrapper::renderProp(): no prop called \u201C' + String(propName) + '\u201C found');
          }
          var propValue = props[propName];
          if (typeof propValue !== 'function') {
            throw new TypeError('ShallowWrapper::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 _this20.wrap(wrapped, null, _this20[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 current node of this wrapper. If it's a composite component, this will
     * be the component constructor. If it's a native DOM node, it will be a string of the tag name.
     * If it's null, it will be null.
     *
     * @returns {String|Function|null}
     */

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

      return type;
    }()

    /**
     * Returns the name of the current 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 node has the given class name or not.
     *
     * NOTE: can only be called on a wrapper of a single node.
     *
     * @param 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 `ShallowWrapper::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 {ShallowWrapper}
     */

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

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

      return forEach;
    }()

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

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

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

      return map;
    }()

    /**
     * Reduces the current array of nodes to a value. 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 _this23 = 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(_this23, accum, _this23.wrap(n), i);
          }, initialValue);
        }
        return this.getNodesInternal().reduce(function (accum, n, i) {
          return fn.call(_this23, i === 1 ? _this23.wrap(accum) : accum, _this23.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 _this24 = 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(_this24, accum, _this24.wrap(n), i);
          }, initialValue);
        }
        return this.getNodesInternal().reduceRight(function (accum, n, i) {
          return fn.call(_this24, i === 1 ? _this24.wrap(accum) : accum, _this24.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('ShallowWrapper::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 _this25 = this;

        return this.getNodesInternal().some(function (n, i) {
          return predicate.call(_this25, _this25.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 _this26 = this;

        return this.getNodesInternal().every(function (n, i) {
          return predicate.call(_this26, _this26.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 {ShallowWrapper}
     */

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

        var nodes = this.getNodesInternal().map(function (n, i) {
          return fn.call(_this27, _this27.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. The predicate function will receive the nodes inside a ShallowWrapper as its
     * first argument.
     *
     * @param {Function} predicate
     * @returns {ShallowWrapper}
     */

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

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

      return findWhere;
    }()

    /**
     * Returns the node at a given index of the current wrapper.
     *
     * @param 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 index
     * @returns {ShallowWrapper}
     */

  }, {
    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 {ShallowWrapper}
     */

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

      return first;
    }()

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

  }, {
    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 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 node
     * @returns {ShallowWrapper}
     */

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

        if (node instanceof ShallowWrapper) {
          return node;
        }

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

        return new (Function.prototype.bind.apply(ShallowWrapper, [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 {ShallowWrapper}
     */

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

      return tap;
    }()

    /**
     * Primarily useful for HOCs (higher-order components), this method may only be
     * run on a single, non-DOM node, and will return the node, shallow-rendered.
     *
     * @param {Object} options
     * @returns {ShallowWrapper}
     */

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

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

        var adapter = (0, _getAdapter2['default'])(this[OPTIONS]);
        var name = 'dive';
        return this.single(name, function (n) {
          if (n && n.nodeType === 'host') {
            throw new TypeError('ShallowWrapper::' + name + '() can not be called on Host Components');
          }
          var el = (0, _getAdapter2['default'])(_this29[OPTIONS]).nodeToElement(n);
          if (!(0, _Utils.isCustomComponentElement)(el, adapter)) {
            throw new TypeError('ShallowWrapper::' + name + '() can only be called on components');
          }
          var childOptions = makeInheritedChildOptions(_this29, options);
          return _this29.wrap(el, null, childOptions);
        });
      }

      return dive;
    }()

    /**
     * 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 ShallowWrapper;
}();

/**
 * Updates the context of the primary wrapper when the
 * `wrappingComponent` re-renders.
 */


function updatePrimaryRootContext(wrappingComponent) {
  var adapter = (0, _getAdapter2['default'])(wrappingComponent[OPTIONS]);
  var primaryWrapper = wrappingComponent[PRIMARY_WRAPPER];
  var primaryRenderer = primaryWrapper[RENDERER];
  var primaryNode = primaryRenderer.getNode();

  var _getContextFromWrappi2 = getContextFromWrappingComponent(wrappingComponent, adapter),
      legacyContext = _getContextFromWrappi2.legacyContext,
      providerValues = _getContextFromWrappi2.providerValues;

  var prevProviderValues = primaryWrapper[PROVIDER_VALUES];

  primaryWrapper.setContext((0, _object2['default'])({}, wrappingComponent[PRIMARY_WRAPPER][OPTIONS].context, legacyContext));
  primaryWrapper[PROVIDER_VALUES] = new Map([].concat(_toConsumableArray(prevProviderValues), _toConsumableArray(providerValues)));

  if (typeof adapter.isContextConsumer === 'function' && adapter.isContextConsumer(primaryNode.type)) {
    var Consumer = primaryNode.type;
    // Adapters with an `isContextConsumer` method will definitely have a `getProviderFromConsumer`
    // method.
    var Provider = adapter.getProviderFromConsumer(Consumer);
    var newValue = providerValues.get(Provider);
    var oldValue = prevProviderValues.get(Provider);

    // Use referential comparison like React
    if (newValue !== oldValue) {
      primaryWrapper.rerender();
    }
  }
}

/**
 * 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.
 *
 * @class WrappingComponentWrapper
 */

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

  function WrappingComponentWrapper(nodes, root, RootFinder) {
    _classCallCheck(this, WrappingComponentWrapper);

    var _this30 = _possibleConstructorReturn(this, (WrappingComponentWrapper.__proto__ || Object.getPrototypeOf(WrappingComponentWrapper)).call(this, nodes));

    (0, _Utils.privateSet)(_this30, PRIMARY_WRAPPER, root);
    (0, _Utils.privateSet)(_this30, ROOT_FINDER, RootFinder);
    return _this30;
  }

  /**
   * Like rerender() on ShallowWrapper, except it also does a "full render" of
   * itself and updates the primary ShallowWrapper's context.
   */


  _createClass(WrappingComponentWrapper, [{
    key: 'rerender',
    value: function () {
      function rerender() {
        var _get2;

        for (var _len4 = arguments.length, args = Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
          args[_key4] = arguments[_key4];
        }

        var result = (_get2 = _get(WrappingComponentWrapper.prototype.__proto__ || Object.getPrototypeOf(WrappingComponentWrapper.prototype), 'rerender', this)).call.apply(_get2, [this].concat(args));
        updatePrimaryRootContext(this);
        return result;
      }

      return rerender;
    }()

    /**
     * Like setState() on ShallowWrapper, except it also does a "full render" of
     * itself and updates the primary ShallowWrapper's context.
     */

  }, {
    key: 'setState',
    value: function () {
      function setState() {
        var _get3;

        for (var _len5 = arguments.length, args = Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {
          args[_key5] = arguments[_key5];
        }

        var result = (_get3 = _get(WrappingComponentWrapper.prototype.__proto__ || Object.getPrototypeOf(WrappingComponentWrapper.prototype), 'setState', this)).call.apply(_get3, [this].concat(args));
        updatePrimaryRootContext(this);
        return result;
      }

      return setState;
    }()

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

  }, {
    key: 'getWrappingComponent',
    value: function () {
      function getWrappingComponent() {
        throw new Error('ShallowWrapper::getWrappingComponent() can only be called on the root');
      }

      return getWrappingComponent;
    }()
  }]);

  return WrappingComponentWrapper;
}(ShallowWrapper);

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

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

          return next;
        }()), _ref2;
      }

      return iterator;
    }()
  });
}

function privateWarning(prop, extraMessage) {
  Object.defineProperty(ShallowWrapper.prototype, prop, {
    get: function () {
      function get() {
        throw new Error('\n        Attempted to access ShallowWrapper::' + String(prop) + ', which was previously a private property on\n        Enzyme ShallowWrapper 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'] = ShallowWrapper;
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/ShallowWrapper.js"],"names":["NODE","NODES","RENDERER","UNRENDERED","ROOT","OPTIONS","SET_STATE","ROOT_NODES","CHILD_CONTEXT","WRAPPING_COMPONENT","PRIMARY_WRAPPER","ROOT_FINDER","PROVIDER_VALUES","findWhereUnwrapped","wrapper","predicate","filter","treeFilter","flatMap","n","getNodeInternal","filterWhereUnwrapped","wrap","getNodesInternal","Boolean","validateOptions","options","lifecycleExperimental","disableLifecycleMethods","enableComponentDidUpdateOnSetState","supportPrevContextArgumentOfComponentDidUpdate","lifecycles","Error","componentDidUpdate","onSetState","TypeError","prevContext","getAdapterLifecycles","hasLegacySetStateArg","hasLegacyPrevContextArg","originalGDSFP","getDerivedStateFromProps","hasShouldComponentUpdateBug","setState","getChildContext","calledByRenderer","getRootNode","node","nodeType","rendered","getRootNodeInternal","length","nodeParents","privateSetNodes","nodes","Array","isArray","pureComponentShouldComponentUpdate","prevProps","props","prevState","state","isPureComponent","instance","isPureReactComponent","hierarchy","renderer","Component","type","componentName","childContextTypes","console","warn","childContext","Object","keys","forEach","key","checkPropTypes","spyOnGetChildContextInitialRender","adapter","prototype","privateSetChildContext","renderedNode","getChildContextSpy","legacyContextMode","getLastReturnValue","restore","nodeHierarchy","concat","mockSCUIfgDSFPReturnNonNull","originalSCU","shouldComponentUpdate","args","sCUResult","apply","nextState","deepRender","target","element","nodeToElement","dive","children","i","found","at","undefined","getContextFromWrappingComponent","rootFinder","legacyContext","context","providerValues","makeShallowOptions","root","passedOptions","wrappingComponent","wrapWithWrappingComponent","wrappedNode","RootFinder","WrappingComponentWrapper","wrappingComponentLegacyContext","wrappingComponentProviderValues","makeInheritedChildOptions","childOptions","ShallowWrapper","isValidElement","createRenderer","mode","Map","render","getNode","updater","callback","componentDidMount","batchedUpdates","update","single","map","unmount","nextContext","shouldRender","shouldComponentUpdateSpy","gDSFP","getSnapshotBeforeUpdate","snapshot","freeze","arguments","rerender","statePayload","call","maybeHasUpdate","skipsComponentDidUpdateOnNullish","invokeSetStateCallback","nodeOrNodes","other","nodeEqual","elementToNode","rstNode","a","b","every","containsMatchingElement","some","selector","getTextFromNode","html","event","simulateEvent","error","thisNode","simulateError","rootNode","propsOfNode","name","_state","_context","allChildren","index","allParents","parents","get","is","matchingAncestors","first","findWhere","propName","handler","prop","response","RangeError","propValue","wrapped","displayNameOfNode","className","indexOf","fn","initialValue","reduce","accum","reduceRight","begin","end","slice","flattened","getElements","exists","find","fnName","intercepter","el","filterWhere","updatePrimaryRootContext","primaryWrapper","primaryRenderer","primaryNode","prevProviderValues","setContext","isContextConsumer","Consumer","Provider","getProviderFromConsumer","newValue","oldValue","result","ITERATOR_SYMBOL","defineProperty","configurable","value","iterator","iter","next","done","privateWarning","extraMessage","enumerable"],"mappings":"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","file":"ShallowWrapper.js","sourcesContent":["import flat from 'array.prototype.flat';\nimport has from 'has';\nimport shallowEqual from 'enzyme-shallow-equal';\n\nimport {\n  nodeEqual,\n  nodeMatches,\n  containsChildrenSubArray,\n  withSetStateAllowed,\n  typeOfNode,\n  isReactElementAlike,\n  displayNameOfNode,\n  isCustomComponent,\n  isCustomComponentElement,\n  ITERATOR_SYMBOL,\n  makeOptions,\n  sym,\n  privateSet,\n  cloneElement,\n  spyMethod,\n  isEmptyValue,\n  loadCheerioRoot,\n} from './Utils';\nimport getAdapter from './getAdapter';\nimport { debugNodes } from './Debug';\nimport {\n  propsOfNode,\n  getTextFromNode,\n  hasClassName,\n  childrenOfNode,\n  parentsOfNode,\n  treeFilter,\n} from './RSTTraversal';\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 SET_STATE = sym('__setState__');\nconst ROOT_NODES = sym('__rootNodes__');\nconst CHILD_CONTEXT = sym('__childContext__');\nconst WRAPPING_COMPONENT = sym('__wrappingComponent__');\nconst PRIMARY_WRAPPER = sym('__primaryWrapper__');\nconst ROOT_FINDER = sym('__rootFinder__');\nconst PROVIDER_VALUES = sym('__providerValues__');\n\n/**\n * Finds all nodes in the current wrapper nodes' render trees that match the provided predicate\n * function.\n *\n * @param {ShallowWrapper} wrapper\n * @param {Function} predicate\n * @param {Function} filter\n * @returns {ShallowWrapper}\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 {ShallowWrapper} wrapper\n * @param {Function} predicate\n * @returns {ShallowWrapper}\n */\nfunction filterWhereUnwrapped(wrapper, predicate) {\n  return wrapper.wrap(wrapper.getNodesInternal().filter(predicate).filter(Boolean));\n}\n\n/**\n * Ensure options passed to ShallowWrapper are valid. Throws otherwise.\n * @param {Object} options\n */\nfunction validateOptions(options) {\n  const {\n    lifecycleExperimental,\n    disableLifecycleMethods,\n    enableComponentDidUpdateOnSetState,\n    supportPrevContextArgumentOfComponentDidUpdate,\n    lifecycles,\n  } = options;\n  if (typeof lifecycleExperimental !== 'undefined' && typeof lifecycleExperimental !== 'boolean') {\n    throw new Error('lifecycleExperimental must be either true or false if provided');\n  }\n\n  if (typeof disableLifecycleMethods !== 'undefined' && typeof disableLifecycleMethods !== 'boolean') {\n    throw new Error('disableLifecycleMethods must be either true or false if provided');\n  }\n\n  if (\n    lifecycleExperimental != null\n    && disableLifecycleMethods != null\n    && lifecycleExperimental === disableLifecycleMethods\n  ) {\n    throw new Error('lifecycleExperimental and disableLifecycleMethods cannot be set to the same value');\n  }\n\n  if (\n    typeof enableComponentDidUpdateOnSetState !== 'undefined'\n    && lifecycles.componentDidUpdate\n    && lifecycles.componentDidUpdate.onSetState !== enableComponentDidUpdateOnSetState\n  ) {\n    throw new TypeError('the legacy enableComponentDidUpdateOnSetState option should be matched by `lifecycles: { componentDidUpdate: { onSetState: true } }`, for compatibility');\n  }\n\n  if (\n    typeof supportPrevContextArgumentOfComponentDidUpdate !== 'undefined'\n    && lifecycles.componentDidUpdate\n    && lifecycles.componentDidUpdate.prevContext !== supportPrevContextArgumentOfComponentDidUpdate\n  ) {\n    throw new TypeError('the legacy supportPrevContextArgumentOfComponentDidUpdate option should be matched by `lifecycles: { componentDidUpdate: { prevContext: true } }`, for compatibility');\n  }\n}\n\nfunction getAdapterLifecycles({ options }) {\n  const {\n    lifecycles = {},\n    enableComponentDidUpdateOnSetState,\n    supportPrevContextArgumentOfComponentDidUpdate,\n  } = options;\n\n  const hasLegacySetStateArg = typeof enableComponentDidUpdateOnSetState !== 'undefined';\n  const hasLegacyPrevContextArg = typeof supportPrevContextArgumentOfComponentDidUpdate !== 'undefined';\n  const componentDidUpdate = hasLegacySetStateArg || hasLegacyPrevContextArg\n    ? {\n      ...(hasLegacySetStateArg && {\n        onSetState: !!enableComponentDidUpdateOnSetState,\n      }),\n      ...(hasLegacyPrevContextArg && {\n        prevContext: !!supportPrevContextArgumentOfComponentDidUpdate,\n      }),\n    }\n    : null;\n  const { getDerivedStateFromProps: originalGDSFP } = lifecycles;\n  const getDerivedStateFromProps = originalGDSFP ? {\n    hasShouldComponentUpdateBug: !!originalGDSFP.hasShouldComponentUpdateBug,\n  } : false;\n\n  return {\n    ...lifecycles,\n    setState: {\n      ...lifecycles.setState,\n    },\n    getChildContext: {\n      calledByRenderer: true,\n      ...lifecycles.getChildContext,\n    },\n    ...(componentDidUpdate && { componentDidUpdate }),\n    getDerivedStateFromProps,\n  };\n}\n\nfunction getRootNode(node) {\n  if (node.nodeType === 'host') {\n    return node;\n  }\n  return node.rendered;\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 (!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\nfunction pureComponentShouldComponentUpdate(prevProps, props, prevState, state) {\n  return !shallowEqual(prevProps, props) || !shallowEqual(prevState, state);\n}\n\nfunction isPureComponent(instance) {\n  return instance && instance.isPureReactComponent;\n}\n\nfunction getChildContext(node, hierarchy, renderer) {\n  const { instance, type: Component } = node;\n  const componentName = displayNameOfNode(node);\n  // Warn like react if childContextTypes is not defined:\n  // https://github.com/facebook/react/blob/1454a8be03794f5e0b23a7e7696cbbbdcf8b0f5d/packages/react-dom/src/server/ReactPartialRenderer.js#L639-L646\n  if (typeof Component.childContextTypes !== 'object') {\n    // eslint-disable-next-line no-console\n    console.warn(\n      `${componentName}.getChildContext(): childContextTypes must be defined in order to use getChildContext().`,\n    );\n    return {};\n  }\n  // Check childContextTypes like react:\n  // https://github.com/facebook/react/blob/1454a8be03794f5e0b23a7e7696cbbbdcf8b0f5d/packages/react-dom/src/server/ReactPartialRenderer.js#L630-L637\n  const childContext = instance.getChildContext();\n  Object.keys(childContext).forEach((key) => {\n    if (!(key in Component.childContextTypes)) {\n      throw new Error(\n        `${componentName}.getChildContext(): key \"${key}\" is not defined in childContextTypes.`,\n      );\n    }\n  });\n  if (typeof renderer.checkPropTypes === 'function') {\n    renderer.checkPropTypes(Component.childContextTypes, childContext, 'child context', hierarchy);\n  }\n  return childContext;\n}\n\nfunction spyOnGetChildContextInitialRender(nodes, adapter) {\n  if (\n    !isCustomComponentElement(nodes, adapter)\n    || !nodes.type.prototype\n    || typeof nodes.type.prototype.getChildContext !== 'function'\n  ) {\n    return null;\n  }\n\n  return spyMethod(nodes.type.prototype, 'getChildContext');\n}\n\nfunction privateSetChildContext(adapter, wrapper, instance, renderedNode, getChildContextSpy) {\n  const renderer = wrapper[RENDERER];\n  // We only support parent-based context.\n  if (adapter.options.legacyContextMode !== 'parent') { return; }\n  if (getChildContextSpy) {\n    privateSet(wrapper, CHILD_CONTEXT, getChildContextSpy.getLastReturnValue());\n    getChildContextSpy.restore();\n  } else if (typeof instance.getChildContext === 'function') {\n    // If there's no spy but getChildContext is a function, that means our renderer\n    // is not going to call it for us, so we need to call it ourselves.\n    const nodeHierarchy = [wrapper[NODE]].concat(nodeParents(wrapper, wrapper[NODE]));\n    const childContext = getChildContext(renderedNode, nodeHierarchy, renderer);\n    privateSet(wrapper, CHILD_CONTEXT, childContext);\n  } else {\n    privateSet(wrapper, CHILD_CONTEXT, null);\n  }\n}\n\nfunction mockSCUIfgDSFPReturnNonNull(node, state) {\n  const { getDerivedStateFromProps } = node.type;\n\n  if (typeof getDerivedStateFromProps === 'function') {\n    // we try to fix a React shallow renderer bug here.\n    // (facebook/react#14607, which has been fixed in react 16.8):\n    // when gDSFP return derived state, it will set instance state in shallow renderer before SCU,\n    // this will cause `this.state` in sCU be the updated state, which is wrong behavior.\n    // so we have to wrap sCU to pass the old state to original sCU.\n    const { instance } = node;\n    const { restore } = spyMethod(\n      instance,\n      'shouldComponentUpdate',\n      (originalSCU) => function shouldComponentUpdate(...args) {\n        instance.state = state;\n        const sCUResult = originalSCU.apply(instance, args);\n        const [, nextState] = args;\n        instance.state = nextState;\n        restore();\n        return sCUResult;\n      },\n    );\n  }\n}\n\n/**\n * Recursively dive()s every custom component in a wrapper until\n * the target component is found.\n *\n * @param {ShallowWrapper} wrapper A ShallowWrapper to search\n * @param {ComponentType} target A react custom component that, when found, will end recursion\n * @param {Adapter} adapter An Enzyme adapter\n * @returns {ShallowWrapper|undefined} A ShallowWrapper for the target, or\n *  undefined if it can't be found\n */\nfunction deepRender(wrapper, target, adapter) {\n  const node = wrapper[NODE];\n  const element = node && adapter.nodeToElement(node);\n  if (wrapper.type() === target) {\n    return wrapper.dive();\n  }\n  if (element && isCustomComponentElement(element, adapter)) {\n    return deepRender(wrapper.dive(), target, adapter);\n  }\n  const children = wrapper.children();\n  for (let i = 0; i < children.length; i += 1) {\n    const found = deepRender(children.at(i), target, adapter);\n    if (typeof found !== 'undefined') {\n      return found;\n    }\n  }\n  return undefined;\n}\n\n/**\n * Deep-renders the `wrappingComponent` and returns the context that should\n * be accessible to the primary wrapper.\n *\n * @param {WrappingComponentWrapper} wrapper The `WrappingComponentWrapper` for a\n *  `wrappingComponent`\n * @param {Adapter} adapter An Enzyme adapter\n * @returns {object} An object containing an object of legacy context values and a Map of\n *  `createContext()` Provider values.\n */\nfunction getContextFromWrappingComponent(wrapper, adapter) {\n  const rootFinder = deepRender(wrapper, wrapper[ROOT_FINDER], adapter);\n  if (!rootFinder) {\n    throw new Error('`wrappingComponent` must render its children!');\n  }\n  return {\n    legacyContext: rootFinder[OPTIONS].context,\n    providerValues: rootFinder[PROVIDER_VALUES],\n  };\n}\n\n/**\n * Makes options specifically for `ShallowWrapper`. Most of the logic here is around rendering\n * a `wrappingComponent` (if one was provided) and adding the child context of that component\n * to `options.context`.\n *\n * @param {ReactElement} nodes the nodes passed to `ShallowWrapper`\n * @param {ShallowWrapper} root this `ShallowWrapper`'s parent. If this is passed, options are\n *  not transformed.\n * @param {*} passedOptions the options passed to `ShallowWrapper`.\n * @param {*} wrapper the `ShallowWrapper` itself\n * @returns {Object} the decorated and transformed options\n */\nfunction makeShallowOptions(nodes, root, passedOptions, wrapper) {\n  const options = makeOptions(passedOptions);\n  const adapter = getAdapter(passedOptions);\n  privateSet(options, PROVIDER_VALUES, passedOptions[PROVIDER_VALUES]);\n  if (root || !isCustomComponent(options.wrappingComponent, adapter)) {\n    return options;\n  }\n  if (typeof adapter.wrapWithWrappingComponent !== 'function') {\n    throw new TypeError('your adapter does not support `wrappingComponent`. Try upgrading it!');\n  }\n  const { node: wrappedNode, RootFinder } = adapter.wrapWithWrappingComponent(nodes, options);\n  // eslint-disable-next-line no-use-before-define\n  const wrappingComponent = new WrappingComponentWrapper(wrappedNode, wrapper, RootFinder);\n  const {\n    legacyContext: wrappingComponentLegacyContext,\n    providerValues: wrappingComponentProviderValues,\n  } = getContextFromWrappingComponent(wrappingComponent, adapter);\n  privateSet(wrapper, WRAPPING_COMPONENT, wrappingComponent);\n  return {\n    ...options,\n    context: {\n      ...options.context,\n      ...wrappingComponentLegacyContext,\n    },\n    [PROVIDER_VALUES]: wrappingComponentProviderValues,\n  };\n}\n\n\nfunction makeInheritedChildOptions(wrapper, options = {}) {\n  const childOptions = {\n    ...wrapper[OPTIONS],\n    ...options,\n    context: options.context || {\n      ...wrapper[OPTIONS].context,\n      ...wrapper[ROOT][CHILD_CONTEXT],\n    },\n  };\n  privateSet(childOptions, PROVIDER_VALUES, wrapper[ROOT][PROVIDER_VALUES]);\n  return childOptions;\n}\n\n\n/**\n * @class ShallowWrapper\n */\nclass ShallowWrapper {\n  constructor(nodes, root, passedOptions = {}) {\n    validateOptions(passedOptions);\n\n    const options = makeShallowOptions(nodes, root, passedOptions, this);\n    const adapter = getAdapter(options);\n    const lifecycles = getAdapterLifecycles(adapter);\n\n    // mounting a ShallowRender component\n    if (!root) {\n      if (!adapter.isValidElement(nodes)) {\n        throw new TypeError('ShallowWrapper can only wrap valid elements');\n      }\n\n      const getChildContextSpy = lifecycles.getChildContext.calledByRenderer\n        ? spyOnGetChildContextInitialRender(nodes, adapter)\n        : null;\n      privateSet(this, ROOT, this);\n      privateSet(this, UNRENDERED, nodes);\n      const renderer = adapter.createRenderer({ mode: 'shallow', ...options });\n      privateSet(this, RENDERER, renderer);\n      const providerValues = new Map(options[PROVIDER_VALUES] || []);\n      this[RENDERER].render(nodes, options.context, { providerValues });\n      const renderedNode = this[RENDERER].getNode();\n      privateSetNodes(this, getRootNode(renderedNode));\n      privateSet(this, OPTIONS, options);\n      privateSet(this, PROVIDER_VALUES, providerValues);\n\n      const { instance } = renderedNode;\n      if (instance && !options.disableLifecycleMethods) {\n        // Ensure to call componentDidUpdate when instance.setState is called\n        if (lifecycles.componentDidUpdate.onSetState && !instance[SET_STATE]) {\n          privateSet(instance, SET_STATE, instance.setState);\n          instance.setState = (updater, callback = undefined) => this.setState(\n            ...(callback == null ? [updater] : [updater, callback]),\n          );\n        }\n\n        if (typeof instance.componentDidMount === 'function') {\n          this[RENDERER].batchedUpdates(() => {\n            instance.componentDidMount();\n          });\n        }\n        privateSetChildContext(adapter, this, instance, renderedNode, getChildContextSpy);\n      }\n    // creating a child component through enzyme's ShallowWrapper APIs.\n    } else {\n      privateSet(this, ROOT, root);\n      privateSet(this, UNRENDERED, null);\n      privateSet(this, RENDERER, root[RENDERER]);\n      privateSetNodes(this, nodes);\n      privateSet(this, OPTIONS, root[OPTIONS]);\n      privateSet(this, ROOT_NODES, root[NODES]);\n      privateSet(this, PROVIDER_VALUES, null);\n    }\n  }\n\n  /**\n   * Returns the root wrapper\n   *\n   * @return {ShallowWrapper}\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('ShallowWrapper::getNode() can only be called when wrapping one node');\n    }\n    if (this[ROOT] === this) {\n      this.update();\n    }\n    return this[NODE];\n  }\n\n  /**\n   * Returns the the wrapped components.\n   *\n   * @return {Array<ReactComponent>}\n   */\n  getNodesInternal() {\n    if (this[ROOT] === this && this.length === 1) {\n      this.update();\n    }\n    return this[NODES];\n  }\n\n  /**\n   * Returns the wrapped ReactElement.\n   *\n   * @return {ReactElement}\n   */\n  getElement() {\n    return this.single('getElement', (n) => getAdapter(this[OPTIONS]).nodeToElement(n));\n  }\n\n  /**\n   * Returns the wrapped ReactElements.\n   *\n   * @return {Array<ReactElement>}\n   */\n  getElements() {\n    return this.getNodesInternal().map((n) => getAdapter(this[OPTIONS]).nodeToElement(n));\n  }\n\n  // eslint-disable-next-line class-methods-use-this\n  getNode() {\n    throw new Error('ShallowWrapper::getNode() is no longer supported. Use ShallowWrapper::getElement() instead');\n  }\n\n  // eslint-disable-next-line class-methods-use-this\n  getNodes() {\n    throw new Error('ShallowWrapper::getNodes() is no longer supported. Use ShallowWrapper::getElements() instead');\n  }\n\n  /**\n   * Gets the instance of the component being rendered as the root node passed into `shallow()`.\n   *\n   * NOTE: can only be called on a wrapper instance that is also the root instance.\n   *\n   * Example:\n   * ```\n   * const wrapper = shallow(<MyComponent />);\n   * const inst = wrapper.instance();\n   * expect(inst).to.be.instanceOf(MyComponent);\n   * ```\n   * @returns {ReactComponent}\n   */\n  instance() {\n    if (this[ROOT] !== this) {\n      throw new Error('ShallowWrapper::instance() can only be called on the root');\n    }\n    return this[RENDERER].getNode().instance;\n  }\n\n  /**\n   * If a `wrappingComponent` was passed in `options`, this methods returns a `ShallowWrapper`\n   * around the rendered `wrappingComponent`. This `ShallowWrapper` can be used to update the\n   * `wrappingComponent`'s props, state, etc.\n   *\n   * @returns ShallowWrapper\n   */\n  getWrappingComponent() {\n    if (this[ROOT] !== this) {\n      throw new Error('ShallowWrapper::getWrappingComponent() can only be called on the root');\n    }\n    if (!this[OPTIONS].wrappingComponent) {\n      throw new Error('ShallowWrapper::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: can only be called on a wrapper instance that is also the root instance.\n   *\n   * @returns {ShallowWrapper}\n   */\n  update() {\n    if (this[ROOT] !== this) {\n      throw new Error('ShallowWrapper::update() can only be called on the root');\n    }\n    if (this.length !== 1) {\n      throw new Error('ShallowWrapper::update() can only be called when wrapping one node');\n    }\n    privateSetNodes(this, getRootNode(this[RENDERER].getNode()));\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   * @returns {ShallowWrapper}\n   */\n  unmount() {\n    this[RENDERER].unmount();\n    if (this[ROOT][WRAPPING_COMPONENT]) {\n      this[ROOT][WRAPPING_COMPONENT].unmount();\n    }\n    return this;\n  }\n\n  /**\n   * A method is for re-render with new props and context.\n   * This calls componentDidUpdate method if disableLifecycleMethods is not enabled.\n   *\n   * NOTE: can only be called on a wrapper instance that is also the root instance.\n   *\n   * @param {Object} props\n   * @param {Object} context\n   * @returns {ShallowWrapper}\n   */\n  rerender(props, context) {\n    const adapter = getAdapter(this[OPTIONS]);\n    this.single('rerender', () => {\n      withSetStateAllowed(() => {\n        // NOTE(lmr): In react 16, instances will be null for SFCs, but\n        // rerendering with props/context is still a valid thing to do. In\n        // this case, state will be undefined, but props/context will exist.\n        const node = this[RENDERER].getNode();\n        const instance = node.instance || {};\n        const type = node.type || {};\n        const { state } = instance;\n        const prevProps = instance.props || this[UNRENDERED].props;\n        const prevContext = instance.context || this[OPTIONS].context;\n        const nextContext = context || prevContext;\n        if (context) {\n          this[OPTIONS] = { ...this[OPTIONS], context: nextContext };\n        }\n        this[RENDERER].batchedUpdates(() => {\n          // When shouldComponentUpdate returns false we shouldn't call componentDidUpdate.\n          // so we spy shouldComponentUpdate to get the result.\n          const lifecycles = getAdapterLifecycles(adapter);\n          let shouldRender = true;\n          let shouldComponentUpdateSpy;\n          let getChildContextSpy;\n          if (\n            !this[OPTIONS].disableLifecycleMethods\n            && instance\n          ) {\n            if (typeof instance.shouldComponentUpdate === 'function') {\n              const { getDerivedStateFromProps: gDSFP } = lifecycles;\n              if (gDSFP && gDSFP.hasShouldComponentUpdateBug) {\n                mockSCUIfgDSFPReturnNonNull(node, state);\n              }\n              shouldComponentUpdateSpy = spyMethod(instance, 'shouldComponentUpdate');\n            }\n            if (\n              lifecycles.getChildContext.calledByRenderer\n              && typeof instance.getChildContext === 'function'\n            ) {\n              getChildContextSpy = spyMethod(instance, 'getChildContext');\n            }\n          }\n          if (!shouldComponentUpdateSpy && isPureComponent(instance)) {\n            shouldRender = pureComponentShouldComponentUpdate(\n              prevProps,\n              props,\n              state,\n              instance.state,\n            );\n          }\n          if (props) this[UNRENDERED] = cloneElement(adapter, this[UNRENDERED], props);\n          this[RENDERER].render(this[UNRENDERED], nextContext, {\n            providerValues: this[PROVIDER_VALUES],\n          });\n          if (shouldComponentUpdateSpy) {\n            shouldRender = shouldComponentUpdateSpy.getLastReturnValue();\n            shouldComponentUpdateSpy.restore();\n          }\n          if (\n            shouldRender\n            && !this[OPTIONS].disableLifecycleMethods\n            && instance\n          ) {\n            privateSetChildContext(adapter, this, instance, node, getChildContextSpy);\n            if (lifecycles.getSnapshotBeforeUpdate) {\n              let snapshot;\n              if (typeof instance.getSnapshotBeforeUpdate === 'function') {\n                snapshot = instance.getSnapshotBeforeUpdate(prevProps, state);\n              }\n              if (\n                lifecycles.componentDidUpdate\n                && typeof instance.componentDidUpdate === 'function'\n                && (\n                  !state\n                  || shallowEqual(state, this.instance().state)\n                  || typeof type.getDerivedStateFromProps === 'function'\n                )\n              ) {\n                instance.componentDidUpdate(prevProps, state, snapshot);\n              }\n            } else if (\n              lifecycles.componentDidUpdate\n              && typeof instance.componentDidUpdate === 'function'\n            ) {\n              if (lifecycles.componentDidUpdate.prevContext) {\n                instance.componentDidUpdate(prevProps, state, prevContext);\n              } else if (!state || shallowEqual(this.instance().state, state)) {\n                instance.componentDidUpdate(prevProps, state);\n              }\n            }\n          // If it doesn't need to rerender, update only its props.\n          } else if (!shallowEqual(props, instance.props)) {\n            instance.props = (Object.freeze || Object)({ ...instance.props, ...props });\n          }\n          this.update();\n        });\n      });\n    });\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 {ShallowWrapper}\n   */\n  setProps(props, callback = undefined) {\n    if (this[ROOT] !== this) {\n      throw new Error('ShallowWrapper::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    this.rerender(props);\n    if (callback) {\n      callback();\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 {ShallowWrapper}\n   */\n  setState(state, callback = undefined) {\n    if (this[ROOT] !== this) {\n      throw new Error('ShallowWrapper::setState() can only be called on the root');\n    }\n    if (this.instance() === null || this[RENDERER].getNode().nodeType !== 'class') {\n      throw new Error('ShallowWrapper::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\n    this.single('setState', () => {\n      withSetStateAllowed(() => {\n        const adapter = getAdapter(this[OPTIONS]);\n\n        const lifecycles = getAdapterLifecycles(adapter);\n\n        const node = this[RENDERER].getNode();\n        const { instance } = node;\n        const prevProps = instance.props;\n        const prevState = instance.state;\n        const prevContext = instance.context;\n\n        const statePayload = typeof state === 'function'\n          ? state.call(instance, prevState, prevProps)\n          : state;\n\n        // returning null or undefined prevents the update in React 16+\n        // https://github.com/facebook/react/pull/12756\n        const maybeHasUpdate = !lifecycles.setState.skipsComponentDidUpdateOnNullish\n          || statePayload != null;\n\n        // When shouldComponentUpdate returns false we shouldn't call componentDidUpdate.\n        // so we spy shouldComponentUpdate to get the result.\n        let shouldComponentUpdateSpy;\n        let getChildContextSpy;\n        let shouldRender = true;\n        if (\n          !this[OPTIONS].disableLifecycleMethods\n          && instance\n        ) {\n          if (\n            lifecycles.componentDidUpdate\n            && lifecycles.componentDidUpdate.onSetState\n            && typeof instance.shouldComponentUpdate === 'function'\n          ) {\n            const { getDerivedStateFromProps: gDSFP } = lifecycles;\n            if (gDSFP && gDSFP.hasShouldComponentUpdateBug) {\n              mockSCUIfgDSFPReturnNonNull(node, state);\n            }\n            shouldComponentUpdateSpy = spyMethod(instance, 'shouldComponentUpdate');\n          }\n          if (\n            lifecycles.getChildContext.calledByRenderer\n            && typeof instance.getChildContext === 'function'\n          ) {\n            getChildContextSpy = spyMethod(instance, 'getChildContext');\n          }\n        }\n        if (!shouldComponentUpdateSpy && isPureComponent(instance)) {\n          shouldRender = pureComponentShouldComponentUpdate(\n            prevProps,\n            instance.props,\n            prevState,\n            { ...prevState, ...statePayload },\n          );\n        }\n\n        // We don't pass the setState callback here\n        // to guarantee to call the callback after finishing the render\n        if (instance[SET_STATE]) {\n          instance[SET_STATE](statePayload);\n        } else {\n          instance.setState(statePayload);\n        }\n        if (shouldComponentUpdateSpy) {\n          shouldRender = shouldComponentUpdateSpy.getLastReturnValue();\n          shouldComponentUpdateSpy.restore();\n        }\n        if (\n          maybeHasUpdate\n          && shouldRender\n          && !this[OPTIONS].disableLifecycleMethods\n        ) {\n          privateSetChildContext(adapter, this, instance, node, getChildContextSpy);\n          if (\n            lifecycles.componentDidUpdate\n            && lifecycles.componentDidUpdate.onSetState\n          ) {\n            if (\n              lifecycles.getSnapshotBeforeUpdate\n              && typeof instance.getSnapshotBeforeUpdate === 'function'\n            ) {\n              const snapshot = instance.getSnapshotBeforeUpdate(prevProps, prevState);\n              if (typeof instance.componentDidUpdate === 'function') {\n                instance.componentDidUpdate(prevProps, prevState, snapshot);\n              }\n            } else if (typeof instance.componentDidUpdate === 'function') {\n              if (lifecycles.componentDidUpdate.prevContext) {\n                instance.componentDidUpdate(prevProps, prevState, prevContext);\n              } else {\n                instance.componentDidUpdate(prevProps, prevState);\n              }\n            }\n          }\n        }\n        this.update();\n        // call the setState callback\n        if (callback) {\n          if (adapter.invokeSetStateCallback) {\n            adapter.invokeSetStateCallback(instance, callback);\n          } else {\n            callback.call(instance);\n          }\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 {ShallowWrapper}\n   */\n  setContext(context) {\n    if (this[ROOT] !== this) {\n      throw new Error('ShallowWrapper::setContext() can only be called on the root');\n    }\n    if (!this[OPTIONS].context) {\n      throw new Error('ShallowWrapper::setContext() can only be called on a wrapper that was originally passed a context option');\n    }\n    return this.rerender(null, context);\n  }\n\n  /**\n   * Whether or not a given react element exists in the shallow render tree.\n   *\n   * Example:\n   * ```\n   * const wrapper = shallow(<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    if (!isReactElementAlike(nodeOrNodes, adapter)) {\n      throw new Error('ShallowWrapper::contains() can only be called with a ReactElement (or an array of them), a string, or a number as an argument.');\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 shallow render tree.\n   * Match is based on the expected element and not on wrappers element.\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 = shallow(<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 adapter = getAdapter(this[OPTIONS]);\n    const rstNode = adapter.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 shallow render tree.\n   * Match is based on the expected element and not on wrappers element.\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 = shallow(<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 shallow render tree.\n   * Match is based on the expected element and not on wrappers element.\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 = shallow(<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 = shallow(<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 = shallow(<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 {ShallowWrapper}\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.getNodesInternal();\n\n    return nodes.every((n) => isEmptyValue(n));\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. The predicate should receive a wrapped node as its first\n   * argument.\n   *\n   * @param {Function} predicate\n   * @returns {ShallowWrapper}\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 {ShallowWrapper}\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 {ShallowWrapper}\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    return this.single('text', getTextFromNode);\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    return this.single('html', (n) => {\n      if (this.type() === null) return null;\n      const adapter = getAdapter(this[OPTIONS]);\n      const renderer = adapter.createRenderer({ ...this[OPTIONS], mode: 'string' });\n      return renderer.render(adapter.nodeToElement(n));\n    });\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 {Array} args\n   * @returns {ShallowWrapper}\n   */\n  simulate(event, ...args) {\n    return this.single('simulate', (n) => {\n      this[RENDERER].simulateEvent(n, event, ...args);\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 {ShallowWrapper}\n   */\n  simulateError(error) {\n    // in shallow, the \"root\" is the \"rendered\" thing.\n\n    return this.single('simulateError', (thisNode) => {\n      if (thisNode.nodeType === 'host') {\n        throw new TypeError('ShallowWrapper::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      return this;\n    });\n  }\n\n  /**\n   * Returns the props hash for the current 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    if (this[ROOT] !== this) {\n      throw new Error('ShallowWrapper::state() can only be called on the root');\n    }\n    if (this.instance() === null || this[RENDERER].getNode().nodeType !== 'class') {\n      throw new Error('ShallowWrapper::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(`ShallowWrapper::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('ShallowWrapper::context() can only be called on the root');\n    }\n    if (!this[OPTIONS].context) {\n      throw new Error('ShallowWrapper::context() can only be called on a wrapper that was originally passed a context option');\n    }\n    if (this.instance() === null) {\n      throw new Error('ShallowWrapper::context() can only be called on wrapped nodes that have a non-null instance');\n    }\n    const _context = this.single('context', () => this.instance().context);\n    if (name) {\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 {ShallowWrapper}\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 {ShallowWrapper}\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 {ShallowWrapper}\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 {ShallowWrapper}\n   */\n  parent() {\n    return this.flatMap((n) => [n.parents().get(0)]);\n  }\n\n  /**\n   *\n   * @param {EnzymeSelector} selector\n   * @returns {ShallowWrapper}\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   * Shallow renders the current node and returns a shallow wrapper around it.\n   *\n   * NOTE: can only be called on wrapper of a single node.\n   *\n   * @param {Object} options\n   * @returns {ShallowWrapper}\n   */\n  shallow(options = {}) {\n    return this.single('shallow', (n) => {\n      const childOptions = makeInheritedChildOptions(this, options);\n      return this.wrap(getAdapter(this[OPTIONS]).nodeToElement(n), null, childOptions);\n    });\n  }\n\n  /**\n   * Returns the value of prop with the given name of the current node.\n   *\n   * @param 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('ShallowWrapper::invoke() requires the name of a prop whose value is a function');\n      }\n      return (...args) => {\n        const response = 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('ShallowWrapper::renderProp() can only be called on custom components');\n      }\n      if (typeof propName !== 'string') {\n        throw new TypeError('ShallowWrapper::renderProp(): `propName` must be a string');\n      }\n      const props = this.props();\n      if (!has(props, propName)) {\n        throw new Error(`ShallowWrapper::renderProp(): no prop called “${propName}“ found`);\n      }\n      const propValue = props[propName];\n      if (typeof propValue !== 'function') {\n        throw new TypeError(`ShallowWrapper::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 current node of this wrapper. If it's a composite component, this will\n   * be the component constructor. If it's a native DOM node, it will be a string of the tag name.\n   * If it's null, it will be null.\n   *\n   * @returns {String|Function|null}\n   */\n  type() {\n    return this.single('type', (n) => typeOfNode(n));\n  }\n\n  /**\n   * Returns the name of the current 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 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 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 `ShallowWrapper::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 {ShallowWrapper}\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 `ShallowWrapper`\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 a value. Each node is passed in as a `ShallowWrapper`\n   * 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('ShallowWrapper::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 {ShallowWrapper}\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. The predicate function will receive the nodes inside a ShallowWrapper as its\n   * first argument.\n   *\n   * @param {Function} predicate\n   * @returns {ShallowWrapper}\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 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 index\n   * @returns {ShallowWrapper}\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 {ShallowWrapper}\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 {ShallowWrapper}\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 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 node\n   * @returns {ShallowWrapper}\n   */\n  wrap(node, root = this[ROOT], ...args) {\n    if (node instanceof ShallowWrapper) {\n      return node;\n    }\n    return new ShallowWrapper(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 {ShallowWrapper}\n   */\n  tap(intercepter) {\n    intercepter(this);\n    return this;\n  }\n\n  /**\n   * Primarily useful for HOCs (higher-order components), this method may only be\n   * run on a single, non-DOM node, and will return the node, shallow-rendered.\n   *\n   * @param {Object} options\n   * @returns {ShallowWrapper}\n   */\n  dive(options = {}) {\n    const adapter = getAdapter(this[OPTIONS]);\n    const name = 'dive';\n    return this.single(name, (n) => {\n      if (n && n.nodeType === 'host') {\n        throw new TypeError(`ShallowWrapper::${name}() can not be called on Host Components`);\n      }\n      const el = getAdapter(this[OPTIONS]).nodeToElement(n);\n      if (!isCustomComponentElement(el, adapter)) {\n        throw new TypeError(`ShallowWrapper::${name}() can only be called on components`);\n      }\n      const childOptions = makeInheritedChildOptions(this, options);\n      return this.wrap(el, null, childOptions);\n    });\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 * Updates the context of the primary wrapper when the\n * `wrappingComponent` re-renders.\n */\nfunction updatePrimaryRootContext(wrappingComponent) {\n  const adapter = getAdapter(wrappingComponent[OPTIONS]);\n  const primaryWrapper = wrappingComponent[PRIMARY_WRAPPER];\n  const primaryRenderer = primaryWrapper[RENDERER];\n  const primaryNode = primaryRenderer.getNode();\n  const {\n    legacyContext,\n    providerValues,\n  } = getContextFromWrappingComponent(wrappingComponent, adapter);\n  const prevProviderValues = primaryWrapper[PROVIDER_VALUES];\n\n  primaryWrapper.setContext({\n    ...wrappingComponent[PRIMARY_WRAPPER][OPTIONS].context,\n    ...legacyContext,\n  });\n  primaryWrapper[PROVIDER_VALUES] = new Map([...prevProviderValues, ...providerValues]);\n\n  if (typeof adapter.isContextConsumer === 'function' && adapter.isContextConsumer(primaryNode.type)) {\n    const Consumer = primaryNode.type;\n    // Adapters with an `isContextConsumer` method will definitely have a `getProviderFromConsumer`\n    // method.\n    const Provider = adapter.getProviderFromConsumer(Consumer);\n    const newValue = providerValues.get(Provider);\n    const oldValue = prevProviderValues.get(Provider);\n\n    // Use referential comparison like React\n    if (newValue !== oldValue) {\n      primaryWrapper.rerender();\n    }\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 *\n * @class WrappingComponentWrapper\n */\nclass WrappingComponentWrapper extends ShallowWrapper {\n  constructor(nodes, root, RootFinder) {\n    super(nodes);\n    privateSet(this, PRIMARY_WRAPPER, root);\n    privateSet(this, ROOT_FINDER, RootFinder);\n  }\n\n  /**\n   * Like rerender() on ShallowWrapper, except it also does a \"full render\" of\n   * itself and updates the primary ShallowWrapper's context.\n   */\n  rerender(...args) {\n    const result = super.rerender(...args);\n    updatePrimaryRootContext(this);\n    return result;\n  }\n\n  /**\n   * Like setState() on ShallowWrapper, except it also does a \"full render\" of\n   * itself and updates the primary ShallowWrapper's context.\n   */\n  setState(...args) {\n    const result = super.setState(...args);\n    updatePrimaryRootContext(this);\n    return result;\n  }\n\n  // eslint-disable-next-line class-methods-use-this\n  getWrappingComponent() {\n    throw new Error('ShallowWrapper::getWrappingComponent() can only be called on the root');\n  }\n}\n\nif (ITERATOR_SYMBOL) {\n  Object.defineProperty(ShallowWrapper.prototype, ITERATOR_SYMBOL, {\n    configurable: true,\n    value: function iterator() {\n      const iter = this.getNodesInternal()[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(ShallowWrapper.prototype, prop, {\n    get() {\n      throw new Error(`\n        Attempted to access ShallowWrapper::${prop}, which was previously a private property on\n        Enzyme ShallowWrapper 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 ShallowWrapper;\n"]}
//# sourceMappingURL=ShallowWrapper.js.map