Projekt

Obecné

Profil

Stáhnout (53.7 KB) Statistiky
| Větev: | Revize:
1
/** @license React v16.13.1
2
 * react-dom-test-utils.development.js
3
 *
4
 * Copyright (c) Facebook, Inc. and its affiliates.
5
 *
6
 * This source code is licensed under the MIT license found in the
7
 * LICENSE file in the root directory of this source tree.
8
 */
9

    
10
'use strict';
11

    
12
(function (global, factory) {
13
  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('react'), require('react-dom')) :
14
  typeof define === 'function' && define.amd ? define(['react', 'react-dom'], factory) :
15
  (global = global || self, global.ReactTestUtils = factory(global.React, global.ReactDOM));
16
}(this, (function (React, ReactDOM) { 'use strict';
17

    
18
  var ReactInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
19
  var _assign = ReactInternals.assign;
20

    
21
  var ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED; // Prevent newer renderers from RTE when used with older react package versions.
22
  // Current owner and dispatcher used to share the same ref,
23
  // but PR #14548 split them out to better support the react-debug-tools package.
24

    
25
  if (!ReactSharedInternals.hasOwnProperty('ReactCurrentDispatcher')) {
26
    ReactSharedInternals.ReactCurrentDispatcher = {
27
      current: null
28
    };
29
  }
30

    
31
  if (!ReactSharedInternals.hasOwnProperty('ReactCurrentBatchConfig')) {
32
    ReactSharedInternals.ReactCurrentBatchConfig = {
33
      suspense: null
34
    };
35
  }
36

    
37
  // by calls to these methods by a Babel plugin.
38
  //
39
  // In PROD (or in packages without access to React internals),
40
  // they are left as they are instead.
41

    
42
  function warn(format) {
43
    {
44
      for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
45
        args[_key - 1] = arguments[_key];
46
      }
47

    
48
      printWarning('warn', format, args);
49
    }
50
  }
51
  function error(format) {
52
    {
53
      for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
54
        args[_key2 - 1] = arguments[_key2];
55
      }
56

    
57
      printWarning('error', format, args);
58
    }
59
  }
60

    
61
  function printWarning(level, format, args) {
62
    // When changing this logic, you might want to also
63
    // update consoleWithStackDev.www.js as well.
64
    {
65
      var hasExistingStack = args.length > 0 && typeof args[args.length - 1] === 'string' && args[args.length - 1].indexOf('\n    in') === 0;
66

    
67
      if (!hasExistingStack) {
68
        var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
69
        var stack = ReactDebugCurrentFrame.getStackAddendum();
70

    
71
        if (stack !== '') {
72
          format += '%s';
73
          args = args.concat([stack]);
74
        }
75
      }
76

    
77
      var argsWithFormat = args.map(function (item) {
78
        return '' + item;
79
      }); // Careful: RN currently depends on this prefix
80

    
81
      argsWithFormat.unshift('Warning: ' + format); // We intentionally don't use spread (or .apply) directly because it
82
      // breaks IE9: https://github.com/facebook/react/issues/13610
83
      // eslint-disable-next-line react-internal/no-production-logging
84

    
85
      Function.prototype.apply.call(console[level], console, argsWithFormat);
86

    
87
      try {
88
        // --- Welcome to debugging React ---
89
        // This error was thrown as a convenience so that you can use this stack
90
        // to find the callsite that caused this warning to fire.
91
        var argIndex = 0;
92
        var message = 'Warning: ' + format.replace(/%s/g, function () {
93
          return args[argIndex++];
94
        });
95
        throw new Error(message);
96
      } catch (x) {}
97
    }
98
  }
99

    
100
  /**
101
   * `ReactInstanceMap` maintains a mapping from a public facing stateful
102
   * instance (key) and the internal representation (value). This allows public
103
   * methods to accept the user facing instance as an argument and map them back
104
   * to internal methods.
105
   *
106
   * Note that this module is currently shared and assumed to be stateless.
107
   * If this becomes an actual Map, that will break.
108
   */
109
  function get(key) {
110
    return key._reactInternalFiber;
111
  }
112

    
113
  var FunctionComponent = 0;
114
  var ClassComponent = 1;
115

    
116
  var HostRoot = 3; // Root of a host tree. Could be nested inside another node.
117

    
118
  var HostComponent = 5;
119
  var HostText = 6;
120

    
121
  // Don't change these two values. They're used by React Dev Tools.
122
  var NoEffect =
123
  /*              */
124
  0;
125

    
126
  var Placement =
127
  /*             */
128
  2;
129
  var Hydrating =
130
  /*             */
131
  1024;
132

    
133
  var ReactCurrentOwner = ReactSharedInternals.ReactCurrentOwner;
134
  function getNearestMountedFiber(fiber) {
135
    var node = fiber;
136
    var nearestMounted = fiber;
137

    
138
    if (!fiber.alternate) {
139
      // If there is no alternate, this might be a new tree that isn't inserted
140
      // yet. If it is, then it will have a pending insertion effect on it.
141
      var nextNode = node;
142

    
143
      do {
144
        node = nextNode;
145

    
146
        if ((node.effectTag & (Placement | Hydrating)) !== NoEffect) {
147
          // This is an insertion or in-progress hydration. The nearest possible
148
          // mounted fiber is the parent but we need to continue to figure out
149
          // if that one is still mounted.
150
          nearestMounted = node.return;
151
        }
152

    
153
        nextNode = node.return;
154
      } while (nextNode);
155
    } else {
156
      while (node.return) {
157
        node = node.return;
158
      }
159
    }
160

    
161
    if (node.tag === HostRoot) {
162
      // TODO: Check if this was a nested HostRoot when used with
163
      // renderContainerIntoSubtree.
164
      return nearestMounted;
165
    } // If we didn't hit the root, that means that we're in an disconnected tree
166
    // that has been unmounted.
167

    
168

    
169
    return null;
170
  }
171

    
172
  function assertIsMounted(fiber) {
173
    if (!(getNearestMountedFiber(fiber) === fiber)) {
174
      {
175
        throw Error( "Unable to find node on an unmounted component." );
176
      }
177
    }
178
  }
179

    
180
  function findCurrentFiberUsingSlowPath(fiber) {
181
    var alternate = fiber.alternate;
182

    
183
    if (!alternate) {
184
      // If there is no alternate, then we only need to check if it is mounted.
185
      var nearestMounted = getNearestMountedFiber(fiber);
186

    
187
      if (!(nearestMounted !== null)) {
188
        {
189
          throw Error( "Unable to find node on an unmounted component." );
190
        }
191
      }
192

    
193
      if (nearestMounted !== fiber) {
194
        return null;
195
      }
196

    
197
      return fiber;
198
    } // If we have two possible branches, we'll walk backwards up to the root
199
    // to see what path the root points to. On the way we may hit one of the
200
    // special cases and we'll deal with them.
201

    
202

    
203
    var a = fiber;
204
    var b = alternate;
205

    
206
    while (true) {
207
      var parentA = a.return;
208

    
209
      if (parentA === null) {
210
        // We're at the root.
211
        break;
212
      }
213

    
214
      var parentB = parentA.alternate;
215

    
216
      if (parentB === null) {
217
        // There is no alternate. This is an unusual case. Currently, it only
218
        // happens when a Suspense component is hidden. An extra fragment fiber
219
        // is inserted in between the Suspense fiber and its children. Skip
220
        // over this extra fragment fiber and proceed to the next parent.
221
        var nextParent = parentA.return;
222

    
223
        if (nextParent !== null) {
224
          a = b = nextParent;
225
          continue;
226
        } // If there's no parent, we're at the root.
227

    
228

    
229
        break;
230
      } // If both copies of the parent fiber point to the same child, we can
231
      // assume that the child is current. This happens when we bailout on low
232
      // priority: the bailed out fiber's child reuses the current child.
233

    
234

    
235
      if (parentA.child === parentB.child) {
236
        var child = parentA.child;
237

    
238
        while (child) {
239
          if (child === a) {
240
            // We've determined that A is the current branch.
241
            assertIsMounted(parentA);
242
            return fiber;
243
          }
244

    
245
          if (child === b) {
246
            // We've determined that B is the current branch.
247
            assertIsMounted(parentA);
248
            return alternate;
249
          }
250

    
251
          child = child.sibling;
252
        } // We should never have an alternate for any mounting node. So the only
253
        // way this could possibly happen is if this was unmounted, if at all.
254

    
255

    
256
        {
257
          {
258
            throw Error( "Unable to find node on an unmounted component." );
259
          }
260
        }
261
      }
262

    
263
      if (a.return !== b.return) {
264
        // The return pointer of A and the return pointer of B point to different
265
        // fibers. We assume that return pointers never criss-cross, so A must
266
        // belong to the child set of A.return, and B must belong to the child
267
        // set of B.return.
268
        a = parentA;
269
        b = parentB;
270
      } else {
271
        // The return pointers point to the same fiber. We'll have to use the
272
        // default, slow path: scan the child sets of each parent alternate to see
273
        // which child belongs to which set.
274
        //
275
        // Search parent A's child set
276
        var didFindChild = false;
277
        var _child = parentA.child;
278

    
279
        while (_child) {
280
          if (_child === a) {
281
            didFindChild = true;
282
            a = parentA;
283
            b = parentB;
284
            break;
285
          }
286

    
287
          if (_child === b) {
288
            didFindChild = true;
289
            b = parentA;
290
            a = parentB;
291
            break;
292
          }
293

    
294
          _child = _child.sibling;
295
        }
296

    
297
        if (!didFindChild) {
298
          // Search parent B's child set
299
          _child = parentB.child;
300

    
301
          while (_child) {
302
            if (_child === a) {
303
              didFindChild = true;
304
              a = parentB;
305
              b = parentA;
306
              break;
307
            }
308

    
309
            if (_child === b) {
310
              didFindChild = true;
311
              b = parentB;
312
              a = parentA;
313
              break;
314
            }
315

    
316
            _child = _child.sibling;
317
          }
318

    
319
          if (!didFindChild) {
320
            {
321
              throw Error( "Child was not found in either parent set. This indicates a bug in React related to the return pointer. Please file an issue." );
322
            }
323
          }
324
        }
325
      }
326

    
327
      if (!(a.alternate === b)) {
328
        {
329
          throw Error( "Return fibers should always be each others' alternates. This error is likely caused by a bug in React. Please file an issue." );
330
        }
331
      }
332
    } // If the root is not a host container, we're in a disconnected tree. I.e.
333
    // unmounted.
334

    
335

    
336
    if (!(a.tag === HostRoot)) {
337
      {
338
        throw Error( "Unable to find node on an unmounted component." );
339
      }
340
    }
341

    
342
    if (a.stateNode.current === a) {
343
      // We've determined that A is the current branch.
344
      return fiber;
345
    } // Otherwise B has to be current branch.
346

    
347

    
348
    return alternate;
349
  }
350

    
351
  var EVENT_POOL_SIZE = 10;
352
  /**
353
   * @interface Event
354
   * @see http://www.w3.org/TR/DOM-Level-3-Events/
355
   */
356

    
357
  var EventInterface = {
358
    type: null,
359
    target: null,
360
    // currentTarget is set when dispatching; no use in copying it here
361
    currentTarget: function () {
362
      return null;
363
    },
364
    eventPhase: null,
365
    bubbles: null,
366
    cancelable: null,
367
    timeStamp: function (event) {
368
      return event.timeStamp || Date.now();
369
    },
370
    defaultPrevented: null,
371
    isTrusted: null
372
  };
373

    
374
  function functionThatReturnsTrue() {
375
    return true;
376
  }
377

    
378
  function functionThatReturnsFalse() {
379
    return false;
380
  }
381
  /**
382
   * Synthetic events are dispatched by event plugins, typically in response to a
383
   * top-level event delegation handler.
384
   *
385
   * These systems should generally use pooling to reduce the frequency of garbage
386
   * collection. The system should check `isPersistent` to determine whether the
387
   * event should be released into the pool after being dispatched. Users that
388
   * need a persisted event should invoke `persist`.
389
   *
390
   * Synthetic events (and subclasses) implement the DOM Level 3 Events API by
391
   * normalizing browser quirks. Subclasses do not necessarily have to implement a
392
   * DOM interface; custom application-specific events can also subclass this.
393
   *
394
   * @param {object} dispatchConfig Configuration used to dispatch this event.
395
   * @param {*} targetInst Marker identifying the event target.
396
   * @param {object} nativeEvent Native browser event.
397
   * @param {DOMEventTarget} nativeEventTarget Target node.
398
   */
399

    
400

    
401
  function SyntheticEvent(dispatchConfig, targetInst, nativeEvent, nativeEventTarget) {
402
    {
403
      // these have a getter/setter for warnings
404
      delete this.nativeEvent;
405
      delete this.preventDefault;
406
      delete this.stopPropagation;
407
      delete this.isDefaultPrevented;
408
      delete this.isPropagationStopped;
409
    }
410

    
411
    this.dispatchConfig = dispatchConfig;
412
    this._targetInst = targetInst;
413
    this.nativeEvent = nativeEvent;
414
    var Interface = this.constructor.Interface;
415

    
416
    for (var propName in Interface) {
417
      if (!Interface.hasOwnProperty(propName)) {
418
        continue;
419
      }
420

    
421
      {
422
        delete this[propName]; // this has a getter/setter for warnings
423
      }
424

    
425
      var normalize = Interface[propName];
426

    
427
      if (normalize) {
428
        this[propName] = normalize(nativeEvent);
429
      } else {
430
        if (propName === 'target') {
431
          this.target = nativeEventTarget;
432
        } else {
433
          this[propName] = nativeEvent[propName];
434
        }
435
      }
436
    }
437

    
438
    var defaultPrevented = nativeEvent.defaultPrevented != null ? nativeEvent.defaultPrevented : nativeEvent.returnValue === false;
439

    
440
    if (defaultPrevented) {
441
      this.isDefaultPrevented = functionThatReturnsTrue;
442
    } else {
443
      this.isDefaultPrevented = functionThatReturnsFalse;
444
    }
445

    
446
    this.isPropagationStopped = functionThatReturnsFalse;
447
    return this;
448
  }
449

    
450
  _assign(SyntheticEvent.prototype, {
451
    preventDefault: function () {
452
      this.defaultPrevented = true;
453
      var event = this.nativeEvent;
454

    
455
      if (!event) {
456
        return;
457
      }
458

    
459
      if (event.preventDefault) {
460
        event.preventDefault();
461
      } else if (typeof event.returnValue !== 'unknown') {
462
        event.returnValue = false;
463
      }
464

    
465
      this.isDefaultPrevented = functionThatReturnsTrue;
466
    },
467
    stopPropagation: function () {
468
      var event = this.nativeEvent;
469

    
470
      if (!event) {
471
        return;
472
      }
473

    
474
      if (event.stopPropagation) {
475
        event.stopPropagation();
476
      } else if (typeof event.cancelBubble !== 'unknown') {
477
        // The ChangeEventPlugin registers a "propertychange" event for
478
        // IE. This event does not support bubbling or cancelling, and
479
        // any references to cancelBubble throw "Member not found".  A
480
        // typeof check of "unknown" circumvents this issue (and is also
481
        // IE specific).
482
        event.cancelBubble = true;
483
      }
484

    
485
      this.isPropagationStopped = functionThatReturnsTrue;
486
    },
487

    
488
    /**
489
     * We release all dispatched `SyntheticEvent`s after each event loop, adding
490
     * them back into the pool. This allows a way to hold onto a reference that
491
     * won't be added back into the pool.
492
     */
493
    persist: function () {
494
      this.isPersistent = functionThatReturnsTrue;
495
    },
496

    
497
    /**
498
     * Checks if this event should be released back into the pool.
499
     *
500
     * @return {boolean} True if this should not be released, false otherwise.
501
     */
502
    isPersistent: functionThatReturnsFalse,
503

    
504
    /**
505
     * `PooledClass` looks for `destructor` on each instance it releases.
506
     */
507
    destructor: function () {
508
      var Interface = this.constructor.Interface;
509

    
510
      for (var propName in Interface) {
511
        {
512
          Object.defineProperty(this, propName, getPooledWarningPropertyDefinition(propName, Interface[propName]));
513
        }
514
      }
515

    
516
      this.dispatchConfig = null;
517
      this._targetInst = null;
518
      this.nativeEvent = null;
519
      this.isDefaultPrevented = functionThatReturnsFalse;
520
      this.isPropagationStopped = functionThatReturnsFalse;
521
      this._dispatchListeners = null;
522
      this._dispatchInstances = null;
523

    
524
      {
525
        Object.defineProperty(this, 'nativeEvent', getPooledWarningPropertyDefinition('nativeEvent', null));
526
        Object.defineProperty(this, 'isDefaultPrevented', getPooledWarningPropertyDefinition('isDefaultPrevented', functionThatReturnsFalse));
527
        Object.defineProperty(this, 'isPropagationStopped', getPooledWarningPropertyDefinition('isPropagationStopped', functionThatReturnsFalse));
528
        Object.defineProperty(this, 'preventDefault', getPooledWarningPropertyDefinition('preventDefault', function () {}));
529
        Object.defineProperty(this, 'stopPropagation', getPooledWarningPropertyDefinition('stopPropagation', function () {}));
530
      }
531
    }
532
  });
533

    
534
  SyntheticEvent.Interface = EventInterface;
535
  /**
536
   * Helper to reduce boilerplate when creating subclasses.
537
   */
538

    
539
  SyntheticEvent.extend = function (Interface) {
540
    var Super = this;
541

    
542
    var E = function () {};
543

    
544
    E.prototype = Super.prototype;
545
    var prototype = new E();
546

    
547
    function Class() {
548
      return Super.apply(this, arguments);
549
    }
550

    
551
    _assign(prototype, Class.prototype);
552

    
553
    Class.prototype = prototype;
554
    Class.prototype.constructor = Class;
555
    Class.Interface = _assign({}, Super.Interface, Interface);
556
    Class.extend = Super.extend;
557
    addEventPoolingTo(Class);
558
    return Class;
559
  };
560

    
561
  addEventPoolingTo(SyntheticEvent);
562
  /**
563
   * Helper to nullify syntheticEvent instance properties when destructing
564
   *
565
   * @param {String} propName
566
   * @param {?object} getVal
567
   * @return {object} defineProperty object
568
   */
569

    
570
  function getPooledWarningPropertyDefinition(propName, getVal) {
571
    var isFunction = typeof getVal === 'function';
572
    return {
573
      configurable: true,
574
      set: set,
575
      get: get
576
    };
577

    
578
    function set(val) {
579
      var action = isFunction ? 'setting the method' : 'setting the property';
580
      warn(action, 'This is effectively a no-op');
581
      return val;
582
    }
583

    
584
    function get() {
585
      var action = isFunction ? 'accessing the method' : 'accessing the property';
586
      var result = isFunction ? 'This is a no-op function' : 'This is set to null';
587
      warn(action, result);
588
      return getVal;
589
    }
590

    
591
    function warn(action, result) {
592
      {
593
        error("This synthetic event is reused for performance reasons. If you're seeing this, " + "you're %s `%s` on a released/nullified synthetic event. %s. " + 'If you must keep the original synthetic event around, use event.persist(). ' + 'See https://fb.me/react-event-pooling for more information.', action, propName, result);
594
      }
595
    }
596
  }
597

    
598
  function getPooledEvent(dispatchConfig, targetInst, nativeEvent, nativeInst) {
599
    var EventConstructor = this;
600

    
601
    if (EventConstructor.eventPool.length) {
602
      var instance = EventConstructor.eventPool.pop();
603
      EventConstructor.call(instance, dispatchConfig, targetInst, nativeEvent, nativeInst);
604
      return instance;
605
    }
606

    
607
    return new EventConstructor(dispatchConfig, targetInst, nativeEvent, nativeInst);
608
  }
609

    
610
  function releasePooledEvent(event) {
611
    var EventConstructor = this;
612

    
613
    if (!(event instanceof EventConstructor)) {
614
      {
615
        throw Error( "Trying to release an event instance into a pool of a different type." );
616
      }
617
    }
618

    
619
    event.destructor();
620

    
621
    if (EventConstructor.eventPool.length < EVENT_POOL_SIZE) {
622
      EventConstructor.eventPool.push(event);
623
    }
624
  }
625

    
626
  function addEventPoolingTo(EventConstructor) {
627
    EventConstructor.eventPool = [];
628
    EventConstructor.getPooled = getPooledEvent;
629
    EventConstructor.release = releasePooledEvent;
630
  }
631

    
632
  /**
633
   * HTML nodeType values that represent the type of the node
634
   */
635
  var ELEMENT_NODE = 1;
636

    
637
  // Do not use the below two methods directly!
638
  // Instead use constants exported from DOMTopLevelEventTypes in ReactDOM.
639
  // (It is the only module that is allowed to access these methods.)
640
  function unsafeCastStringToDOMTopLevelType(topLevelType) {
641
    return topLevelType;
642
  }
643

    
644
  var canUseDOM = !!(typeof window !== 'undefined' && typeof window.document !== 'undefined' && typeof window.document.createElement !== 'undefined');
645

    
646
  /**
647
   * Generate a mapping of standard vendor prefixes using the defined style property and event name.
648
   *
649
   * @param {string} styleProp
650
   * @param {string} eventName
651
   * @returns {object}
652
   */
653

    
654
  function makePrefixMap(styleProp, eventName) {
655
    var prefixes = {};
656
    prefixes[styleProp.toLowerCase()] = eventName.toLowerCase();
657
    prefixes['Webkit' + styleProp] = 'webkit' + eventName;
658
    prefixes['Moz' + styleProp] = 'moz' + eventName;
659
    return prefixes;
660
  }
661
  /**
662
   * A list of event names to a configurable list of vendor prefixes.
663
   */
664

    
665

    
666
  var vendorPrefixes = {
667
    animationend: makePrefixMap('Animation', 'AnimationEnd'),
668
    animationiteration: makePrefixMap('Animation', 'AnimationIteration'),
669
    animationstart: makePrefixMap('Animation', 'AnimationStart'),
670
    transitionend: makePrefixMap('Transition', 'TransitionEnd')
671
  };
672
  /**
673
   * Event names that have already been detected and prefixed (if applicable).
674
   */
675

    
676
  var prefixedEventNames = {};
677
  /**
678
   * Element to check for prefixes on.
679
   */
680

    
681
  var style = {};
682
  /**
683
   * Bootstrap if a DOM exists.
684
   */
685

    
686
  if (canUseDOM) {
687
    style = document.createElement('div').style; // On some platforms, in particular some releases of Android 4.x,
688
    // the un-prefixed "animation" and "transition" properties are defined on the
689
    // style object but the events that fire will still be prefixed, so we need
690
    // to check if the un-prefixed events are usable, and if not remove them from the map.
691

    
692
    if (!('AnimationEvent' in window)) {
693
      delete vendorPrefixes.animationend.animation;
694
      delete vendorPrefixes.animationiteration.animation;
695
      delete vendorPrefixes.animationstart.animation;
696
    } // Same as above
697

    
698

    
699
    if (!('TransitionEvent' in window)) {
700
      delete vendorPrefixes.transitionend.transition;
701
    }
702
  }
703
  /**
704
   * Attempts to determine the correct vendor prefixed event name.
705
   *
706
   * @param {string} eventName
707
   * @returns {string}
708
   */
709

    
710

    
711
  function getVendorPrefixedEventName(eventName) {
712
    if (prefixedEventNames[eventName]) {
713
      return prefixedEventNames[eventName];
714
    } else if (!vendorPrefixes[eventName]) {
715
      return eventName;
716
    }
717

    
718
    var prefixMap = vendorPrefixes[eventName];
719

    
720
    for (var styleProp in prefixMap) {
721
      if (prefixMap.hasOwnProperty(styleProp) && styleProp in style) {
722
        return prefixedEventNames[eventName] = prefixMap[styleProp];
723
      }
724
    }
725

    
726
    return eventName;
727
  }
728

    
729
  /**
730
   * To identify top level events in ReactDOM, we use constants defined by this
731
   * module. This is the only module that uses the unsafe* methods to express
732
   * that the constants actually correspond to the browser event names. This lets
733
   * us save some bundle size by avoiding a top level type -> event name map.
734
   * The rest of ReactDOM code should import top level types from this file.
735
   */
736

    
737
  var TOP_ABORT = unsafeCastStringToDOMTopLevelType('abort');
738
  var TOP_ANIMATION_END = unsafeCastStringToDOMTopLevelType(getVendorPrefixedEventName('animationend'));
739
  var TOP_ANIMATION_ITERATION = unsafeCastStringToDOMTopLevelType(getVendorPrefixedEventName('animationiteration'));
740
  var TOP_ANIMATION_START = unsafeCastStringToDOMTopLevelType(getVendorPrefixedEventName('animationstart'));
741
  var TOP_BLUR = unsafeCastStringToDOMTopLevelType('blur');
742
  var TOP_CAN_PLAY = unsafeCastStringToDOMTopLevelType('canplay');
743
  var TOP_CAN_PLAY_THROUGH = unsafeCastStringToDOMTopLevelType('canplaythrough');
744
  var TOP_CANCEL = unsafeCastStringToDOMTopLevelType('cancel');
745
  var TOP_CHANGE = unsafeCastStringToDOMTopLevelType('change');
746
  var TOP_CLICK = unsafeCastStringToDOMTopLevelType('click');
747
  var TOP_CLOSE = unsafeCastStringToDOMTopLevelType('close');
748
  var TOP_COMPOSITION_END = unsafeCastStringToDOMTopLevelType('compositionend');
749
  var TOP_COMPOSITION_START = unsafeCastStringToDOMTopLevelType('compositionstart');
750
  var TOP_COMPOSITION_UPDATE = unsafeCastStringToDOMTopLevelType('compositionupdate');
751
  var TOP_CONTEXT_MENU = unsafeCastStringToDOMTopLevelType('contextmenu');
752
  var TOP_COPY = unsafeCastStringToDOMTopLevelType('copy');
753
  var TOP_CUT = unsafeCastStringToDOMTopLevelType('cut');
754
  var TOP_DOUBLE_CLICK = unsafeCastStringToDOMTopLevelType('dblclick');
755
  var TOP_DRAG = unsafeCastStringToDOMTopLevelType('drag');
756
  var TOP_DRAG_END = unsafeCastStringToDOMTopLevelType('dragend');
757
  var TOP_DRAG_ENTER = unsafeCastStringToDOMTopLevelType('dragenter');
758
  var TOP_DRAG_EXIT = unsafeCastStringToDOMTopLevelType('dragexit');
759
  var TOP_DRAG_LEAVE = unsafeCastStringToDOMTopLevelType('dragleave');
760
  var TOP_DRAG_OVER = unsafeCastStringToDOMTopLevelType('dragover');
761
  var TOP_DRAG_START = unsafeCastStringToDOMTopLevelType('dragstart');
762
  var TOP_DROP = unsafeCastStringToDOMTopLevelType('drop');
763
  var TOP_DURATION_CHANGE = unsafeCastStringToDOMTopLevelType('durationchange');
764
  var TOP_EMPTIED = unsafeCastStringToDOMTopLevelType('emptied');
765
  var TOP_ENCRYPTED = unsafeCastStringToDOMTopLevelType('encrypted');
766
  var TOP_ENDED = unsafeCastStringToDOMTopLevelType('ended');
767
  var TOP_ERROR = unsafeCastStringToDOMTopLevelType('error');
768
  var TOP_FOCUS = unsafeCastStringToDOMTopLevelType('focus');
769
  var TOP_INPUT = unsafeCastStringToDOMTopLevelType('input');
770
  var TOP_KEY_DOWN = unsafeCastStringToDOMTopLevelType('keydown');
771
  var TOP_KEY_PRESS = unsafeCastStringToDOMTopLevelType('keypress');
772
  var TOP_KEY_UP = unsafeCastStringToDOMTopLevelType('keyup');
773
  var TOP_LOAD = unsafeCastStringToDOMTopLevelType('load');
774
  var TOP_LOAD_START = unsafeCastStringToDOMTopLevelType('loadstart');
775
  var TOP_LOADED_DATA = unsafeCastStringToDOMTopLevelType('loadeddata');
776
  var TOP_LOADED_METADATA = unsafeCastStringToDOMTopLevelType('loadedmetadata');
777
  var TOP_MOUSE_DOWN = unsafeCastStringToDOMTopLevelType('mousedown');
778
  var TOP_MOUSE_MOVE = unsafeCastStringToDOMTopLevelType('mousemove');
779
  var TOP_MOUSE_OUT = unsafeCastStringToDOMTopLevelType('mouseout');
780
  var TOP_MOUSE_OVER = unsafeCastStringToDOMTopLevelType('mouseover');
781
  var TOP_MOUSE_UP = unsafeCastStringToDOMTopLevelType('mouseup');
782
  var TOP_PASTE = unsafeCastStringToDOMTopLevelType('paste');
783
  var TOP_PAUSE = unsafeCastStringToDOMTopLevelType('pause');
784
  var TOP_PLAY = unsafeCastStringToDOMTopLevelType('play');
785
  var TOP_PLAYING = unsafeCastStringToDOMTopLevelType('playing');
786
  var TOP_PROGRESS = unsafeCastStringToDOMTopLevelType('progress');
787
  var TOP_RATE_CHANGE = unsafeCastStringToDOMTopLevelType('ratechange');
788
  var TOP_SCROLL = unsafeCastStringToDOMTopLevelType('scroll');
789
  var TOP_SEEKED = unsafeCastStringToDOMTopLevelType('seeked');
790
  var TOP_SEEKING = unsafeCastStringToDOMTopLevelType('seeking');
791
  var TOP_SELECTION_CHANGE = unsafeCastStringToDOMTopLevelType('selectionchange');
792
  var TOP_STALLED = unsafeCastStringToDOMTopLevelType('stalled');
793
  var TOP_SUSPEND = unsafeCastStringToDOMTopLevelType('suspend');
794
  var TOP_TEXT_INPUT = unsafeCastStringToDOMTopLevelType('textInput');
795
  var TOP_TIME_UPDATE = unsafeCastStringToDOMTopLevelType('timeupdate');
796
  var TOP_TOGGLE = unsafeCastStringToDOMTopLevelType('toggle');
797
  var TOP_TOUCH_CANCEL = unsafeCastStringToDOMTopLevelType('touchcancel');
798
  var TOP_TOUCH_END = unsafeCastStringToDOMTopLevelType('touchend');
799
  var TOP_TOUCH_MOVE = unsafeCastStringToDOMTopLevelType('touchmove');
800
  var TOP_TOUCH_START = unsafeCastStringToDOMTopLevelType('touchstart');
801
  var TOP_TRANSITION_END = unsafeCastStringToDOMTopLevelType(getVendorPrefixedEventName('transitionend'));
802
  var TOP_VOLUME_CHANGE = unsafeCastStringToDOMTopLevelType('volumechange');
803
  var TOP_WAITING = unsafeCastStringToDOMTopLevelType('waiting');
804
  var TOP_WHEEL = unsafeCastStringToDOMTopLevelType('wheel'); // List of events that need to be individually attached to media elements.
805

    
806
  var PLUGIN_EVENT_SYSTEM = 1;
807

    
808
  var didWarnAboutMessageChannel = false;
809
  var enqueueTaskImpl = null;
810
  function enqueueTask(task) {
811
    if (enqueueTaskImpl === null) {
812
      try {
813
        // read require off the module object to get around the bundlers.
814
        // we don't want them to detect a require and bundle a Node polyfill.
815
        var requireString = ('require' + Math.random()).slice(0, 7);
816
        var nodeRequire = module && module[requireString]; // assuming we're in node, let's try to get node's
817
        // version of setImmediate, bypassing fake timers if any.
818

    
819
        enqueueTaskImpl = nodeRequire('timers').setImmediate;
820
      } catch (_err) {
821
        // we're in a browser
822
        // we can't use regular timers because they may still be faked
823
        // so we try MessageChannel+postMessage instead
824
        enqueueTaskImpl = function (callback) {
825
          {
826
            if (didWarnAboutMessageChannel === false) {
827
              didWarnAboutMessageChannel = true;
828

    
829
              if (typeof MessageChannel === 'undefined') {
830
                error('This browser does not have a MessageChannel implementation, ' + 'so enqueuing tasks via await act(async () => ...) will fail. ' + 'Please file an issue at https://github.com/facebook/react/issues ' + 'if you encounter this warning.');
831
              }
832
            }
833
          }
834

    
835
          var channel = new MessageChannel();
836
          channel.port1.onmessage = callback;
837
          channel.port2.postMessage(undefined);
838
        };
839
      }
840
    }
841

    
842
    return enqueueTaskImpl(task);
843
  }
844

    
845
  var ReactInternals$1 = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
846
  var _ReactInternals$Sched = ReactInternals$1.Scheduler,
847
      unstable_cancelCallback = _ReactInternals$Sched.unstable_cancelCallback,
848
      unstable_now = _ReactInternals$Sched.unstable_now,
849
      unstable_scheduleCallback = _ReactInternals$Sched.unstable_scheduleCallback,
850
      unstable_shouldYield = _ReactInternals$Sched.unstable_shouldYield,
851
      unstable_requestPaint = _ReactInternals$Sched.unstable_requestPaint,
852
      unstable_getFirstCallbackNode = _ReactInternals$Sched.unstable_getFirstCallbackNode,
853
      unstable_runWithPriority = _ReactInternals$Sched.unstable_runWithPriority,
854
      unstable_next = _ReactInternals$Sched.unstable_next,
855
      unstable_continueExecution = _ReactInternals$Sched.unstable_continueExecution,
856
      unstable_pauseExecution = _ReactInternals$Sched.unstable_pauseExecution,
857
      unstable_getCurrentPriorityLevel = _ReactInternals$Sched.unstable_getCurrentPriorityLevel,
858
      unstable_ImmediatePriority = _ReactInternals$Sched.unstable_ImmediatePriority,
859
      unstable_UserBlockingPriority = _ReactInternals$Sched.unstable_UserBlockingPriority,
860
      unstable_NormalPriority = _ReactInternals$Sched.unstable_NormalPriority,
861
      unstable_LowPriority = _ReactInternals$Sched.unstable_LowPriority,
862
      unstable_IdlePriority = _ReactInternals$Sched.unstable_IdlePriority,
863
      unstable_forceFrameRate = _ReactInternals$Sched.unstable_forceFrameRate,
864
      unstable_flushAllWithoutAsserting = _ReactInternals$Sched.unstable_flushAllWithoutAsserting;
865

    
866
  // ReactDOM.js, and ReactTestUtils.js:
867

    
868
  var _ReactDOM$__SECRET_IN = ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.Events,
869

    
870
  /* eslint-disable no-unused-vars */
871
  getInstanceFromNode = _ReactDOM$__SECRET_IN[0],
872
      getNodeFromInstance = _ReactDOM$__SECRET_IN[1],
873
      getFiberCurrentPropsFromNode = _ReactDOM$__SECRET_IN[2],
874
      injectEventPluginsByName = _ReactDOM$__SECRET_IN[3],
875
      eventNameDispatchConfigs = _ReactDOM$__SECRET_IN[4],
876
      accumulateTwoPhaseDispatches = _ReactDOM$__SECRET_IN[5],
877
      accumulateDirectDispatches = _ReactDOM$__SECRET_IN[6],
878
      enqueueStateRestore = _ReactDOM$__SECRET_IN[7],
879
      restoreStateIfNeeded = _ReactDOM$__SECRET_IN[8],
880
      dispatchEvent = _ReactDOM$__SECRET_IN[9],
881
      runEventsInBatch = _ReactDOM$__SECRET_IN[10],
882

    
883
  /* eslint-enable no-unused-vars */
884
  flushPassiveEffects = _ReactDOM$__SECRET_IN[11],
885
      IsThisRendererActing = _ReactDOM$__SECRET_IN[12];
886
  var batchedUpdates = ReactDOM.unstable_batchedUpdates;
887
  var IsSomeRendererActing = ReactSharedInternals.IsSomeRendererActing; // this implementation should be exactly the same in
888
  // ReactTestUtilsAct.js, ReactTestRendererAct.js, createReactNoop.js
889

    
890
  var isSchedulerMocked = typeof unstable_flushAllWithoutAsserting === 'function';
891

    
892
  var flushWork = unstable_flushAllWithoutAsserting || function () {
893
    var didFlushWork = false;
894

    
895
    while (flushPassiveEffects()) {
896
      didFlushWork = true;
897
    }
898

    
899
    return didFlushWork;
900
  };
901

    
902
  function flushWorkAndMicroTasks(onDone) {
903
    try {
904
      flushWork();
905
      enqueueTask(function () {
906
        if (flushWork()) {
907
          flushWorkAndMicroTasks(onDone);
908
        } else {
909
          onDone();
910
        }
911
      });
912
    } catch (err) {
913
      onDone(err);
914
    }
915
  } // we track the 'depth' of the act() calls with this counter,
916
  // so we can tell if any async act() calls try to run in parallel.
917

    
918

    
919
  var actingUpdatesScopeDepth = 0;
920

    
921
  function act(callback) {
922

    
923
    var previousActingUpdatesScopeDepth = actingUpdatesScopeDepth;
924
    var previousIsSomeRendererActing;
925
    var previousIsThisRendererActing;
926
    actingUpdatesScopeDepth++;
927
    previousIsSomeRendererActing = IsSomeRendererActing.current;
928
    previousIsThisRendererActing = IsThisRendererActing.current;
929
    IsSomeRendererActing.current = true;
930
    IsThisRendererActing.current = true;
931

    
932
    function onDone() {
933
      actingUpdatesScopeDepth--;
934
      IsSomeRendererActing.current = previousIsSomeRendererActing;
935
      IsThisRendererActing.current = previousIsThisRendererActing;
936

    
937
      {
938
        if (actingUpdatesScopeDepth > previousActingUpdatesScopeDepth) {
939
          // if it's _less than_ previousActingUpdatesScopeDepth, then we can assume the 'other' one has warned
940
          error('You seem to have overlapping act() calls, this is not supported. ' + 'Be sure to await previous act() calls before making a new one. ');
941
        }
942
      }
943
    }
944

    
945
    var result;
946

    
947
    try {
948
      result = batchedUpdates(callback);
949
    } catch (error) {
950
      // on sync errors, we still want to 'cleanup' and decrement actingUpdatesScopeDepth
951
      onDone();
952
      throw error;
953
    }
954

    
955
    if (result !== null && typeof result === 'object' && typeof result.then === 'function') {
956
      // setup a boolean that gets set to true only
957
      // once this act() call is await-ed
958
      var called = false;
959

    
960
      {
961
        if (typeof Promise !== 'undefined') {
962
          //eslint-disable-next-line no-undef
963
          Promise.resolve().then(function () {}).then(function () {
964
            if (called === false) {
965
              error('You called act(async () => ...) without await. ' + 'This could lead to unexpected testing behaviour, interleaving multiple act ' + 'calls and mixing their scopes. You should - await act(async () => ...);');
966
            }
967
          });
968
        }
969
      } // in the async case, the returned thenable runs the callback, flushes
970
      // effects and  microtasks in a loop until flushPassiveEffects() === false,
971
      // and cleans up
972

    
973

    
974
      return {
975
        then: function (resolve, reject) {
976
          called = true;
977
          result.then(function () {
978
            if (actingUpdatesScopeDepth > 1 || isSchedulerMocked === true && previousIsSomeRendererActing === true) {
979
              onDone();
980
              resolve();
981
              return;
982
            } // we're about to exit the act() scope,
983
            // now's the time to flush tasks/effects
984

    
985

    
986
            flushWorkAndMicroTasks(function (err) {
987
              onDone();
988

    
989
              if (err) {
990
                reject(err);
991
              } else {
992
                resolve();
993
              }
994
            });
995
          }, function (err) {
996
            onDone();
997
            reject(err);
998
          });
999
        }
1000
      };
1001
    } else {
1002
      {
1003
        if (result !== undefined) {
1004
          error('The callback passed to act(...) function ' + 'must return undefined, or a Promise. You returned %s', result);
1005
        }
1006
      } // flush effects until none remain, and cleanup
1007

    
1008

    
1009
      try {
1010
        if (actingUpdatesScopeDepth === 1 && (isSchedulerMocked === false || previousIsSomeRendererActing === false)) {
1011
          // we're about to exit the act() scope,
1012
          // now's the time to flush effects
1013
          flushWork();
1014
        }
1015

    
1016
        onDone();
1017
      } catch (err) {
1018
        onDone();
1019
        throw err;
1020
      } // in the sync case, the returned thenable only warns *if* await-ed
1021

    
1022

    
1023
      return {
1024
        then: function (resolve) {
1025
          {
1026
            error('Do not await the result of calling act(...) with sync logic, it is not a Promise.');
1027
          }
1028

    
1029
          resolve();
1030
        }
1031
      };
1032
    }
1033
  }
1034

    
1035
  var findDOMNode = ReactDOM.findDOMNode; // Keep in sync with ReactDOMUnstableNativeDependencies.js
1036
  // ReactDOM.js, and ReactTestUtilsAct.js:
1037

    
1038
  var _ReactDOM$__SECRET_IN$1 = ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.Events,
1039
      getInstanceFromNode$1 = _ReactDOM$__SECRET_IN$1[0],
1040

    
1041
  /* eslint-disable no-unused-vars */
1042
  getNodeFromInstance$1 = _ReactDOM$__SECRET_IN$1[1],
1043
      getFiberCurrentPropsFromNode$1 = _ReactDOM$__SECRET_IN$1[2],
1044
      injectEventPluginsByName$1 = _ReactDOM$__SECRET_IN$1[3],
1045

    
1046
  /* eslint-enable no-unused-vars */
1047
  eventNameDispatchConfigs$1 = _ReactDOM$__SECRET_IN$1[4],
1048
      accumulateTwoPhaseDispatches$1 = _ReactDOM$__SECRET_IN$1[5],
1049
      accumulateDirectDispatches$1 = _ReactDOM$__SECRET_IN$1[6],
1050
      enqueueStateRestore$1 = _ReactDOM$__SECRET_IN$1[7],
1051
      restoreStateIfNeeded$1 = _ReactDOM$__SECRET_IN$1[8],
1052
      dispatchEvent$1 = _ReactDOM$__SECRET_IN$1[9],
1053
      runEventsInBatch$1 = _ReactDOM$__SECRET_IN$1[10],
1054

    
1055
  /* eslint-disable no-unused-vars */
1056
  flushPassiveEffects$1 = _ReactDOM$__SECRET_IN$1[11],
1057
      IsThisRendererActing$1
1058
  /* eslint-enable no-unused-vars */
1059
  = _ReactDOM$__SECRET_IN$1[12];
1060

    
1061
  function Event(suffix) {}
1062

    
1063
  var hasWarnedAboutDeprecatedMockComponent = false;
1064
  /**
1065
   * @class ReactTestUtils
1066
   */
1067

    
1068
  /**
1069
   * Simulates a top level event being dispatched from a raw event that occurred
1070
   * on an `Element` node.
1071
   * @param {number} topLevelType A number from `TopLevelEventTypes`
1072
   * @param {!Element} node The dom to simulate an event occurring on.
1073
   * @param {?Event} fakeNativeEvent Fake native event to use in SyntheticEvent.
1074
   */
1075

    
1076
  function simulateNativeEventOnNode(topLevelType, node, fakeNativeEvent) {
1077
    fakeNativeEvent.target = node;
1078
    dispatchEvent$1(topLevelType, PLUGIN_EVENT_SYSTEM, document, fakeNativeEvent);
1079
  }
1080
  /**
1081
   * Simulates a top level event being dispatched from a raw event that occurred
1082
   * on the `ReactDOMComponent` `comp`.
1083
   * @param {Object} topLevelType A type from `BrowserEventConstants.topLevelTypes`.
1084
   * @param {!ReactDOMComponent} comp
1085
   * @param {?Event} fakeNativeEvent Fake native event to use in SyntheticEvent.
1086
   */
1087

    
1088

    
1089
  function simulateNativeEventOnDOMComponent(topLevelType, comp, fakeNativeEvent) {
1090
    simulateNativeEventOnNode(topLevelType, findDOMNode(comp), fakeNativeEvent);
1091
  }
1092

    
1093
  function findAllInRenderedFiberTreeInternal(fiber, test) {
1094
    if (!fiber) {
1095
      return [];
1096
    }
1097

    
1098
    var currentParent = findCurrentFiberUsingSlowPath(fiber);
1099

    
1100
    if (!currentParent) {
1101
      return [];
1102
    }
1103

    
1104
    var node = currentParent;
1105
    var ret = [];
1106

    
1107
    while (true) {
1108
      if (node.tag === HostComponent || node.tag === HostText || node.tag === ClassComponent || node.tag === FunctionComponent) {
1109
        var publicInst = node.stateNode;
1110

    
1111
        if (test(publicInst)) {
1112
          ret.push(publicInst);
1113
        }
1114
      }
1115

    
1116
      if (node.child) {
1117
        node.child.return = node;
1118
        node = node.child;
1119
        continue;
1120
      }
1121

    
1122
      if (node === currentParent) {
1123
        return ret;
1124
      }
1125

    
1126
      while (!node.sibling) {
1127
        if (!node.return || node.return === currentParent) {
1128
          return ret;
1129
        }
1130

    
1131
        node = node.return;
1132
      }
1133

    
1134
      node.sibling.return = node.return;
1135
      node = node.sibling;
1136
    }
1137
  }
1138

    
1139
  function validateClassInstance(inst, methodName) {
1140
    if (!inst) {
1141
      // This is probably too relaxed but it's existing behavior.
1142
      return;
1143
    }
1144

    
1145
    if (get(inst)) {
1146
      // This is a public instance indeed.
1147
      return;
1148
    }
1149

    
1150
    var received;
1151
    var stringified = '' + inst;
1152

    
1153
    if (Array.isArray(inst)) {
1154
      received = 'an array';
1155
    } else if (inst && inst.nodeType === ELEMENT_NODE && inst.tagName) {
1156
      received = 'a DOM node';
1157
    } else if (stringified === '[object Object]') {
1158
      received = 'object with keys {' + Object.keys(inst).join(', ') + '}';
1159
    } else {
1160
      received = stringified;
1161
    }
1162

    
1163
    {
1164
      {
1165
        throw Error( methodName + "(...): the first argument must be a React class instance. Instead received: " + received + "." );
1166
      }
1167
    }
1168
  }
1169
  /**
1170
   * Utilities for making it easy to test React components.
1171
   *
1172
   * See https://reactjs.org/docs/test-utils.html
1173
   *
1174
   * Todo: Support the entire DOM.scry query syntax. For now, these simple
1175
   * utilities will suffice for testing purposes.
1176
   * @lends ReactTestUtils
1177
   */
1178

    
1179

    
1180
  var ReactTestUtils = {
1181
    renderIntoDocument: function (element) {
1182
      var div = document.createElement('div'); // None of our tests actually require attaching the container to the
1183
      // DOM, and doing so creates a mess that we rely on test isolation to
1184
      // clean up, so we're going to stop honoring the name of this method
1185
      // (and probably rename it eventually) if no problems arise.
1186
      // document.documentElement.appendChild(div);
1187

    
1188
      return ReactDOM.render(element, div);
1189
    },
1190
    isElement: function (element) {
1191
      return React.isValidElement(element);
1192
    },
1193
    isElementOfType: function (inst, convenienceConstructor) {
1194
      return React.isValidElement(inst) && inst.type === convenienceConstructor;
1195
    },
1196
    isDOMComponent: function (inst) {
1197
      return !!(inst && inst.nodeType === ELEMENT_NODE && inst.tagName);
1198
    },
1199
    isDOMComponentElement: function (inst) {
1200
      return !!(inst && React.isValidElement(inst) && !!inst.tagName);
1201
    },
1202
    isCompositeComponent: function (inst) {
1203
      if (ReactTestUtils.isDOMComponent(inst)) {
1204
        // Accessing inst.setState warns; just return false as that'll be what
1205
        // this returns when we have DOM nodes as refs directly
1206
        return false;
1207
      }
1208

    
1209
      return inst != null && typeof inst.render === 'function' && typeof inst.setState === 'function';
1210
    },
1211
    isCompositeComponentWithType: function (inst, type) {
1212
      if (!ReactTestUtils.isCompositeComponent(inst)) {
1213
        return false;
1214
      }
1215

    
1216
      var internalInstance = get(inst);
1217
      var constructor = internalInstance.type;
1218
      return constructor === type;
1219
    },
1220
    findAllInRenderedTree: function (inst, test) {
1221
      validateClassInstance(inst, 'findAllInRenderedTree');
1222

    
1223
      if (!inst) {
1224
        return [];
1225
      }
1226

    
1227
      var internalInstance = get(inst);
1228
      return findAllInRenderedFiberTreeInternal(internalInstance, test);
1229
    },
1230

    
1231
    /**
1232
     * Finds all instance of components in the rendered tree that are DOM
1233
     * components with the class name matching `className`.
1234
     * @return {array} an array of all the matches.
1235
     */
1236
    scryRenderedDOMComponentsWithClass: function (root, classNames) {
1237
      validateClassInstance(root, 'scryRenderedDOMComponentsWithClass');
1238
      return ReactTestUtils.findAllInRenderedTree(root, function (inst) {
1239
        if (ReactTestUtils.isDOMComponent(inst)) {
1240
          var className = inst.className;
1241

    
1242
          if (typeof className !== 'string') {
1243
            // SVG, probably.
1244
            className = inst.getAttribute('class') || '';
1245
          }
1246

    
1247
          var classList = className.split(/\s+/);
1248

    
1249
          if (!Array.isArray(classNames)) {
1250
            if (!(classNames !== undefined)) {
1251
              {
1252
                throw Error( "TestUtils.scryRenderedDOMComponentsWithClass expects a className as a second argument." );
1253
              }
1254
            }
1255

    
1256
            classNames = classNames.split(/\s+/);
1257
          }
1258

    
1259
          return classNames.every(function (name) {
1260
            return classList.indexOf(name) !== -1;
1261
          });
1262
        }
1263

    
1264
        return false;
1265
      });
1266
    },
1267

    
1268
    /**
1269
     * Like scryRenderedDOMComponentsWithClass but expects there to be one result,
1270
     * and returns that one result, or throws exception if there is any other
1271
     * number of matches besides one.
1272
     * @return {!ReactDOMComponent} The one match.
1273
     */
1274
    findRenderedDOMComponentWithClass: function (root, className) {
1275
      validateClassInstance(root, 'findRenderedDOMComponentWithClass');
1276
      var all = ReactTestUtils.scryRenderedDOMComponentsWithClass(root, className);
1277

    
1278
      if (all.length !== 1) {
1279
        throw new Error('Did not find exactly one match (found: ' + all.length + ') ' + 'for class:' + className);
1280
      }
1281

    
1282
      return all[0];
1283
    },
1284

    
1285
    /**
1286
     * Finds all instance of components in the rendered tree that are DOM
1287
     * components with the tag name matching `tagName`.
1288
     * @return {array} an array of all the matches.
1289
     */
1290
    scryRenderedDOMComponentsWithTag: function (root, tagName) {
1291
      validateClassInstance(root, 'scryRenderedDOMComponentsWithTag');
1292
      return ReactTestUtils.findAllInRenderedTree(root, function (inst) {
1293
        return ReactTestUtils.isDOMComponent(inst) && inst.tagName.toUpperCase() === tagName.toUpperCase();
1294
      });
1295
    },
1296

    
1297
    /**
1298
     * Like scryRenderedDOMComponentsWithTag but expects there to be one result,
1299
     * and returns that one result, or throws exception if there is any other
1300
     * number of matches besides one.
1301
     * @return {!ReactDOMComponent} The one match.
1302
     */
1303
    findRenderedDOMComponentWithTag: function (root, tagName) {
1304
      validateClassInstance(root, 'findRenderedDOMComponentWithTag');
1305
      var all = ReactTestUtils.scryRenderedDOMComponentsWithTag(root, tagName);
1306

    
1307
      if (all.length !== 1) {
1308
        throw new Error('Did not find exactly one match (found: ' + all.length + ') ' + 'for tag:' + tagName);
1309
      }
1310

    
1311
      return all[0];
1312
    },
1313

    
1314
    /**
1315
     * Finds all instances of components with type equal to `componentType`.
1316
     * @return {array} an array of all the matches.
1317
     */
1318
    scryRenderedComponentsWithType: function (root, componentType) {
1319
      validateClassInstance(root, 'scryRenderedComponentsWithType');
1320
      return ReactTestUtils.findAllInRenderedTree(root, function (inst) {
1321
        return ReactTestUtils.isCompositeComponentWithType(inst, componentType);
1322
      });
1323
    },
1324

    
1325
    /**
1326
     * Same as `scryRenderedComponentsWithType` but expects there to be one result
1327
     * and returns that one result, or throws exception if there is any other
1328
     * number of matches besides one.
1329
     * @return {!ReactComponent} The one match.
1330
     */
1331
    findRenderedComponentWithType: function (root, componentType) {
1332
      validateClassInstance(root, 'findRenderedComponentWithType');
1333
      var all = ReactTestUtils.scryRenderedComponentsWithType(root, componentType);
1334

    
1335
      if (all.length !== 1) {
1336
        throw new Error('Did not find exactly one match (found: ' + all.length + ') ' + 'for componentType:' + componentType);
1337
      }
1338

    
1339
      return all[0];
1340
    },
1341

    
1342
    /**
1343
     * Pass a mocked component module to this method to augment it with
1344
     * useful methods that allow it to be used as a dummy React component.
1345
     * Instead of rendering as usual, the component will become a simple
1346
     * <div> containing any provided children.
1347
     *
1348
     * @param {object} module the mock function object exported from a
1349
     *                        module that defines the component to be mocked
1350
     * @param {?string} mockTagName optional dummy root tag name to return
1351
     *                              from render method (overrides
1352
     *                              module.mockTagName if provided)
1353
     * @return {object} the ReactTestUtils object (for chaining)
1354
     */
1355
    mockComponent: function (module, mockTagName) {
1356
      {
1357
        if (!hasWarnedAboutDeprecatedMockComponent) {
1358
          hasWarnedAboutDeprecatedMockComponent = true;
1359

    
1360
          warn('ReactTestUtils.mockComponent() is deprecated. ' + 'Use shallow rendering or jest.mock() instead.\n\n' + 'See https://fb.me/test-utils-mock-component for more information.');
1361
        }
1362
      }
1363

    
1364
      mockTagName = mockTagName || module.mockTagName || 'div';
1365
      module.prototype.render.mockImplementation(function () {
1366
        return React.createElement(mockTagName, null, this.props.children);
1367
      });
1368
      return this;
1369
    },
1370
    nativeTouchData: function (x, y) {
1371
      return {
1372
        touches: [{
1373
          pageX: x,
1374
          pageY: y
1375
        }]
1376
      };
1377
    },
1378
    Simulate: null,
1379
    SimulateNative: {},
1380
    act: act
1381
  };
1382
  /**
1383
   * Exports:
1384
   *
1385
   * - `ReactTestUtils.Simulate.click(Element)`
1386
   * - `ReactTestUtils.Simulate.mouseMove(Element)`
1387
   * - `ReactTestUtils.Simulate.change(Element)`
1388
   * - ... (All keys from event plugin `eventTypes` objects)
1389
   */
1390

    
1391
  function makeSimulator(eventType) {
1392
    return function (domNode, eventData) {
1393
      if (!!React.isValidElement(domNode)) {
1394
        {
1395
          throw Error( "TestUtils.Simulate expected a DOM node as the first argument but received a React element. Pass the DOM node you wish to simulate the event on instead. Note that TestUtils.Simulate will not work if you are using shallow rendering." );
1396
        }
1397
      }
1398

    
1399
      if (!!ReactTestUtils.isCompositeComponent(domNode)) {
1400
        {
1401
          throw Error( "TestUtils.Simulate expected a DOM node as the first argument but received a component instance. Pass the DOM node you wish to simulate the event on instead." );
1402
        }
1403
      }
1404

    
1405
      var dispatchConfig = eventNameDispatchConfigs$1[eventType];
1406
      var fakeNativeEvent = new Event();
1407
      fakeNativeEvent.target = domNode;
1408
      fakeNativeEvent.type = eventType.toLowerCase(); // We don't use SyntheticEvent.getPooled in order to not have to worry about
1409
      // properly destroying any properties assigned from `eventData` upon release
1410

    
1411
      var targetInst = getInstanceFromNode$1(domNode);
1412
      var event = new SyntheticEvent(dispatchConfig, targetInst, fakeNativeEvent, domNode); // Since we aren't using pooling, always persist the event. This will make
1413
      // sure it's marked and won't warn when setting additional properties.
1414

    
1415
      event.persist();
1416

    
1417
      _assign(event, eventData);
1418

    
1419
      if (dispatchConfig.phasedRegistrationNames) {
1420
        accumulateTwoPhaseDispatches$1(event);
1421
      } else {
1422
        accumulateDirectDispatches$1(event);
1423
      }
1424

    
1425
      ReactDOM.unstable_batchedUpdates(function () {
1426
        // Normally extractEvent enqueues a state restore, but we'll just always
1427
        // do that since we're by-passing it here.
1428
        enqueueStateRestore$1(domNode);
1429
        runEventsInBatch$1(event);
1430
      });
1431
      restoreStateIfNeeded$1();
1432
    };
1433
  }
1434

    
1435
  function buildSimulators() {
1436
    ReactTestUtils.Simulate = {};
1437
    var eventType;
1438

    
1439
    for (eventType in eventNameDispatchConfigs$1) {
1440
      /**
1441
       * @param {!Element|ReactDOMComponent} domComponentOrNode
1442
       * @param {?object} eventData Fake event data to use in SyntheticEvent.
1443
       */
1444
      ReactTestUtils.Simulate[eventType] = makeSimulator(eventType);
1445
    }
1446
  }
1447

    
1448
  buildSimulators();
1449
  /**
1450
   * Exports:
1451
   *
1452
   * - `ReactTestUtils.SimulateNative.click(Element/ReactDOMComponent)`
1453
   * - `ReactTestUtils.SimulateNative.mouseMove(Element/ReactDOMComponent)`
1454
   * - `ReactTestUtils.SimulateNative.mouseIn/ReactDOMComponent)`
1455
   * - `ReactTestUtils.SimulateNative.mouseOut(Element/ReactDOMComponent)`
1456
   * - ... (All keys from `BrowserEventConstants.topLevelTypes`)
1457
   *
1458
   * Note: Top level event types are a subset of the entire set of handler types
1459
   * (which include a broader set of "synthetic" events). For example, onDragDone
1460
   * is a synthetic event. Except when testing an event plugin or React's event
1461
   * handling code specifically, you probably want to use ReactTestUtils.Simulate
1462
   * to dispatch synthetic events.
1463
   */
1464

    
1465
  function makeNativeSimulator(eventType, topLevelType) {
1466
    return function (domComponentOrNode, nativeEventData) {
1467
      var fakeNativeEvent = new Event(eventType);
1468

    
1469
      _assign(fakeNativeEvent, nativeEventData);
1470

    
1471
      if (ReactTestUtils.isDOMComponent(domComponentOrNode)) {
1472
        simulateNativeEventOnDOMComponent(topLevelType, domComponentOrNode, fakeNativeEvent);
1473
      } else if (domComponentOrNode.tagName) {
1474
        // Will allow on actual dom nodes.
1475
        simulateNativeEventOnNode(topLevelType, domComponentOrNode, fakeNativeEvent);
1476
      }
1477
    };
1478
  }
1479

    
1480
  [[TOP_ABORT, 'abort'], [TOP_ANIMATION_END, 'animationEnd'], [TOP_ANIMATION_ITERATION, 'animationIteration'], [TOP_ANIMATION_START, 'animationStart'], [TOP_BLUR, 'blur'], [TOP_CAN_PLAY_THROUGH, 'canPlayThrough'], [TOP_CAN_PLAY, 'canPlay'], [TOP_CANCEL, 'cancel'], [TOP_CHANGE, 'change'], [TOP_CLICK, 'click'], [TOP_CLOSE, 'close'], [TOP_COMPOSITION_END, 'compositionEnd'], [TOP_COMPOSITION_START, 'compositionStart'], [TOP_COMPOSITION_UPDATE, 'compositionUpdate'], [TOP_CONTEXT_MENU, 'contextMenu'], [TOP_COPY, 'copy'], [TOP_CUT, 'cut'], [TOP_DOUBLE_CLICK, 'doubleClick'], [TOP_DRAG_END, 'dragEnd'], [TOP_DRAG_ENTER, 'dragEnter'], [TOP_DRAG_EXIT, 'dragExit'], [TOP_DRAG_LEAVE, 'dragLeave'], [TOP_DRAG_OVER, 'dragOver'], [TOP_DRAG_START, 'dragStart'], [TOP_DRAG, 'drag'], [TOP_DROP, 'drop'], [TOP_DURATION_CHANGE, 'durationChange'], [TOP_EMPTIED, 'emptied'], [TOP_ENCRYPTED, 'encrypted'], [TOP_ENDED, 'ended'], [TOP_ERROR, 'error'], [TOP_FOCUS, 'focus'], [TOP_INPUT, 'input'], [TOP_KEY_DOWN, 'keyDown'], [TOP_KEY_PRESS, 'keyPress'], [TOP_KEY_UP, 'keyUp'], [TOP_LOAD_START, 'loadStart'], [TOP_LOAD_START, 'loadStart'], [TOP_LOAD, 'load'], [TOP_LOADED_DATA, 'loadedData'], [TOP_LOADED_METADATA, 'loadedMetadata'], [TOP_MOUSE_DOWN, 'mouseDown'], [TOP_MOUSE_MOVE, 'mouseMove'], [TOP_MOUSE_OUT, 'mouseOut'], [TOP_MOUSE_OVER, 'mouseOver'], [TOP_MOUSE_UP, 'mouseUp'], [TOP_PASTE, 'paste'], [TOP_PAUSE, 'pause'], [TOP_PLAY, 'play'], [TOP_PLAYING, 'playing'], [TOP_PROGRESS, 'progress'], [TOP_RATE_CHANGE, 'rateChange'], [TOP_SCROLL, 'scroll'], [TOP_SEEKED, 'seeked'], [TOP_SEEKING, 'seeking'], [TOP_SELECTION_CHANGE, 'selectionChange'], [TOP_STALLED, 'stalled'], [TOP_SUSPEND, 'suspend'], [TOP_TEXT_INPUT, 'textInput'], [TOP_TIME_UPDATE, 'timeUpdate'], [TOP_TOGGLE, 'toggle'], [TOP_TOUCH_CANCEL, 'touchCancel'], [TOP_TOUCH_END, 'touchEnd'], [TOP_TOUCH_MOVE, 'touchMove'], [TOP_TOUCH_START, 'touchStart'], [TOP_TRANSITION_END, 'transitionEnd'], [TOP_VOLUME_CHANGE, 'volumeChange'], [TOP_WAITING, 'waiting'], [TOP_WHEEL, 'wheel']].forEach(function (_ref) {
1481
    var topLevelType = _ref[0],
1482
        eventType = _ref[1];
1483

    
1484
    /**
1485
     * @param {!Element|ReactDOMComponent} domComponentOrNode
1486
     * @param {?Event} nativeEventData Fake native event to use in SyntheticEvent.
1487
     */
1488
    ReactTestUtils.SimulateNative[eventType] = makeNativeSimulator(eventType, topLevelType);
1489
  });
1490

    
1491
  // TODO: decide on the top-level export form.
1492
  // This is hacky but makes it work with both Rollup and Jest.
1493

    
1494

    
1495
  var testUtils = ReactTestUtils.default || ReactTestUtils;
1496

    
1497
  return testUtils;
1498

    
1499
})));
(3-3/11)