react-dom 17.0.0-rc.1 → 17.0.1

package/cjs/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.
@@ -140,8 +140,8 @@ var HostComponent = 5;
 var HostText = 6;
 
 // Don't change these two values. They're used by React Dev Tools.
-var NoEffect =
-/*                     */
+var NoFlags =
+/*                      */
 0;
 
 var Placement =
@@ -164,7 +164,7 @@ function getNearestMountedFiber(fiber) {
     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.
@@ -409,136 +409,144 @@ function getEventCharCode(nativeEvent) {
   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;
@@ -599,6 +607,8 @@ var MouseEventInterface = _assign({}, UIEventInterface, {
     return lastMovementY;
   }
 });
+
+var SyntheticMouseEvent = createSyntheticEvent(MouseEventInterface);
 /**
  * @interface DragEvent
  * @see http://www.w3.org/TR/DOM-Level-3-Events/
@@ -607,6 +617,8 @@ var MouseEventInterface = _assign({}, UIEventInterface, {
 var DragEventInterface = _assign({}, MouseEventInterface, {
   dataTransfer: 0
 });
+
+var SyntheticDragEvent = createSyntheticEvent(DragEventInterface);
 /**
  * @interface FocusEvent
  * @see http://www.w3.org/TR/DOM-Level-3-Events/
@@ -615,6 +627,8 @@ var DragEventInterface = _assign({}, MouseEventInterface, {
 var FocusEventInterface = _assign({}, UIEventInterface, {
   relatedTarget: 0
 });
+
+var SyntheticFocusEvent = createSyntheticEvent(FocusEventInterface);
 /**
  * @interface Event
  * @see http://www.w3.org/TR/css3-animations/#AnimationEvent-interface
@@ -626,6 +640,8 @@ var AnimationEventInterface = _assign({}, EventInterface, {
   elapsedTime: 0,
   pseudoElement: 0
 });
+
+var SyntheticAnimationEvent = createSyntheticEvent(AnimationEventInterface);
 /**
  * @interface Event
  * @see http://www.w3.org/TR/clipboard-apis/
@@ -636,6 +652,8 @@ var ClipboardEventInterface = _assign({}, EventInterface, {
     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
@@ -644,6 +662,8 @@ var ClipboardEventInterface = _assign({}, EventInterface, {
 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
@@ -827,6 +847,8 @@ var KeyboardEventInterface = _assign({}, UIEventInterface, {
     return 0;
   }
 });
+
+var SyntheticKeyboardEvent = createSyntheticEvent(KeyboardEventInterface);
 /**
  * @interface PointerEvent
  * @see http://www.w3.org/TR/pointerevents/
@@ -844,6 +866,8 @@ var PointerEventInterface = _assign({}, MouseEventInterface, {
   pointerType: 0,
   isPrimary: 0
 });
+
+var SyntheticPointerEvent = createSyntheticEvent(PointerEventInterface);
 /**
  * @interface TouchEvent
  * @see http://www.w3.org/TR/touch-events/
@@ -859,6 +883,8 @@ var TouchEventInterface = _assign({}, UIEventInterface, {
   shiftKey: 0,
   getModifierState: getEventModifierState
 });
+
+var SyntheticTouchEvent = createSyntheticEvent(TouchEventInterface);
 /**
  * @interface Event
  * @see http://www.w3.org/TR/2009/WD-css3-transitions-20090320/#transition-events-
@@ -870,6 +896,8 @@ var TransitionEventInterface = _assign({}, EventInterface, {
   elapsedTime: 0,
   pseudoElement: 0
 });
+
+var SyntheticTransitionEvent = createSyntheticEvent(TransitionEventInterface);
 /**
  * @interface WheelEvent
  * @see http://www.w3.org/TR/DOM-Level-3-Events/
@@ -893,6 +921,8 @@ var WheelEventInterface = _assign({}, MouseEventInterface, {
   deltaMode: 0
 });
 
+var SyntheticWheelEvent = createSyntheticEvent(WheelEventInterface);
+
 /**
  * HTML nodeType values that represent the type of the node
  */
@@ -935,21 +965,24 @@ function enqueueTask(task) {
   return enqueueTaskImpl(task);
 }
 
-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 Scheduler.unstable_flushAllWithoutAsserting === 'function';
 
@@ -981,7 +1014,6 @@ function flushWorkAndMicroTasks(onDone) {
 
 
 var actingUpdatesScopeDepth = 0;
-
 function act(callback) {
 
   var previousActingUpdatesScopeDepth = actingUpdatesScopeDepth;
@@ -1094,6 +1126,114 @@ function act(callback) {
   }
 }
 
+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 (Scheduler.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 = Scheduler.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 = Scheduler.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);
 
@@ -1345,22 +1485,14 @@ function clearCaughtError() {
   }
 }
 
-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) {}
 
@@ -1681,7 +1813,7 @@ function nativeTouchData(x, y) {
 
 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;
 }
@@ -1807,7 +1939,7 @@ function getListener(inst, registrationName) {
     return null;
   }
 
-  var props = getFiberCurrentPropsFromNode$1(stateNode);
+  var props = getFiberCurrentPropsFromNode(stateNode);
 
   if (!props) {
     // Work in progress.
@@ -1926,7 +2058,7 @@ function makeSimulator(eventType) {
     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.
 
@@ -1943,11 +2075,11 @@ function makeSimulator(eventType) {
     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.
 
@@ -1981,5 +2113,6 @@ exports.scryRenderedComponentsWithType = scryRenderedComponentsWithType;
 exports.scryRenderedDOMComponentsWithClass = scryRenderedDOMComponentsWithClass;
 exports.scryRenderedDOMComponentsWithTag = scryRenderedDOMComponentsWithTag;
 exports.traverseTwoPhase = traverseTwoPhase;
+exports.unstable_concurrentAct = unstable_concurrentAct;
   })();
 }