react-test-renderer 15.5.0 → 15.5.4

package/lib/shallow/ReactChildFiber.js

@@ -0,0 +1,243 @@
+/**
+ * Copyright 2013-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ *
+ * 
+ */
+
+'use strict';
+
+var REACT_ELEMENT_TYPE = require('./ReactElementSymbol');
+
+var _require = require('./ReactCoroutine'),
+    REACT_COROUTINE_TYPE = _require.REACT_COROUTINE_TYPE,
+    REACT_YIELD_TYPE = _require.REACT_YIELD_TYPE;
+
+var ReactFiber = require('./ReactFiber');
+var ReactReifiedYield = require('./ReactReifiedYield');
+
+var cloneFiber = ReactFiber.cloneFiber,
+    createFiberFromElement = ReactFiber.createFiberFromElement,
+    createFiberFromCoroutine = ReactFiber.createFiberFromCoroutine,
+    createFiberFromYield = ReactFiber.createFiberFromYield;
+var createReifiedYield = ReactReifiedYield.createReifiedYield;
+
+
+var isArray = Array.isArray;
+
+function ChildReconciler(shouldClone) {
+
+  function createSubsequentChild(returnFiber, existingChild, previousSibling, newChildren, priority) {
+    if (typeof newChildren !== 'object' || newChildren === null) {
+      return previousSibling;
+    }
+
+    switch (newChildren.$$typeof) {
+      case REACT_ELEMENT_TYPE:
+        {
+          var element = newChildren;
+          if (existingChild && element.type === existingChild.type && element.key === existingChild.key) {
+            // TODO: This is not sufficient since previous siblings could be new.
+            // Will fix reconciliation properly later.
+            var clone = shouldClone ? cloneFiber(existingChild, priority) : existingChild;
+            if (!shouldClone) {
+              // TODO: This might be lowering the priority of nested unfinished work.
+              clone.pendingWorkPriority = priority;
+            }
+            clone.pendingProps = element.props;
+            clone.sibling = null;
+            clone['return'] = returnFiber;
+            previousSibling.sibling = clone;
+            return clone;
+          }
+          var child = createFiberFromElement(element, priority);
+          previousSibling.sibling = child;
+          child['return'] = returnFiber;
+          return child;
+        }
+
+      case REACT_COROUTINE_TYPE:
+        {
+          var coroutine = newChildren;
+          var _child = createFiberFromCoroutine(coroutine, priority);
+          previousSibling.sibling = _child;
+          _child['return'] = returnFiber;
+          return _child;
+        }
+
+      case REACT_YIELD_TYPE:
+        {
+          var yieldNode = newChildren;
+          var reifiedYield = createReifiedYield(yieldNode);
+          var _child2 = createFiberFromYield(yieldNode, priority);
+          _child2.output = reifiedYield;
+          previousSibling.sibling = _child2;
+          _child2['return'] = returnFiber;
+          return _child2;
+        }
+    }
+
+    if (isArray(newChildren)) {
+      var prev = previousSibling;
+      var existing = existingChild;
+      for (var i = 0; i < newChildren.length; i++) {
+        var nextExisting = existing && existing.sibling;
+        prev = createSubsequentChild(returnFiber, existing, prev, newChildren[i], priority);
+        if (prev && existing) {
+          // TODO: This is not correct because there could've been more
+          // than one sibling consumed but I don't want to return a tuple.
+          existing = nextExisting;
+        }
+      }
+      return prev;
+    } else {
+      // TODO: Throw for unknown children.
+      return previousSibling;
+    }
+  }
+
+  function createFirstChild(returnFiber, existingChild, newChildren, priority) {
+    if (typeof newChildren !== 'object' || newChildren === null) {
+      return null;
+    }
+
+    switch (newChildren.$$typeof) {
+      case REACT_ELEMENT_TYPE:
+        {
+          /* $FlowFixMe(>=0.31.0): This is an unsafe cast. Consider adding a type
+           *                       annotation to the `newChildren` param of this
+           *                       function.
+           */
+          var element = newChildren;
+          if (existingChild && element.type === existingChild.type && element.key === existingChild.key) {
+            // Get the clone of the existing fiber.
+            var clone = shouldClone ? cloneFiber(existingChild, priority) : existingChild;
+            if (!shouldClone) {
+              // TODO: This might be lowering the priority of nested unfinished work.
+              clone.pendingWorkPriority = priority;
+            }
+            clone.pendingProps = element.props;
+            clone.sibling = null;
+            clone['return'] = returnFiber;
+            return clone;
+          }
+          var child = createFiberFromElement(element, priority);
+          child['return'] = returnFiber;
+          return child;
+        }
+
+      case REACT_COROUTINE_TYPE:
+        {
+          /* $FlowFixMe(>=0.31.0): No 'handler' property found in object type
+           */
+          var coroutine = newChildren;
+          var _child3 = createFiberFromCoroutine(coroutine, priority);
+          _child3['return'] = returnFiber;
+          return _child3;
+        }
+
+      case REACT_YIELD_TYPE:
+        {
+          // A yield results in a fragment fiber whose output is the continuation.
+          // TODO: When there is only a single child, we can optimize this to avoid
+          // the fragment.
+          /* $FlowFixMe(>=0.31.0): No 'continuation' property found in object
+           * type
+           */
+          var yieldNode = newChildren;
+          var reifiedYield = createReifiedYield(yieldNode);
+          var _child4 = createFiberFromYield(yieldNode, priority);
+          _child4.output = reifiedYield;
+          _child4['return'] = returnFiber;
+          return _child4;
+        }
+    }
+
+    if (isArray(newChildren)) {
+      var first = null;
+      var prev = null;
+      var existing = existingChild;
+      /* $FlowIssue(>=0.31.0) #12747709
+       *
+       * `Array.isArray` is matched syntactically for now until predicate
+       * support is complete.
+       */
+      for (var i = 0; i < newChildren.length; i++) {
+        var nextExisting = existing && existing.sibling;
+        if (prev == null) {
+          prev = createFirstChild(returnFiber, existing, newChildren[i], priority);
+          first = prev;
+        } else {
+          prev = createSubsequentChild(returnFiber, existing, prev, newChildren[i], priority);
+        }
+        if (prev && existing) {
+          // TODO: This is not correct because there could've been more
+          // than one sibling consumed but I don't want to return a tuple.
+          existing = nextExisting;
+        }
+      }
+      return first;
+    } else {
+      // TODO: Throw for unknown children.
+      return null;
+    }
+  }
+
+  // TODO: This API won't work because we'll need to transfer the side-effects of
+  // unmounting children to the returnFiber.
+  function reconcileChildFibers(returnFiber, currentFirstChild, newChildren, priority) {
+    return createFirstChild(returnFiber, currentFirstChild, newChildren, priority);
+  }
+
+  return reconcileChildFibers;
+}
+
+exports.reconcileChildFibers = ChildReconciler(true);
+
+exports.reconcileChildFibersInPlace = ChildReconciler(false);
+
+function cloneSiblings(current, workInProgress, returnFiber) {
+  workInProgress['return'] = returnFiber;
+  while (current.sibling) {
+    current = current.sibling;
+    workInProgress = workInProgress.sibling = cloneFiber(current, current.pendingWorkPriority);
+    workInProgress['return'] = returnFiber;
+  }
+  workInProgress.sibling = null;
+}
+
+exports.cloneChildFibers = function (current, workInProgress) {
+  if (!workInProgress.child) {
+    return;
+  }
+  if (current && workInProgress.child === current.child) {
+    // We use workInProgress.child since that lets Flow know that it can't be
+    // null since we validated that already. However, as the line above suggests
+    // they're actually the same thing.
+    var currentChild = workInProgress.child;
+    // TODO: This used to reset the pending priority. Not sure if that is needed.
+    // workInProgress.pendingWorkPriority = current.pendingWorkPriority;
+    // TODO: The below priority used to be set to NoWork which would've
+    // dropped work. This is currently unobservable but will become
+    // observable when the first sibling has lower priority work remaining
+    // than the next sibling. At that point we should add tests that catches
+    // this.
+    var newChild = cloneFiber(currentChild, currentChild.pendingWorkPriority);
+    workInProgress.child = newChild;
+    cloneSiblings(currentChild, newChild, workInProgress);
+  }
+
+  // If there is no alternate, then we don't need to clone the children.
+  // If the children of the alternate fiber is a different set, then we don't
+  // need to clone. We need to reset the return fiber though since we'll
+  // traverse down into them.
+  var child = workInProgress.child;
+  while (child) {
+    child['return'] = workInProgress;
+    child = child.sibling;
+  }
+};

package/lib/shallow/ReactChildReconciler.js

@@ -0,0 +1,153 @@
+/**
+ * Copyright 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ *
+ */
+
+'use strict';
+
+var ReactReconciler = require('./ReactReconciler');
+
+var instantiateReactComponent = require('./instantiateReactComponent');
+var KeyEscapeUtils = require('./KeyEscapeUtils');
+var shouldUpdateReactComponent = require('./shouldUpdateReactComponent');
+var traverseAllChildren = require('./traverseAllChildren');
+var warning = require('fbjs/lib/warning');
+
+var ReactComponentTreeHook;
+
+if (typeof process !== 'undefined' && process.env && process.env.NODE_ENV === 'test') {
+  // Temporary hack.
+  // Inline requires don't work well with Jest:
+  // https://github.com/facebook/react/issues/7240
+  // Remove the inline requires when we don't need them anymore:
+  // https://github.com/facebook/react/pull/7178
+  ReactComponentTreeHook = require('react/lib/ReactComponentTreeHook');
+}
+
+function instantiateChild(childInstances, child, name, selfDebugID) {
+  // We found a component instance.
+  var keyUnique = childInstances[name] === undefined;
+  if (process.env.NODE_ENV !== 'production') {
+    if (!ReactComponentTreeHook) {
+      ReactComponentTreeHook = require('react/lib/ReactComponentTreeHook');
+    }
+    if (!keyUnique) {
+      process.env.NODE_ENV !== 'production' ? warning(false, 'flattenChildren(...): Encountered two children with the same key, ' + '`%s`. Child keys must be unique; when two children share a key, only ' + 'the first child will be used.%s', KeyEscapeUtils.unescape(name), ReactComponentTreeHook.getStackAddendumByID(selfDebugID)) : void 0;
+    }
+  }
+  if (child != null && keyUnique) {
+    childInstances[name] = instantiateReactComponent(child, true);
+  }
+}
+
+/**
+ * ReactChildReconciler provides helpers for initializing or updating a set of
+ * children. Its output is suitable for passing it onto ReactMultiChild which
+ * does diffed reordering and insertion.
+ */
+var ReactChildReconciler = {
+  /**
+   * Generates a "mount image" for each of the supplied children. In the case
+   * of `ReactDOMComponent`, a mount image is a string of markup.
+   *
+   * @param {?object} nestedChildNodes Nested child maps.
+   * @return {?object} A set of child instances.
+   * @internal
+   */
+  instantiateChildren: function (nestedChildNodes, transaction, context, selfDebugID // 0 in production and for roots
+  ) {
+    if (nestedChildNodes == null) {
+      return null;
+    }
+    var childInstances = {};
+
+    if (process.env.NODE_ENV !== 'production') {
+      traverseAllChildren(nestedChildNodes, function (childInsts, child, name) {
+        return instantiateChild(childInsts, child, name, selfDebugID);
+      }, childInstances);
+    } else {
+      traverseAllChildren(nestedChildNodes, instantiateChild, childInstances);
+    }
+    return childInstances;
+  },
+
+  /**
+   * Updates the rendered children and returns a new set of children.
+   *
+   * @param {?object} prevChildren Previously initialized set of children.
+   * @param {?object} nextChildren Flat child element maps.
+   * @param {ReactReconcileTransaction} transaction
+   * @param {object} context
+   * @return {?object} A new set of child instances.
+   * @internal
+   */
+  updateChildren: function (prevChildren, nextChildren, mountImages, removedNodes, transaction, hostParent, hostContainerInfo, context, selfDebugID // 0 in production and for roots
+  ) {
+    // We currently don't have a way to track moves here but if we use iterators
+    // instead of for..in we can zip the iterators and check if an item has
+    // moved.
+    // TODO: If nothing has changed, return the prevChildren object so that we
+    // can quickly bailout if nothing has changed.
+    if (!nextChildren && !prevChildren) {
+      return;
+    }
+    var name;
+    var prevChild;
+    for (name in nextChildren) {
+      if (!nextChildren.hasOwnProperty(name)) {
+        continue;
+      }
+      prevChild = prevChildren && prevChildren[name];
+      var prevElement = prevChild && prevChild._currentElement;
+      var nextElement = nextChildren[name];
+      if (prevChild != null && shouldUpdateReactComponent(prevElement, nextElement)) {
+        ReactReconciler.receiveComponent(prevChild, nextElement, transaction, context);
+        nextChildren[name] = prevChild;
+      } else {
+        if (prevChild) {
+          removedNodes[name] = ReactReconciler.getHostNode(prevChild);
+          ReactReconciler.unmountComponent(prevChild, false);
+        }
+        // The child must be instantiated before it's mounted.
+        var nextChildInstance = instantiateReactComponent(nextElement, true);
+        nextChildren[name] = nextChildInstance;
+        // Creating mount image now ensures refs are resolved in right order
+        // (see https://github.com/facebook/react/pull/7101 for explanation).
+        var nextChildMountImage = ReactReconciler.mountComponent(nextChildInstance, transaction, hostParent, hostContainerInfo, context, selfDebugID);
+        mountImages.push(nextChildMountImage);
+      }
+    }
+    // Unmount children that are no longer present.
+    for (name in prevChildren) {
+      if (prevChildren.hasOwnProperty(name) && !(nextChildren && nextChildren.hasOwnProperty(name))) {
+        prevChild = prevChildren[name];
+        removedNodes[name] = ReactReconciler.getHostNode(prevChild);
+        ReactReconciler.unmountComponent(prevChild, false);
+      }
+    }
+  },
+
+  /**
+   * Unmounts all rendered children. This should be used to clean up children
+   * when this component is unmounted.
+   *
+   * @param {?object} renderedChildren Previously initialized set of children.
+   * @internal
+   */
+  unmountChildren: function (renderedChildren, safely) {
+    for (var name in renderedChildren) {
+      if (renderedChildren.hasOwnProperty(name)) {
+        var renderedChild = renderedChildren[name];
+        ReactReconciler.unmountComponent(renderedChild, safely);
+      }
+    }
+  }
+
+};
+
+module.exports = ReactChildReconciler;

package/lib/shallow/ReactComponentBrowserEnvironment.js

@@ -0,0 +1,29 @@
+/**
+ * Copyright 2013-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ *
+ */
+
+'use strict';
+
+var DOMChildrenOperations = require('./DOMChildrenOperations');
+var ReactDOMIDOperations = require('./ReactDOMIDOperations');
+
+/**
+ * Abstracts away all functionality of the reconciler that requires knowledge of
+ * the browser context. TODO: These callers should be refactored to avoid the
+ * need for this injection.
+ */
+var ReactComponentBrowserEnvironment = {
+
+  processChildrenUpdates: ReactDOMIDOperations.dangerouslyProcessChildrenUpdates,
+
+  replaceNodeWithMarkup: DOMChildrenOperations.dangerouslyReplaceNodeWithMarkup
+
+};
+
+module.exports = ReactComponentBrowserEnvironment;

package/lib/shallow/ReactComponentEnvironment.js

@@ -0,0 +1,45 @@
+/**
+ * Copyright 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ *
+ * 
+ */
+
+'use strict';
+
+var _prodInvariant = require('./reactProdInvariant');
+
+var invariant = require('fbjs/lib/invariant');
+
+var injected = false;
+
+var ReactComponentEnvironment = {
+
+  /**
+   * Optionally injectable hook for swapping out mount images in the middle of
+   * the tree.
+   */
+  replaceNodeWithMarkup: null,
+
+  /**
+   * Optionally injectable hook for processing a queue of child updates. Will
+   * later move into MultiChildComponents.
+   */
+  processChildrenUpdates: null,
+
+  injection: {
+    injectEnvironment: function (environment) {
+      !!injected ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactCompositeComponent: injectEnvironment() can only be called once.') : _prodInvariant('104') : void 0;
+      ReactComponentEnvironment.replaceNodeWithMarkup = environment.replaceNodeWithMarkup;
+      ReactComponentEnvironment.processChildrenUpdates = environment.processChildrenUpdates;
+      injected = true;
+    }
+  }
+
+};
+
+module.exports = ReactComponentEnvironment;