react-dom 17.0.0-rc.1 → 17.0.1

package/umd/react-dom-test-utils.development.js

@@ -1,4 +1,4 @@
-/** @license React v0.0.0-2d131d782
+/** @license React v17.0.1
  * react-dom-test-utils.development.js
  *
  * Copyright (c) Facebook, Inc. and its affiliates.
@@ -137,8 +137,8 @@
   var HostText = 6;
 
   // Don't change these two values. They're used by React Dev Tools.
-  var NoEffect =
-  /*                     */
+  var NoFlags =
+  /*                      */
   0;
 
   var Placement =
@@ -161,7 +161,7 @@
       do {
         node = nextNode;
 
-        if ((node.effectTag & (Placement | Hydrating)) !== NoEffect) {
+        if ((node.flags & (Placement | Hydrating)) !== NoFlags) {
           // This is an insertion or in-progress hydration. The nearest possible
           // mounted fiber is the parent but we need to continue to figure out
           // if that one is still mounted.
@@ -406,136 +406,144 @@
     return 0;
   }
 
-  /**
-   * @interface Event
-   * @see http://www.w3.org/TR/DOM-Level-3-Events/
-   */
-  var EventInterface = {
-    eventPhase: 0,
-    bubbles: 0,
-    cancelable: 0,
-    timeStamp: function (event) {
-      return event.timeStamp || Date.now();
-    },
-    defaultPrevented: 0,
-    isTrusted: 0
-  };
-
   function functionThatReturnsTrue() {
     return true;
   }
 
   function functionThatReturnsFalse() {
     return false;
-  }
-  /**
-   * Synthetic events are dispatched by event plugins, typically in response to a
-   * top-level event delegation handler.
-   *
-   * These systems should generally use pooling to reduce the frequency of garbage
-   * collection. The system should check `isPersistent` to determine whether the
-   * event should be released into the pool after being dispatched. Users that
-   * need a persisted event should invoke `persist`.
-   *
-   * Synthetic events (and subclasses) implement the DOM Level 3 Events API by
-   * normalizing browser quirks. Subclasses do not necessarily have to implement a
-   * DOM interface; custom application-specific events can also subclass this.
-   */
+  } // This is intentionally a factory so that we have different returned constructors.
+  // If we had a single constructor, it would be megamorphic and engines would deopt.
 
 
-  function SyntheticEvent(reactName, reactEventType, targetInst, nativeEvent, nativeEventTarget) {
-    var Interface = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : EventInterface;
-    this._reactName = reactName;
-    this._targetInst = targetInst;
-    this.type = reactEventType;
-    this.nativeEvent = nativeEvent;
-    this.target = nativeEventTarget;
-    this.currentTarget = null;
+  function createSyntheticEvent(Interface) {
+    /**
+     * Synthetic events are dispatched by event plugins, typically in response to a
+     * top-level event delegation handler.
+     *
+     * These systems should generally use pooling to reduce the frequency of garbage
+     * collection. The system should check `isPersistent` to determine whether the
+     * event should be released into the pool after being dispatched. Users that
+     * need a persisted event should invoke `persist`.
+     *
+     * Synthetic events (and subclasses) implement the DOM Level 3 Events API by
+     * normalizing browser quirks. Subclasses do not necessarily have to implement a
+     * DOM interface; custom application-specific events can also subclass this.
+     */
+    function SyntheticBaseEvent(reactName, reactEventType, targetInst, nativeEvent, nativeEventTarget) {
+      this._reactName = reactName;
+      this._targetInst = targetInst;
+      this.type = reactEventType;
+      this.nativeEvent = nativeEvent;
+      this.target = nativeEventTarget;
+      this.currentTarget = null;
+
+      for (var _propName in Interface) {
+        if (!Interface.hasOwnProperty(_propName)) {
+          continue;
+        }
 
-    for (var _propName in Interface) {
-      if (!Interface.hasOwnProperty(_propName)) {
-        continue;
+        var normalize = Interface[_propName];
+
+        if (normalize) {
+          this[_propName] = normalize(nativeEvent);
+        } else {
+          this[_propName] = nativeEvent[_propName];
+        }
       }
 
-      var normalize = Interface[_propName];
+      var defaultPrevented = nativeEvent.defaultPrevented != null ? nativeEvent.defaultPrevented : nativeEvent.returnValue === false;
 
-      if (normalize) {
-        this[_propName] = normalize(nativeEvent);
+      if (defaultPrevented) {
+        this.isDefaultPrevented = functionThatReturnsTrue;
       } else {
-        this[_propName] = nativeEvent[_propName];
+        this.isDefaultPrevented = functionThatReturnsFalse;
       }
-    }
-
-    var defaultPrevented = nativeEvent.defaultPrevented != null ? nativeEvent.defaultPrevented : nativeEvent.returnValue === false;
 
-    if (defaultPrevented) {
-      this.isDefaultPrevented = functionThatReturnsTrue;
-    } else {
-      this.isDefaultPrevented = functionThatReturnsFalse;
+      this.isPropagationStopped = functionThatReturnsFalse;
+      return this;
     }
 
-    this.isPropagationStopped = functionThatReturnsFalse;
-    return this;
-  }
+    _assign(SyntheticBaseEvent.prototype, {
+      preventDefault: function () {
+        this.defaultPrevented = true;
+        var event = this.nativeEvent;
 
-  _assign(SyntheticEvent.prototype, {
-    preventDefault: function () {
-      this.defaultPrevented = true;
-      var event = this.nativeEvent;
+        if (!event) {
+          return;
+        }
 
-      if (!event) {
-        return;
-      }
+        if (event.preventDefault) {
+          event.preventDefault(); // $FlowFixMe - flow is not aware of `unknown` in IE
+        } else if (typeof event.returnValue !== 'unknown') {
+          event.returnValue = false;
+        }
 
-      if (event.preventDefault) {
-        event.preventDefault(); // $FlowFixMe - flow is not aware of `unknown` in IE
-      } else if (typeof event.returnValue !== 'unknown') {
-        event.returnValue = false;
-      }
+        this.isDefaultPrevented = functionThatReturnsTrue;
+      },
+      stopPropagation: function () {
+        var event = this.nativeEvent;
 
-      this.isDefaultPrevented = functionThatReturnsTrue;
-    },
-    stopPropagation: function () {
-      var event = this.nativeEvent;
+        if (!event) {
+          return;
+        }
 
-      if (!event) {
-        return;
-      }
+        if (event.stopPropagation) {
+          event.stopPropagation(); // $FlowFixMe - flow is not aware of `unknown` in IE
+        } else if (typeof event.cancelBubble !== 'unknown') {
+          // The ChangeEventPlugin registers a "propertychange" event for
+          // IE. This event does not support bubbling or cancelling, and
+          // any references to cancelBubble throw "Member not found".  A
+          // typeof check of "unknown" circumvents this issue (and is also
+          // IE specific).
+          event.cancelBubble = true;
+        }
 
-      if (event.stopPropagation) {
-        event.stopPropagation(); // $FlowFixMe - flow is not aware of `unknown` in IE
-      } else if (typeof event.cancelBubble !== 'unknown') {
-        // The ChangeEventPlugin registers a "propertychange" event for
-        // IE. This event does not support bubbling or cancelling, and
-        // any references to cancelBubble throw "Member not found".  A
-        // typeof check of "unknown" circumvents this issue (and is also
-        // IE specific).
-        event.cancelBubble = true;
-      }
+        this.isPropagationStopped = functionThatReturnsTrue;
+      },
+
+      /**
+       * We release all dispatched `SyntheticEvent`s after each event loop, adding
+       * them back into the pool. This allows a way to hold onto a reference that
+       * won't be added back into the pool.
+       */
+      persist: function () {// Modern event system doesn't use pooling.
+      },
+
+      /**
+       * Checks if this event should be released back into the pool.
+       *
+       * @return {boolean} True if this should not be released, false otherwise.
+       */
+      isPersistent: functionThatReturnsTrue
+    });
 
-      this.isPropagationStopped = functionThatReturnsTrue;
-    },
+    return SyntheticBaseEvent;
+  }
+  /**
+   * @interface Event
+   * @see http://www.w3.org/TR/DOM-Level-3-Events/
+   */
 
-    /**
-     * We release all dispatched `SyntheticEvent`s after each event loop, adding
-     * them back into the pool. This allows a way to hold onto a reference that
-     * won't be added back into the pool.
-     */
-    persist: function () {// Modern event system doesn't use pooling.
-    },
 
-    /**
-     * Checks if this event should be released back into the pool.
-     *
-     * @return {boolean} True if this should not be released, false otherwise.
-     */
-    isPersistent: functionThatReturnsTrue
-  });
+  var EventInterface = {
+    eventPhase: 0,
+    bubbles: 0,
+    cancelable: 0,
+    timeStamp: function (event) {
+      return event.timeStamp || Date.now();
+    },
+    defaultPrevented: 0,
+    isTrusted: 0
+  };
+  var SyntheticEvent = createSyntheticEvent(EventInterface);
 
   var UIEventInterface = _assign({}, EventInterface, {
     view: 0,
     detail: 0
   });
+
+  var SyntheticUIEvent = createSyntheticEvent(UIEventInterface);
   var lastMovementX;
   var lastMovementY;
   var lastMouseEvent;
@@ -596,6 +604,8 @@
       return lastMovementY;
     }
   });
+
+  var SyntheticMouseEvent = createSyntheticEvent(MouseEventInterface);
   /**
    * @interface DragEvent
    * @see http://www.w3.org/TR/DOM-Level-3-Events/
@@ -604,6 +614,8 @@
   var DragEventInterface = _assign({}, MouseEventInterface, {
     dataTransfer: 0
   });
+
+  var SyntheticDragEvent = createSyntheticEvent(DragEventInterface);
   /**
    * @interface FocusEvent
    * @see http://www.w3.org/TR/DOM-Level-3-Events/
@@ -612,6 +624,8 @@
   var FocusEventInterface = _assign({}, UIEventInterface, {
     relatedTarget: 0
   });
+
+  var SyntheticFocusEvent = createSyntheticEvent(FocusEventInterface);
   /**
    * @interface Event
    * @see http://www.w3.org/TR/css3-animations/#AnimationEvent-interface
@@ -623,6 +637,8 @@
     elapsedTime: 0,
     pseudoElement: 0
   });
+
+  var SyntheticAnimationEvent = createSyntheticEvent(AnimationEventInterface);
   /**
    * @interface Event
    * @see http://www.w3.org/TR/clipboard-apis/
@@ -633,6 +649,8 @@
       return 'clipboardData' in event ? event.clipboardData : window.clipboardData;
     }
   });
+
+  var SyntheticClipboardEvent = createSyntheticEvent(ClipboardEventInterface);
   /**
    * @interface Event
    * @see http://www.w3.org/TR/DOM-Level-3-Events/#events-compositionevents
@@ -641,6 +659,8 @@
   var CompositionEventInterface = _assign({}, EventInterface, {
     data: 0
   });
+
+  var SyntheticCompositionEvent = createSyntheticEvent(CompositionEventInterface);
   /**
    * Normalization of deprecated HTML5 `key` values
    * @see https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent#Key_names
@@ -824,6 +844,8 @@
       return 0;
     }
   });
+
+  var SyntheticKeyboardEvent = createSyntheticEvent(KeyboardEventInterface);
   /**
    * @interface PointerEvent
    * @see http://www.w3.org/TR/pointerevents/
@@ -841,6 +863,8 @@
     pointerType: 0,
     isPrimary: 0
   });
+
+  var SyntheticPointerEvent = createSyntheticEvent(PointerEventInterface);
   /**
    * @interface TouchEvent
    * @see http://www.w3.org/TR/touch-events/
@@ -856,6 +880,8 @@
     shiftKey: 0,
     getModifierState: getEventModifierState
   });
+
+  var SyntheticTouchEvent = createSyntheticEvent(TouchEventInterface);
   /**
    * @interface Event
    * @see http://www.w3.org/TR/2009/WD-css3-transitions-20090320/#transition-events-
@@ -867,6 +893,8 @@
     elapsedTime: 0,
     pseudoElement: 0
   });
+
+  var SyntheticTransitionEvent = createSyntheticEvent(TransitionEventInterface);
   /**
    * @interface WheelEvent
    * @see http://www.w3.org/TR/DOM-Level-3-Events/
@@ -890,6 +918,8 @@
     deltaMode: 0
   });
 
+  var SyntheticWheelEvent = createSyntheticEvent(WheelEventInterface);
+
   /**
    * HTML nodeType values that represent the type of the node
    */
@@ -953,21 +983,24 @@
       unstable_forceFrameRate = _ReactInternals$Sched.unstable_forceFrameRate,
       unstable_flushAllWithoutAsserting = _ReactInternals$Sched.unstable_flushAllWithoutAsserting;
 
-  var _ReactDOM$__SECRET_IN = ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.Events,
-
-  /* eslint-disable no-unused-vars */
-  getInstanceFromNode = _ReactDOM$__SECRET_IN[0],
-      getNodeFromInstance = _ReactDOM$__SECRET_IN[1],
-      getFiberCurrentPropsFromNode = _ReactDOM$__SECRET_IN[2],
-      enqueueStateRestore = _ReactDOM$__SECRET_IN[3],
-      restoreStateIfNeeded = _ReactDOM$__SECRET_IN[4],
+  var EventInternals = ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.Events; // const getInstanceFromNode = EventInternals[0];
+  // const getNodeFromInstance = EventInternals[1];
+  // const getFiberCurrentPropsFromNode = EventInternals[2];
+  // const enqueueStateRestore = EventInternals[3];
+  // const restoreStateIfNeeded = EventInternals[4];
 
-  /* eslint-enable no-unused-vars */
-  flushPassiveEffects = _ReactDOM$__SECRET_IN[5],
-      IsThisRendererActing = _ReactDOM$__SECRET_IN[6];
+  var flushPassiveEffects = EventInternals[5];
+  var IsThisRendererActing = EventInternals[6];
   var batchedUpdates = ReactDOM.unstable_batchedUpdates;
-  var IsSomeRendererActing = ReactSharedInternals.IsSomeRendererActing; // this implementation should be exactly the same in
-  // ReactTestUtilsAct.js, ReactTestRendererAct.js, createReactNoop.js
+  var IsSomeRendererActing = ReactSharedInternals.IsSomeRendererActing; // This is the public version of `ReactTestUtils.act`. It is implemented in
+  // "userspace" (i.e. not the reconciler), so that it doesn't add to the
+  // production bundle size.
+  // TODO: Remove this implementation of `act` in favor of the one exported by
+  // the reconciler. To do this, we must first drop support for `act` in
+  // production mode.
+  // TODO: Remove support for the mock scheduler build, which was only added for
+  // the purposes of internal testing. Internal tests should use
+  // `unstable_concurrentAct` instead.
 
   var isSchedulerMocked = typeof unstable_flushAllWithoutAsserting === 'function';
 
@@ -999,7 +1032,6 @@
 
 
   var actingUpdatesScopeDepth = 0;
-
   function act(callback) {
 
     var previousActingUpdatesScopeDepth = actingUpdatesScopeDepth;
@@ -1112,6 +1144,114 @@
     }
   }
 
+  var EventInternals$1 = ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.Events; // const getInstanceFromNode = EventInternals[0];
+  // const getNodeFromInstance = EventInternals[1];
+  // const getFiberCurrentPropsFromNode = EventInternals[2];
+  // const enqueueStateRestore = EventInternals[3];
+  // const restoreStateIfNeeded = EventInternals[4];
+  // const flushPassiveEffects = EventInternals[5];
+
+  var IsThisRendererActing$1 = EventInternals$1[6];
+  var batchedUpdates$1 = ReactDOM.unstable_batchedUpdates;
+  var IsSomeRendererActing$1 = ReactSharedInternals.IsSomeRendererActing; // This version of `act` is only used by our tests. Unlike the public version
+  // of `act`, it's designed to work identically in both production and
+  // development. It may have slightly different behavior from the public
+  // version, too, since our constraints in our test suite are not the same as
+  // those of developers using React — we're testing React itself, as opposed to
+  // building an app with React.
+
+  var actingUpdatesScopeDepth$1 = 0;
+  function unstable_concurrentAct(scope) {
+    if (unstable_flushAllWithoutAsserting === undefined) {
+      throw Error('This version of `act` requires a special mock build of Scheduler.');
+    }
+
+    if (setTimeout._isMockFunction !== true) {
+      throw Error("This version of `act` requires Jest's timer mocks " + '(i.e. jest.useFakeTimers).');
+    }
+
+    var previousActingUpdatesScopeDepth = actingUpdatesScopeDepth$1;
+    var previousIsSomeRendererActing = IsSomeRendererActing$1.current;
+    var previousIsThisRendererActing = IsThisRendererActing$1.current;
+    IsSomeRendererActing$1.current = true;
+    IsThisRendererActing$1.current = true;
+    actingUpdatesScopeDepth$1++;
+
+    var unwind = function () {
+      actingUpdatesScopeDepth$1--;
+      IsSomeRendererActing$1.current = previousIsSomeRendererActing;
+      IsThisRendererActing$1.current = previousIsThisRendererActing;
+
+      {
+        if (actingUpdatesScopeDepth$1 > previousActingUpdatesScopeDepth) {
+          // if it's _less than_ previousActingUpdatesScopeDepth, then we can
+          // assume the 'other' one has warned
+          error('You seem to have overlapping act() calls, this is not supported. ' + 'Be sure to await previous act() calls before making a new one. ');
+        }
+      }
+    }; // TODO: This would be way simpler if 1) we required a promise to be
+    // returned and 2) we could use async/await. Since it's only our used in
+    // our test suite, we should be able to.
+
+
+    try {
+      var thenable = batchedUpdates$1(scope);
+
+      if (typeof thenable === 'object' && thenable !== null && typeof thenable.then === 'function') {
+        return {
+          then: function (resolve, reject) {
+            thenable.then(function () {
+              flushActWork(function () {
+                unwind();
+                resolve();
+              }, function (error) {
+                unwind();
+                reject(error);
+              });
+            }, function (error) {
+              unwind();
+              reject(error);
+            });
+          }
+        };
+      } else {
+        try {
+          // TODO: Let's not support non-async scopes at all in our tests. Need to
+          // migrate existing tests.
+          var didFlushWork;
+
+          do {
+            didFlushWork = unstable_flushAllWithoutAsserting();
+          } while (didFlushWork);
+        } finally {
+          unwind();
+        }
+      }
+    } catch (error) {
+      unwind();
+      throw error;
+    }
+  }
+
+  function flushActWork(resolve, reject) {
+    // Flush suspended fallbacks
+    // $FlowFixMe: Flow doesn't know about global Jest object
+    jest.runOnlyPendingTimers();
+    enqueueTask(function () {
+      try {
+        var didFlushWork = unstable_flushAllWithoutAsserting();
+
+        if (didFlushWork) {
+          flushActWork(resolve, reject);
+        } else {
+          resolve();
+        }
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+
   function invokeGuardedCallbackProd(name, func, context, a, b, c, d, e, f) {
     var funcArgs = Array.prototype.slice.call(arguments, 3);
 
@@ -1363,22 +1503,14 @@
     }
   }
 
-  var _ReactDOM$__SECRET_IN$1 = ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.Events,
-      getInstanceFromNode$1 = _ReactDOM$__SECRET_IN$1[0],
-
-  /* eslint-disable no-unused-vars */
-  getNodeFromInstance$1 = _ReactDOM$__SECRET_IN$1[1],
-      getFiberCurrentPropsFromNode$1 = _ReactDOM$__SECRET_IN$1[2],
-
-  /* eslint-enable no-unused-vars */
-  enqueueStateRestore$1 = _ReactDOM$__SECRET_IN$1[3],
-      restoreStateIfNeeded$1 = _ReactDOM$__SECRET_IN$1[4],
-
-  /* eslint-disable no-unused-vars */
-  flushPassiveEffects$1 = _ReactDOM$__SECRET_IN$1[5],
-      IsThisRendererActing$1
-  /* eslint-enable no-unused-vars */
-  = _ReactDOM$__SECRET_IN$1[6];
+  var EventInternals$2 = ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.Events;
+  var getInstanceFromNode = EventInternals$2[0];
+  var getNodeFromInstance = EventInternals$2[1];
+  var getFiberCurrentPropsFromNode = EventInternals$2[2];
+  var enqueueStateRestore = EventInternals$2[3];
+  var restoreStateIfNeeded = EventInternals$2[4]; // const flushPassiveEffects = EventInternals[5];
+  // TODO: This is related to `act`, not events. Move to separate key?
+  // const IsThisRendererActing = EventInternals[6];
 
   function Event(suffix) {}
 
@@ -1699,7 +1831,7 @@
 
   function executeDispatch(event, listener, inst) {
     var type = event.type || 'unknown-event';
-    event.currentTarget = getNodeFromInstance$1(inst);
+    event.currentTarget = getNodeFromInstance(inst);
     invokeGuardedCallbackAndCatchFirstError(type, listener, undefined, event);
     event.currentTarget = null;
   }
@@ -1825,7 +1957,7 @@
       return null;
     }
 
-    var props = getFiberCurrentPropsFromNode$1(stateNode);
+    var props = getFiberCurrentPropsFromNode(stateNode);
 
     if (!props) {
       // Work in progress.
@@ -1944,7 +2076,7 @@
       var fakeNativeEvent = new Event();
       fakeNativeEvent.target = domNode;
       fakeNativeEvent.type = eventType.toLowerCase();
-      var targetInst = getInstanceFromNode$1(domNode);
+      var targetInst = getInstanceFromNode(domNode);
       var event = new SyntheticEvent(reactName, fakeNativeEvent.type, targetInst, fakeNativeEvent, domNode); // Since we aren't using pooling, always persist the event. This will make
       // sure it's marked and won't warn when setting additional properties.
 
@@ -1961,11 +2093,11 @@
       ReactDOM.unstable_batchedUpdates(function () {
         // Normally extractEvent enqueues a state restore, but we'll just always
         // do that since we're by-passing it here.
-        enqueueStateRestore$1(domNode);
+        enqueueStateRestore(domNode);
         executeDispatchesAndRelease(event);
         rethrowCaughtError();
       });
-      restoreStateIfNeeded$1();
+      restoreStateIfNeeded();
     };
   } // A one-time snapshot with no plans to update. We'll probably want to deprecate Simulate API.
 
@@ -1999,5 +2131,6 @@
   exports.scryRenderedDOMComponentsWithClass = scryRenderedDOMComponentsWithClass;
   exports.scryRenderedDOMComponentsWithTag = scryRenderedDOMComponentsWithTag;
   exports.traverseTwoPhase = traverseTwoPhase;
+  exports.unstable_concurrentAct = unstable_concurrentAct;
 
 })));