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