Updating NPM dependencies

node_modules/jest-resolve-dependencies/build/index.js

@@ -1,15 +1,67 @@
 'use strict';
 
-function _jestSnapshot() {
-  const data = require('jest-snapshot');
+function path() {
+  const data = _interopRequireWildcard(require('path'));
 
-  _jestSnapshot = function _jestSnapshot() {
+  path = function () {
     return data;
   };
 
   return data;
 }
 
+function _jestSnapshot() {
+  const data = require('jest-snapshot');
+
+  _jestSnapshot = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _getRequireWildcardCache() {
+  if (typeof WeakMap !== 'function') return null;
+  var cache = new WeakMap();
+  _getRequireWildcardCache = function () {
+    return cache;
+  };
+  return cache;
+}
+
+function _interopRequireWildcard(obj) {
+  if (obj && obj.__esModule) {
+    return obj;
+  }
+  if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) {
+    return {default: obj};
+  }
+  var cache = _getRequireWildcardCache();
+  if (cache && cache.has(obj)) {
+    return cache.get(obj);
+  }
+  var newObj = {};
+  var hasPropertyDescriptor =
+    Object.defineProperty && Object.getOwnPropertyDescriptor;
+  for (var key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      var desc = hasPropertyDescriptor
+        ? Object.getOwnPropertyDescriptor(obj, key)
+        : null;
+      if (desc && (desc.get || desc.set)) {
+        Object.defineProperty(newObj, key, desc);
+      } else {
+        newObj[key] = obj[key];
+      }
+    }
+  }
+  newObj.default = obj;
+  if (cache) {
+    cache.set(obj, newObj);
+  }
+  return newObj;
+}
+
 function _defineProperty(obj, key, value) {
   if (key in obj) {
     Object.defineProperty(obj, key, {
@@ -28,8 +80,6 @@ function _defineProperty(obj, key, value) {
  * DependencyResolver is used to resolve the direct dependencies of a module or
  * to retrieve a list of all transitive inverse dependencies.
  */
-
-/* eslint-disable-next-line no-redeclare */
 class DependencyResolver {
   constructor(resolver, hasteFS, snapshotResolver) {
     _defineProperty(this, '_hasteFS', void 0);
@@ -56,6 +106,7 @@ class DependencyResolver {
       }
 
       let resolvedDependency;
+      let resolvedMockDependency;
 
       try {
         resolvedDependency = this._resolver.resolveModule(
@@ -63,12 +114,40 @@ class DependencyResolver {
           dependency,
           options
         );
-      } catch (e) {
-        resolvedDependency = this._resolver.getMockModule(file, dependency);
+      } catch {
+        try {
+          resolvedDependency = this._resolver.getMockModule(file, dependency);
+        } catch {
+          // leave resolvedDependency as undefined if nothing can be found
+        }
       }
 
-      if (resolvedDependency) {
-        acc.push(resolvedDependency);
+      if (!resolvedDependency) {
+        return acc;
+      }
+
+      acc.push(resolvedDependency); // If we resolve a dependency, then look for a mock dependency
+      // of the same name in that dependency's directory.
+
+      try {
+        resolvedMockDependency = this._resolver.getMockModule(
+          resolvedDependency,
+          path().basename(dependency)
+        );
+      } catch {
+        // leave resolvedMockDependency as undefined if nothing can be found
+      }
+
+      if (resolvedMockDependency) {
+        const dependencyMockDir = path().resolve(
+          path().dirname(resolvedDependency),
+          '__mocks__'
+        );
+        resolvedMockDependency = path().resolve(resolvedMockDependency); // make sure mock is in the correct directory
+
+        if (dependencyMockDir === path().dirname(resolvedMockDependency)) {
+          acc.push(resolvedMockDependency);
+        }
       }
 
       return acc;
@@ -118,77 +197,27 @@ class DependencyResolver {
 
     const relatedPaths = new Set();
     const changed = new Set();
-    var _iteratorNormalCompletion = true;
-    var _didIteratorError = false;
-    var _iteratorError = undefined;
 
-    try {
-      for (
-        var _iterator = paths[Symbol.iterator](), _step;
-        !(_iteratorNormalCompletion = (_step = _iterator.next()).done);
-        _iteratorNormalCompletion = true
-      ) {
-        const path = _step.value;
+    for (const path of paths) {
+      if (this._hasteFS.exists(path)) {
+        const modulePath = (0, _jestSnapshot().isSnapshotPath)(path)
+          ? this._snapshotResolver.resolveTestPath(path)
+          : path;
+        changed.add(modulePath);
 
-        if (this._hasteFS.exists(path)) {
-          const modulePath = (0, _jestSnapshot().isSnapshotPath)(path)
-            ? this._snapshotResolver.resolveTestPath(path)
-            : path;
-          changed.add(modulePath);
-
-          if (filter(modulePath)) {
-            relatedPaths.add(modulePath);
-          }
-        }
-      }
-    } catch (err) {
-      _didIteratorError = true;
-      _iteratorError = err;
-    } finally {
-      try {
-        if (!_iteratorNormalCompletion && _iterator.return != null) {
-          _iterator.return();
-        }
-      } finally {
-        if (_didIteratorError) {
-          throw _iteratorError;
+        if (filter(modulePath)) {
+          relatedPaths.add(modulePath);
         }
       }
     }
 
     const modules = [];
-    var _iteratorNormalCompletion2 = true;
-    var _didIteratorError2 = false;
-    var _iteratorError2 = undefined;
 
-    try {
-      for (
-        var _iterator2 = this._hasteFS
-            .getAbsoluteFileIterator()
-            [Symbol.iterator](),
-          _step2;
-        !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done);
-        _iteratorNormalCompletion2 = true
-      ) {
-        const file = _step2.value;
-        modules.push({
-          dependencies: this.resolve(file, options),
-          file
-        });
-      }
-    } catch (err) {
-      _didIteratorError2 = true;
-      _iteratorError2 = err;
-    } finally {
-      try {
-        if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
-          _iterator2.return();
-        }
-      } finally {
-        if (_didIteratorError2) {
-          throw _iteratorError2;
-        }
-      }
+    for (const file of this._hasteFS.getAbsoluteFileIterator()) {
+      modules.push({
+        dependencies: this.resolve(file, options),
+        file
+      });
     }
 
     return collectModules(relatedPaths, modules, changed);