Updating NPM dependencies

node_modules/jest-resolve/build/index.js

@@ -1,19 +1,9 @@
 'use strict';
 
-function _path() {
-  const data = _interopRequireDefault(require('path'));
+function path() {
+  const data = _interopRequireWildcard(require('path'));
 
-  _path = function _path() {
-    return data;
-  };
-
-  return data;
-}
-
-function _realpathNative() {
-  const data = require('realpath-native');
-
-  _realpathNative = function _realpathNative() {
+  path = function () {
     return data;
   };
 
@@ -23,46 +13,89 @@ function _realpathNative() {
 function _chalk() {
   const data = _interopRequireDefault(require('chalk'));
 
-  _chalk = function _chalk() {
+  _chalk = function () {
     return data;
   };
 
   return data;
 }
 
-var _nodeModulesPaths = _interopRequireDefault(require('./nodeModulesPaths'));
+function _slash() {
+  const data = _interopRequireDefault(require('slash'));
+
+  _slash = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _jestUtil() {
+  const data = require('jest-util');
+
+  _jestUtil = function () {
+    return data;
+  };
+
+  return data;
+}
+
+var _ModuleNotFoundError = _interopRequireDefault(
+  require('./ModuleNotFoundError')
+);
+
+var _defaultResolver = _interopRequireWildcard(require('./defaultResolver'));
 
 var _isBuiltinModule = _interopRequireDefault(require('./isBuiltinModule'));
 
-var _defaultResolver = _interopRequireWildcard(require('./defaultResolver'));
+var _nodeModulesPaths = _interopRequireDefault(require('./nodeModulesPaths'));
+
+var _shouldLoadAsEsm = _interopRequireWildcard(require('./shouldLoadAsEsm'));
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+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;
-  } else {
-    var newObj = {};
-    if (obj != null) {
-      for (var key in obj) {
-        if (Object.prototype.hasOwnProperty.call(obj, key)) {
-          var desc =
-            Object.defineProperty && Object.getOwnPropertyDescriptor
-              ? Object.getOwnPropertyDescriptor(obj, key)
-              : {};
-          if (desc.get || desc.set) {
-            Object.defineProperty(newObj, key, desc);
-          } else {
-            newObj[key] = obj[key];
-          }
-        }
+  }
+  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;
-    return newObj;
   }
-}
-
-function _interopRequireDefault(obj) {
-  return obj && obj.__esModule ? obj : {default: obj};
+  newObj.default = obj;
+  if (cache) {
+    cache.set(obj, newObj);
+  }
+  return newObj;
 }
 
 function _defineProperty(obj, key, value) {
@@ -81,15 +114,13 @@ function _defineProperty(obj, key, value) {
 
 const NATIVE_PLATFORM = 'native'; // We might be inside a symlink.
 
-const cwd = process.cwd();
-const resolvedCwd = (0, _realpathNative().sync)(cwd) || cwd;
-const NODE_PATH = process.env.NODE_PATH;
+const resolvedCwd = (0, _jestUtil().tryRealpath)(process.cwd());
+const {NODE_PATH} = process.env;
 const nodePaths = NODE_PATH
-  ? NODE_PATH.split(_path().default.delimiter)
+  ? NODE_PATH.split(path().delimiter)
       .filter(Boolean) // The resolver expects absolute paths.
-      .map(p => _path().default.resolve(resolvedCwd, p))
+      .map(p => path().resolve(resolvedCwd, p))
   : undefined;
-/* eslint-disable-next-line no-redeclare */
 
 class Resolver {
   constructor(moduleMap, options) {
@@ -106,7 +137,6 @@ class Resolver {
     _defineProperty(this, '_supportsNativePlatform', void 0);
 
     this._options = {
-      browser: options.browser,
       defaultPlatform: options.defaultPlatform,
       extensions: options.extensions,
       hasCoreModules:
@@ -127,8 +157,23 @@ class Resolver {
     this._modulePathCache = new Map();
   }
 
+  static tryCastModuleNotFoundError(error) {
+    if (error instanceof _ModuleNotFoundError.default) {
+      return error;
+    }
+
+    const casted = error;
+
+    if (casted.code === 'MODULE_NOT_FOUND') {
+      return _ModuleNotFoundError.default.duckType(casted);
+    }
+
+    return null;
+  }
+
   static clearDefaultResolverCache() {
     (0, _defaultResolver.clearDefaultResolverCache)();
+    (0, _shouldLoadAsEsm.clearCachedLookups)();
   }
 
   static findNodeModule(path, options) {
@@ -147,15 +192,19 @@ class Resolver {
         paths: paths ? (nodePaths || []).concat(paths) : nodePaths,
         rootDir: options.rootDir
       });
-    } catch (e) {}
+    } catch (e) {
+      if (options.throwIfNotFound) {
+        throw e;
+      }
+    }
 
     return null;
-  }
+  } // unstable as it should be replaced by https://github.com/nodejs/modules/issues/393, and we don't want people to use it
 
   resolveModuleFromDirIfExists(dirname, moduleName, options) {
     const paths = (options && options.paths) || this._options.modulePaths;
     const moduleDirectory = this._options.moduleDirectories;
-    const key = dirname + _path().default.delimiter + moduleName;
+    const key = dirname + path().delimiter + moduleName;
     const defaultPlatform = this._options.defaultPlatform;
 
     const extensions = this._options.extensions.slice();
@@ -195,23 +244,21 @@ class Resolver {
     // exist and aren't mocked.
 
     const skipResolution =
-      options &&
-      options.skipNodeResolution &&
-      !moduleName.includes(_path().default.sep);
+      options && options.skipNodeResolution && !moduleName.includes(path().sep);
 
-    const resolveNodeModule = name =>
+    const resolveNodeModule = (name, throwIfNotFound = false) =>
       Resolver.findNodeModule(name, {
         basedir: dirname,
-        browser: this._options.browser,
         extensions,
         moduleDirectory,
         paths,
         resolver: this._options.resolver,
-        rootDir: this._options.rootDir
+        rootDir: this._options.rootDir,
+        throwIfNotFound
       });
 
     if (!skipResolution) {
-      module = resolveNodeModule(moduleName);
+      module = resolveNodeModule(moduleName, Boolean(process.versions.pnp));
 
       if (module) {
         this._moduleNameCache.set(key, module);
@@ -226,9 +273,9 @@ class Resolver {
 
     if (hastePackage) {
       try {
-        const module = _path().default.join.apply(
-          _path().default,
-          [_path().default.dirname(hastePackage)].concat(parts)
+        const module = path().join.apply(
+          path(),
+          [path().dirname(hastePackage)].concat(parts)
         ); // try resolving with custom resolver first to support extensions,
         // then fallback to require.resolve
 
@@ -238,15 +285,14 @@ class Resolver {
         this._moduleNameCache.set(key, resolvedModule);
 
         return resolvedModule;
-      } catch (ignoredError) {}
+      } catch {}
     }
 
     return null;
   }
 
   resolveModule(from, moduleName, options) {
-    const dirname = _path().default.dirname(from);
-
+    const dirname = path().dirname(from);
     const module =
       this.resolveStubModuleName(from, moduleName) ||
       this.resolveModuleFromDirIfExists(dirname, moduleName, options);
@@ -254,18 +300,30 @@ class Resolver {
     // produces an error based on the dirname but we have the actual current
     // module name available.
 
-    const relativePath = _path().default.relative(dirname, from);
-
-    const err = new Error(
-      `Cannot find module '${moduleName}' from '${relativePath || '.'}'`
+    const relativePath =
+      (0, _slash().default)(path().relative(this._options.rootDir, from)) ||
+      '.';
+    throw new _ModuleNotFoundError.default(
+      `Cannot find module '${moduleName}' from '${relativePath}'`,
+      moduleName
     );
-    err.code = 'MODULE_NOT_FOUND';
-    throw err;
+  }
+
+  _isAliasModule(moduleName) {
+    const moduleNameMapper = this._options.moduleNameMapper;
+
+    if (!moduleNameMapper) {
+      return false;
+    }
+
+    return moduleNameMapper.some(({regex}) => regex.test(moduleName));
   }
 
   isCoreModule(moduleName) {
     return (
-      this._options.hasCoreModules && (0, _isBuiltinModule.default)(moduleName)
+      this._options.hasCoreModules &&
+      (0, _isBuiltinModule.default)(moduleName) &&
+      !this._isAliasModule(moduleName)
     );
   }
 
@@ -278,13 +336,11 @@ class Resolver {
   }
 
   getModulePath(from, moduleName) {
-    if (moduleName[0] !== '.' || _path().default.isAbsolute(moduleName)) {
+    if (moduleName[0] !== '.' || path().isAbsolute(moduleName)) {
       return moduleName;
     }
 
-    return _path().default.normalize(
-      _path().default.dirname(from) + '/' + moduleName
-    );
+    return path().normalize(path().dirname(from) + '/' + moduleName);
   }
 
   getPackage(name) {
@@ -335,7 +391,7 @@ class Resolver {
 
   getModuleID(virtualMocks, from, _moduleName) {
     const moduleName = _moduleName || '';
-    const key = from + _path().default.delimiter + moduleName;
+    const key = from + path().delimiter + moduleName;
 
     const cachedModuleID = this._moduleIDCache.get(key);
 
@@ -349,8 +405,7 @@ class Resolver {
 
     const mockPath = this._getMockPath(from, moduleName);
 
-    const sep = _path().default.delimiter;
-
+    const sep = path().delimiter;
     const id =
       moduleType +
       sep +
@@ -398,8 +453,7 @@ class Resolver {
   }
 
   resolveStubModuleName(from, moduleName) {
-    const dirname = _path().default.dirname(from);
-
+    const dirname = path().dirname(from);
     const paths = this._options.modulePaths;
 
     const extensions = this._options.extensions.slice();
@@ -422,35 +476,29 @@ class Resolver {
     }
 
     if (moduleNameMapper) {
-      var _iteratorNormalCompletion = true;
-      var _didIteratorError = false;
-      var _iteratorError = undefined;
-
-      try {
-        for (
-          var _iterator = moduleNameMapper[Symbol.iterator](), _step;
-          !(_iteratorNormalCompletion = (_step = _iterator.next()).done);
-          _iteratorNormalCompletion = true
-        ) {
-          const _step$value = _step.value,
-            mappedModuleName = _step$value.moduleName,
-            regex = _step$value.regex;
-
-          if (regex.test(moduleName)) {
-            // Note: once a moduleNameMapper matches the name, it must result
-            // in a module, or else an error is thrown.
-            const matches = moduleName.match(regex);
-            const updatedName = matches
-              ? mappedModuleName.replace(
+      for (const {moduleName: mappedModuleName, regex} of moduleNameMapper) {
+        if (regex.test(moduleName)) {
+          // Note: once a moduleNameMapper matches the name, it must result
+          // in a module, or else an error is thrown.
+          const matches = moduleName.match(regex);
+          const mapModuleName = matches
+            ? moduleName =>
+                moduleName.replace(
                   /\$([0-9]+)/g,
                   (_, index) => matches[parseInt(index, 10)]
                 )
-              : mappedModuleName;
-            const module =
+            : moduleName => moduleName;
+          const possibleModuleNames = Array.isArray(mappedModuleName)
+            ? mappedModuleName
+            : [mappedModuleName];
+          let module = null;
+
+          for (const possibleModuleName of possibleModuleNames) {
+            const updatedName = mapModuleName(possibleModuleName);
+            module =
               this.getModule(updatedName) ||
               Resolver.findNodeModule(updatedName, {
                 basedir: dirname,
-                browser: this._options.browser,
                 extensions,
                 moduleDirectory,
                 paths,
@@ -458,31 +506,22 @@ class Resolver {
                 rootDir: this._options.rootDir
               });
 
-            if (!module) {
-              throw createNoMappedModuleFoundError(
-                moduleName,
-                updatedName,
-                mappedModuleName,
-                regex,
-                resolver
-              );
+            if (module) {
+              break;
             }
+          }
 
-            return module;
-          }
-        }
-      } catch (err) {
-        _didIteratorError = true;
-        _iteratorError = err;
-      } finally {
-        try {
-          if (!_iteratorNormalCompletion && _iterator.return != null) {
-            _iterator.return();
-          }
-        } finally {
-          if (_didIteratorError) {
-            throw _iteratorError;
+          if (!module) {
+            throw createNoMappedModuleFoundError(
+              moduleName,
+              mapModuleName,
+              mappedModuleName,
+              regex,
+              resolver
+            );
           }
+
+          return module;
         }
       }
     }
@@ -491,23 +530,34 @@ class Resolver {
   }
 }
 
+_defineProperty(Resolver, 'ModuleNotFoundError', _ModuleNotFoundError.default);
+
+_defineProperty(Resolver, 'unstable_shouldLoadAsEsm', _shouldLoadAsEsm.default);
+
 const createNoMappedModuleFoundError = (
   moduleName,
-  updatedName,
+  mapModuleName,
   mappedModuleName,
   regex,
   resolver
 ) => {
+  const mappedAs = Array.isArray(mappedModuleName)
+    ? JSON.stringify(mappedModuleName.map(mapModuleName), null, 2)
+    : mappedModuleName;
+  const original = Array.isArray(mappedModuleName)
+    ? JSON.stringify(mappedModuleName, null, 6) // using 6 because of misalignment when nested below
+        .slice(0, -1) + '    ]' /// align last bracket correctly as well
+    : mappedModuleName;
   const error = new Error(
     _chalk().default.red(`${_chalk().default.bold('Configuration error')}:
 
 Could not locate module ${_chalk().default.bold(moduleName)} mapped as:
-${_chalk().default.bold(updatedName)}.
+${_chalk().default.bold(mappedAs)}.
 
 Please check your configuration for these entries:
 {
   "moduleNameMapper": {
-    "${regex.toString()}": "${_chalk().default.bold(mappedModuleName)}"
+    "${regex.toString()}": "${_chalk().default.bold(original)}"
   },
   "resolver": ${_chalk().default.bold(String(resolver))}
 }`)