1 | 'use strict';
|
2 |
|
3 | 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; }; }();
|
4 |
|
5 | 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; };
|
6 |
|
7 |
|
8 |
|
9 |
|
10 |
|
11 |
|
12 |
|
13 | var _object = require('object.assign');
|
14 |
|
15 | var _object2 = _interopRequireDefault(_object);
|
16 |
|
17 | var _react = require('react');
|
18 |
|
19 | var _react2 = _interopRequireDefault(_react);
|
20 |
|
21 | var _reactDom = require('react-dom');
|
22 |
|
23 | var _reactDom2 = _interopRequireDefault(_reactDom);
|
24 |
|
25 | var _server = require('react-dom/server');
|
26 |
|
27 | var _server2 = _interopRequireDefault(_server);
|
28 |
|
29 | var _testUtils = require('react-dom/test-utils');
|
30 |
|
31 | var _testUtils2 = _interopRequireDefault(_testUtils);
|
32 |
|
33 | var _shallow = require('react-test-renderer/shallow');
|
34 |
|
35 | var _shallow2 = _interopRequireDefault(_shallow);
|
36 |
|
37 | var _object3 = require('object.values');
|
38 |
|
39 | var _object4 = _interopRequireDefault(_object3);
|
40 |
|
41 | var _reactIs = require('react-is');
|
42 |
|
43 | var _enzyme = require('enzyme');
|
44 |
|
45 | var _enzymeAdapterUtils = require('enzyme-adapter-utils');
|
46 |
|
47 | function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
|
48 |
|
49 | function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
|
50 |
|
51 | function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
52 |
|
53 | 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; }
|
54 |
|
55 | 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; }
|
56 |
|
57 | function compositeTypeToNodeType(type) {
|
58 | switch (type) {
|
59 | case 0:
|
60 | case 1:
|
61 | return 'class';
|
62 | case 2:
|
63 | return 'function';
|
64 | default:
|
65 | throw new Error('Enzyme Internal Error: unknown composite type ' + String(type));
|
66 | }
|
67 | }
|
68 | function childrenFromInst(inst, el) {
|
69 | if (inst._renderedChildren) {
|
70 | return (0, _object4['default'])(inst._renderedChildren);
|
71 | }
|
72 | if (el.props) {
|
73 | return (0, _object4['default'])({ '.0': el.props.children });
|
74 | }
|
75 | return [];
|
76 | }
|
77 |
|
78 | function nodeType(inst) {
|
79 | if (inst._compositeType != null) {
|
80 | return compositeTypeToNodeType(inst._compositeType);
|
81 | }
|
82 | return 'host';
|
83 | }
|
84 |
|
85 | function instanceToTree(inst) {
|
86 | if (!inst || (typeof inst === 'undefined' ? 'undefined' : _typeof(inst)) !== 'object') {
|
87 | return inst;
|
88 | }
|
89 | var el = inst._currentElement;
|
90 | if (el == null || el === false) {
|
91 | return null;
|
92 | }
|
93 | if ((typeof el === 'undefined' ? 'undefined' : _typeof(el)) !== 'object') {
|
94 | return el;
|
95 | }
|
96 | if (inst._renderedChildren) {
|
97 | return {
|
98 | nodeType: nodeType(inst),
|
99 | type: el.type,
|
100 | props: el.props,
|
101 | key: (0, _enzymeAdapterUtils.ensureKeyOrUndefined)(el.key),
|
102 | ref: el.ref,
|
103 | instance: inst._instance || inst._hostNode || null,
|
104 | rendered: (0, _object4['default'])(inst._renderedChildren).map(instanceToTree)
|
105 | };
|
106 | }
|
107 | if (inst._hostNode) {
|
108 | return {
|
109 | nodeType: 'host',
|
110 | type: el.type,
|
111 | props: el.props,
|
112 | key: (0, _enzymeAdapterUtils.ensureKeyOrUndefined)(el.key),
|
113 | ref: el.ref,
|
114 | instance: inst._instance || inst._hostNode || null,
|
115 | rendered: childrenFromInst(inst, el).map(instanceToTree)
|
116 | };
|
117 | }
|
118 | if (inst._renderedComponent) {
|
119 | return {
|
120 | nodeType: nodeType(inst),
|
121 | type: el.type,
|
122 | props: el.props,
|
123 | key: (0, _enzymeAdapterUtils.ensureKeyOrUndefined)(el.key),
|
124 | ref: el.ref,
|
125 | instance: inst._instance || inst._hostNode || null,
|
126 | rendered: instanceToTree(inst._renderedComponent)
|
127 | };
|
128 | }
|
129 | return {
|
130 | nodeType: nodeType(inst),
|
131 | type: el.type,
|
132 | props: el.props,
|
133 | key: (0, _enzymeAdapterUtils.ensureKeyOrUndefined)(el.key),
|
134 | ref: el.ref,
|
135 | instance: inst._instance || null,
|
136 | rendered: childrenFromInst(inst, el).map(instanceToTree)
|
137 | };
|
138 | }
|
139 |
|
140 | var eventOptions = { animation: true };
|
141 |
|
142 | var ReactFifteenAdapter = function (_EnzymeAdapter) {
|
143 | _inherits(ReactFifteenAdapter, _EnzymeAdapter);
|
144 |
|
145 | function ReactFifteenAdapter() {
|
146 | _classCallCheck(this, ReactFifteenAdapter);
|
147 |
|
148 | var _this = _possibleConstructorReturn(this, (ReactFifteenAdapter.__proto__ || Object.getPrototypeOf(ReactFifteenAdapter)).call(this));
|
149 |
|
150 | var lifecycles = _this.options.lifecycles;
|
151 |
|
152 | _this.options = (0, _object2['default'])({}, _this.options, {
|
153 | supportPrevContextArgumentOfComponentDidUpdate: true,
|
154 | lifecycles: (0, _object2['default'])({}, lifecycles, {
|
155 | componentDidUpdate: {
|
156 | prevContext: true
|
157 | }
|
158 | })
|
159 | });
|
160 | return _this;
|
161 | }
|
162 |
|
163 | _createClass(ReactFifteenAdapter, [{
|
164 | key: 'createMountRenderer',
|
165 | value: function () {
|
166 | function createMountRenderer(options) {
|
167 | (0, _enzymeAdapterUtils.assertDomAvailable)('mount');
|
168 | var domNode = options.attachTo || global.document.createElement('div');
|
169 | var instance = null;
|
170 | var adapter = this;
|
171 | return {
|
172 | render: function () {
|
173 | function render(el, context, callback) {
|
174 | if (instance === null) {
|
175 | var type = el.type,
|
176 | props = el.props,
|
177 | ref = el.ref;
|
178 |
|
179 | var wrapperProps = (0, _object2['default'])({
|
180 | Component: type,
|
181 | props: props,
|
182 | context: context
|
183 | }, ref && { ref: ref });
|
184 | var ReactWrapperComponent = (0, _enzymeAdapterUtils.createMountWrapper)(el, (0, _object2['default'])({}, options, { adapter: adapter }));
|
185 | var wrappedEl = _react2['default'].createElement(ReactWrapperComponent, wrapperProps);
|
186 | instance = _reactDom2['default'].render(wrappedEl, domNode);
|
187 | if (typeof callback === 'function') {
|
188 | callback();
|
189 | }
|
190 | } else {
|
191 | instance.setChildProps(el.props, context, callback);
|
192 | }
|
193 | }
|
194 |
|
195 | return render;
|
196 | }(),
|
197 | unmount: function () {
|
198 | function unmount() {
|
199 | _reactDom2['default'].unmountComponentAtNode(domNode);
|
200 | instance = null;
|
201 | }
|
202 |
|
203 | return unmount;
|
204 | }(),
|
205 | getNode: function () {
|
206 | function getNode() {
|
207 | return instance ? instanceToTree(instance._reactInternalInstance).rendered : null;
|
208 | }
|
209 |
|
210 | return getNode;
|
211 | }(),
|
212 | simulateEvent: function () {
|
213 | function simulateEvent(node, event, mock) {
|
214 | var mappedEvent = (0, _enzymeAdapterUtils.mapNativeEventNames)(event, eventOptions);
|
215 | var eventFn = _testUtils2['default'].Simulate[mappedEvent];
|
216 | if (!eventFn) {
|
217 | throw new TypeError('ReactWrapper::simulate() event \'' + String(event) + '\' does not exist');
|
218 | }
|
219 |
|
220 | eventFn(_reactDom2['default'].findDOMNode(node.instance), mock);
|
221 | }
|
222 |
|
223 | return simulateEvent;
|
224 | }(),
|
225 | batchedUpdates: function () {
|
226 | function batchedUpdates(fn) {
|
227 | return _reactDom2['default'].unstable_batchedUpdates(fn);
|
228 | }
|
229 |
|
230 | return batchedUpdates;
|
231 | }()
|
232 | };
|
233 | }
|
234 |
|
235 | return createMountRenderer;
|
236 | }()
|
237 | }, {
|
238 | key: 'createShallowRenderer',
|
239 | value: function () {
|
240 | function createShallowRenderer() /* options */{
|
241 | var renderer = new _shallow2['default']();
|
242 | var isDOM = false;
|
243 | var cachedNode = null;
|
244 | return {
|
245 | render: function () {
|
246 | function render(el, context) {
|
247 | cachedNode = el;
|
248 |
|
249 | if (typeof el.type === 'string') {
|
250 | isDOM = true;
|
251 | } else {
|
252 | isDOM = false;
|
253 | return (0, _enzymeAdapterUtils.withSetStateAllowed)(function () {
|
254 | return renderer.render(el, context);
|
255 | });
|
256 | }
|
257 | }
|
258 |
|
259 | return render;
|
260 | }(),
|
261 | unmount: function () {
|
262 | function unmount() {
|
263 | renderer.unmount();
|
264 | }
|
265 |
|
266 | return unmount;
|
267 | }(),
|
268 | getNode: function () {
|
269 | function getNode() {
|
270 | if (isDOM) {
|
271 | return (0, _enzymeAdapterUtils.elementToTree)(cachedNode);
|
272 | }
|
273 | var output = renderer.getRenderOutput();
|
274 | return {
|
275 | nodeType: compositeTypeToNodeType(renderer._instance._compositeType),
|
276 | type: cachedNode.type,
|
277 | props: cachedNode.props,
|
278 | key: (0, _enzymeAdapterUtils.ensureKeyOrUndefined)(cachedNode.key),
|
279 | ref: cachedNode.ref,
|
280 | instance: renderer._instance._instance,
|
281 | rendered: (0, _enzymeAdapterUtils.elementToTree)(output)
|
282 | };
|
283 | }
|
284 |
|
285 | return getNode;
|
286 | }(),
|
287 | simulateEvent: function () {
|
288 | function simulateEvent(node, event) {
|
289 | for (var _len = arguments.length, args = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
|
290 | args[_key - 2] = arguments[_key];
|
291 | }
|
292 |
|
293 | var handler = node.props[(0, _enzymeAdapterUtils.propFromEvent)(event, eventOptions)];
|
294 | if (handler) {
|
295 | (0, _enzymeAdapterUtils.withSetStateAllowed)(function () {
|
296 |
|
297 |
|
298 | renderer.unstable_batchedUpdates(function () {
|
299 | handler.apply(undefined, _toConsumableArray(args));
|
300 | });
|
301 | });
|
302 | }
|
303 | }
|
304 |
|
305 | return simulateEvent;
|
306 | }(),
|
307 | batchedUpdates: function () {
|
308 | function batchedUpdates(fn) {
|
309 | return (0, _enzymeAdapterUtils.withSetStateAllowed)(function () {
|
310 | return renderer.unstable_batchedUpdates(fn);
|
311 | });
|
312 | }
|
313 |
|
314 | return batchedUpdates;
|
315 | }()
|
316 | };
|
317 | }
|
318 |
|
319 | return createShallowRenderer;
|
320 | }()
|
321 | }, {
|
322 | key: 'createStringRenderer',
|
323 | value: function () {
|
324 | function createStringRenderer(options) {
|
325 | return {
|
326 | render: function () {
|
327 | function render(el, context) {
|
328 | if (options.context && (el.type.contextTypes || options.childContextTypes)) {
|
329 | var childContextTypes = (0, _object2['default'])({}, el.type.contextTypes || {}, options.childContextTypes);
|
330 | var ContextWrapper = (0, _enzymeAdapterUtils.createRenderWrapper)(el, context, childContextTypes);
|
331 | return _server2['default'].renderToStaticMarkup(_react2['default'].createElement(ContextWrapper));
|
332 | }
|
333 | return _server2['default'].renderToStaticMarkup(el);
|
334 | }
|
335 |
|
336 | return render;
|
337 | }()
|
338 | };
|
339 | }
|
340 |
|
341 | return createStringRenderer;
|
342 | }()
|
343 |
|
344 |
|
345 |
|
346 |
|
347 |
|
348 | }, {
|
349 | key: 'createRenderer',
|
350 | value: function () {
|
351 | function createRenderer(options) {
|
352 | switch (options.mode) {
|
353 | case _enzyme.EnzymeAdapter.MODES.MOUNT:
|
354 | return this.createMountRenderer(options);
|
355 | case _enzyme.EnzymeAdapter.MODES.SHALLOW:
|
356 | return this.createShallowRenderer(options);
|
357 | case _enzyme.EnzymeAdapter.MODES.STRING:
|
358 | return this.createStringRenderer(options);
|
359 | default:
|
360 | throw new Error('Enzyme Internal Error: Unrecognized mode: ' + String(options.mode));
|
361 | }
|
362 | }
|
363 |
|
364 | return createRenderer;
|
365 | }()
|
366 |
|
367 |
|
368 |
|
369 |
|
370 |
|
371 |
|
372 | }, {
|
373 | key: 'nodeToElement',
|
374 | value: function () {
|
375 | function nodeToElement(node) {
|
376 | if (!node || (typeof node === 'undefined' ? 'undefined' : _typeof(node)) !== 'object') return null;
|
377 | return _react2['default'].createElement(node.type, (0, _enzymeAdapterUtils.propsWithKeysAndRef)(node));
|
378 | }
|
379 |
|
380 | return nodeToElement;
|
381 | }()
|
382 | }, {
|
383 | key: 'elementToNode',
|
384 | value: function () {
|
385 | function elementToNode(element) {
|
386 | return (0, _enzymeAdapterUtils.elementToTree)(element);
|
387 | }
|
388 |
|
389 | return elementToNode;
|
390 | }()
|
391 | }, {
|
392 | key: 'nodeToHostNode',
|
393 | value: function () {
|
394 | function nodeToHostNode(node) {
|
395 | return _reactDom2['default'].findDOMNode(node.instance);
|
396 | }
|
397 |
|
398 | return nodeToHostNode;
|
399 | }()
|
400 | }, {
|
401 | key: 'displayNameOfNode',
|
402 | value: function () {
|
403 | function displayNameOfNode(node) {
|
404 | return (0, _enzymeAdapterUtils.displayNameOfNode)(node);
|
405 | }
|
406 |
|
407 | return displayNameOfNode;
|
408 | }()
|
409 | }, {
|
410 | key: 'isValidElement',
|
411 | value: function () {
|
412 | function isValidElement(element) {
|
413 | return (0, _reactIs.isElement)(element);
|
414 | }
|
415 |
|
416 | return isValidElement;
|
417 | }()
|
418 | }, {
|
419 | key: 'isValidElementType',
|
420 | value: function () {
|
421 | function isValidElementType(object) {
|
422 | return (0, _reactIs.isValidElementType)(object);
|
423 | }
|
424 |
|
425 | return isValidElementType;
|
426 | }()
|
427 | }, {
|
428 | key: 'createElement',
|
429 | value: function () {
|
430 | function createElement() {
|
431 | return _react2['default'].createElement.apply(_react2['default'], arguments);
|
432 | }
|
433 |
|
434 | return createElement;
|
435 | }()
|
436 | }, {
|
437 | key: 'invokeSetStateCallback',
|
438 | value: function () {
|
439 | function invokeSetStateCallback(instance, callback) {
|
440 |
|
441 | callback.call(instance, undefined);
|
442 | }
|
443 |
|
444 | return invokeSetStateCallback;
|
445 | }()
|
446 | }]);
|
447 |
|
448 | return ReactFifteenAdapter;
|
449 | }(_enzyme.EnzymeAdapter);
|
450 |
|
451 | module.exports = ReactFifteenAdapter; |
\ | No newline at end of file |