@parcel/utils 2.0.0-nightly.97 → 2.0.0-nightly.970

package/.eslintrc.js

@@ -5,16 +5,16 @@ const RESTRICTED_CONFIG = [
       {
         name: '@parcel/workers',
         message:
-          'Do not import workers inside utils. Instead, create a separate package.'
-      }
-    ]
-  }
+          'Do not import workers inside utils. Instead, create a separate package.',
+      },
+    ],
+  },
 ];
 
 module.exports = {
   extends: '@parcel/eslint-config',
   rules: {
     'no-restricted-imports': RESTRICTED_CONFIG,
-    'no-restricted-modules': RESTRICTED_CONFIG
-  }
+    'no-restricted-modules': RESTRICTED_CONFIG,
+  },
 };

package/lib/DefaultMap.js

@@ -5,14 +5,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.DefaultWeakMap = exports.DefaultMap = void 0;
 
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
 class DefaultMap extends Map {
   constructor(getDefault, entries) {
     super(entries);
-
-    _defineProperty(this, "_getDefault", void 0);
-
     this._getDefault = getDefault;
   }
 
@@ -39,9 +34,6 @@ exports.DefaultMap = DefaultMap;
 class DefaultWeakMap extends WeakMap {
   constructor(getDefault, entries) {
     super(entries);
-
-    _defineProperty(this, "_getDefault", void 0);
-
     this._getDefault = getDefault;
   }
 

package/lib/Deferred.js

@@ -5,7 +5,15 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.makeDeferredWithPromise = makeDeferredWithPromise;
 
-var _assert = _interopRequireDefault(require("assert"));
+function _assert() {
+  const data = _interopRequireDefault(require("assert"));
+
+  _assert = function () {
+    return data;
+  };
+
+  return data;
+}
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
@@ -18,7 +26,7 @@ function makeDeferredWithPromise() {
     };
   }); // Promise constructor callback executes synchronously, so this is defined
 
-  (0, _assert.default)(deferred != null);
+  (0, _assert().default)(deferred != null);
   return {
     deferred,
     promise

package/lib/PromiseQueue.js

@@ -7,26 +7,16 @@ exports.default = void 0;
 
 var _Deferred = require("./Deferred");
 
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
 class PromiseQueue {
+  _numRunning = 0;
+  _queue = [];
+  _runPromise = null;
+  _count = 0;
+  _results = [];
+
   constructor(opts = {
     maxConcurrent: Infinity
   }) {
-    _defineProperty(this, "_deferred", void 0);
-
-    _defineProperty(this, "_maxConcurrent", void 0);
-
-    _defineProperty(this, "_numRunning", 0);
-
-    _defineProperty(this, "_queue", []);
-
-    _defineProperty(this, "_runPromise", null);
-
-    _defineProperty(this, "_count", 0);
-
-    _defineProperty(this, "_results", []);
-
     if (opts.maxConcurrent <= 0) {
       throw new TypeError('maxConcurrent must be a positive, non-zero value');
     }
@@ -87,7 +77,7 @@ class PromiseQueue {
     if (this._queue.length) {
       this._next();
     } else if (this._numRunning === 0) {
-      this._resolve();
+      this._done();
     }
   }
 
@@ -96,10 +86,15 @@ class PromiseQueue {
 
     try {
       await fn();
-      this._numRunning--;
     } catch (e) {
-      this._reject(e); // rejecting resets state so numRunning is reset to 0 here
-
+      // Only store the first error that occurs.
+      // We don't reject immediately so that any other concurrent
+      // requests have time to complete.
+      if (this._error == null) {
+        this._error = e;
+      }
+    } finally {
+      this._numRunning--;
     }
   }
 
@@ -112,17 +107,13 @@ class PromiseQueue {
     this._deferred = null;
   }
 
-  _reject(err) {
-    if (this._deferred != null) {
-      this._deferred.reject(err);
-    }
-
-    this._resetState();
-  }
-
-  _resolve() {
+  _done() {
     if (this._deferred != null) {
-      this._deferred.resolve(this._results);
+      if (this._error != null) {
+        this._deferred.reject(this._error);
+      } else {
+        this._deferred.resolve(this._results);
+      }
     }
 
     this._resetState();

package/lib/TapStream.js

@@ -5,24 +5,24 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
-var _stream = require("stream");
+function _stream() {
+  const data = require("stream");
 
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+  _stream = function () {
+    return data;
+  };
 
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+  return data;
+}
 
 /*
  * "Taps" into the contents of a flowing stream, yielding chunks to the passed
  * callback. Continues to pass data chunks down the stream.
  */
-class TapStream extends _stream.Transform {
+class TapStream extends _stream().Transform {
   constructor(tap, options) {
-    super(_objectSpread({}, options));
-
-    _defineProperty(this, "_tap", void 0);
-
+    super({ ...options
+    });
     this._tap = tap;
   }
 

package/lib/alternatives.js

@@ -0,0 +1,134 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.findAlternativeNodeModules = findAlternativeNodeModules;
+exports.findAlternativeFiles = findAlternativeFiles;
+
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+
+  _path = function () {
+    return data;
+  };
+
+  return data;
+}
+
+var _schema = require("./schema");
+
+var _path2 = require("./path");
+
+var _config = require("./config");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+async function findAlternativeNodeModules(fs, moduleName, dir) {
+  let potentialModules = [];
+
+  let root = _path().default.parse(dir).root;
+
+  let isOrganisationModule = moduleName.startsWith('@');
+
+  while (dir !== root) {
+    // Skip node_modules directories
+    if (_path().default.basename(dir) === 'node_modules') {
+      dir = _path().default.dirname(dir);
+    }
+
+    try {
+      let modulesDir = _path().default.join(dir, 'node_modules');
+
+      let stats = await fs.stat(modulesDir);
+
+      if (stats.isDirectory()) {
+        let dirContent = (await fs.readdir(modulesDir)).sort(); // Filter out the modules that interest us
+
+        let modules = dirContent.filter(i => isOrganisationModule ? i.startsWith('@') : !i.startsWith('@')); // If it's an organisation module, loop through all the modules of that organisation
+
+        if (isOrganisationModule) {
+          await Promise.all(modules.map(async item => {
+            let orgDirPath = _path().default.join(modulesDir, item);
+
+            let orgDirContent = (await fs.readdir(orgDirPath)).sort(); // Add all org packages
+
+            potentialModules.push(...orgDirContent.map(i => `${item}/${i}`));
+          }));
+        }
+      }
+    } catch (err) {// ignore
+    } // Move up a directory
+
+
+    dir = _path().default.dirname(dir);
+  }
+
+  return (0, _schema.fuzzySearch)(potentialModules.sort(), moduleName).slice(0, 2);
+}
+
+async function findAllFilesUp({
+  fs,
+  dir,
+  root,
+  basedir,
+  maxlength,
+  collected,
+  leadingDotSlash = true,
+  includeDirectories = true
+}) {
+  let dirContent = (await fs.readdir(dir)).sort();
+  return Promise.all(dirContent.map(async item => {
+    let fullPath = _path().default.join(dir, item);
+
+    let relativeFilePath = (0, _path2.relativePath)(basedir, fullPath, leadingDotSlash);
+
+    if (relativeFilePath.length < maxlength) {
+      let stats = await fs.stat(fullPath);
+      let isDir = stats.isDirectory();
+
+      if (isDir && includeDirectories || stats.isFile()) {
+        collected.push(relativeFilePath);
+      } // If it's a directory, run over each item within said directory...
+
+
+      if (isDir) {
+        return findAllFilesUp({
+          fs,
+          dir: fullPath,
+          root,
+          basedir,
+          maxlength,
+          collected
+        });
+      }
+    }
+  }));
+}
+
+async function findAlternativeFiles(fs, fileSpecifier, dir, projectRoot, leadingDotSlash = true, includeDirectories = true, includeExtension = false) {
+  let potentialFiles = []; // Find our root, we won't recommend files above the package root as that's bad practise
+
+  let pkg = await (0, _config.resolveConfig)(fs, _path().default.join(dir, 'index'), ['package.json'], projectRoot);
+  let pkgRoot = pkg ? _path().default.dirname(pkg) : projectRoot;
+  await findAllFilesUp({
+    fs,
+    dir: pkgRoot,
+    root: pkgRoot,
+    basedir: dir,
+    maxlength: fileSpecifier.length + 10,
+    collected: potentialFiles,
+    leadingDotSlash,
+    includeDirectories
+  });
+
+  if (_path().default.extname(fileSpecifier) === '' && !includeExtension) {
+    potentialFiles = potentialFiles.map(p => {
+      let ext = _path().default.extname(p);
+
+      return ext.length > 0 ? p.slice(0, -ext.length) : p;
+    });
+  }
+
+  return (0, _schema.fuzzySearch)(potentialFiles, fileSpecifier).slice(0, 2);
+}

package/lib/ansi-html.js

@@ -5,12 +5,20 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.ansiHtml = ansiHtml;
 
-var _ansiHtml = _interopRequireDefault(require("ansi-html"));
+function _ansiHtmlCommunity() {
+  const data = _interopRequireDefault(require("ansi-html-community"));
+
+  _ansiHtmlCommunity = function () {
+    return data;
+  };
+
+  return data;
+}
 
 var _escapeHtml = require("./escape-html");
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 function ansiHtml(ansi) {
-  return (0, _ansiHtml.default)((0, _escapeHtml.escapeHTML)(ansi));
+  return (0, _ansiHtmlCommunity().default)((0, _escapeHtml.escapeHTML)(ansi));
 }

package/lib/blob.js

@@ -6,24 +6,42 @@ Object.defineProperty(exports, "__esModule", {
 exports.blobToBuffer = blobToBuffer;
 exports.blobToString = blobToString;
 
-var _ = require("../");
+function _buffer() {
+  const data = require("buffer");
 
-var _stream = require("stream");
+  _buffer = function () {
+    return data;
+  };
+
+  return data;
+}
+
+var _ = require("./");
+
+function _stream() {
+  const data = require("stream");
+
+  _stream = function () {
+    return data;
+  };
+
+  return data;
+}
 
 function blobToBuffer(blob) {
-  if (blob instanceof _stream.Readable) {
+  if (blob instanceof _stream().Readable) {
     return (0, _.bufferStream)(blob);
-  } else if (blob instanceof Buffer) {
-    return Buffer.from(blob);
+  } else if (blob instanceof _buffer().Buffer) {
+    return Promise.resolve(_buffer().Buffer.from(blob));
   } else {
-    return Buffer.from(blob, 'utf8');
+    return Promise.resolve(_buffer().Buffer.from(blob, 'utf8'));
   }
 }
 
 async function blobToString(blob) {
-  if (blob instanceof _stream.Readable) {
+  if (blob instanceof _stream().Readable) {
     return (await (0, _.bufferStream)(blob)).toString();
-  } else if (blob instanceof Buffer) {
+  } else if (blob instanceof _buffer().Buffer) {
     return blob.toString();
   } else {
     return blob;

package/lib/collection.js

@@ -4,25 +4,16 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.unique = unique;
-exports.flatMap = flatMap;
 exports.objectSortedEntries = objectSortedEntries;
 exports.objectSortedEntriesDeep = objectSortedEntriesDeep;
 exports.setDifference = setDifference;
+exports.setIntersect = setIntersect;
+exports.setUnion = setUnion;
 
 function unique(array) {
   return [...new Set(array)];
 }
 
-function flatMap(array, projectFn) {
-  let out = [];
-
-  for (let arr of array.map(projectFn)) {
-    out.push(...arr);
-  }
-
-  return out;
-}
-
 function objectSortedEntries(obj) {
   return Object.entries(obj).sort(([keyA], [keyB]) => keyA.localeCompare(keyB));
 }
@@ -59,4 +50,16 @@ function setDifference(a, b) {
   }
 
   return difference;
+}
+
+function setIntersect(a, b) {
+  for (let entry of a) {
+    if (!b.has(entry)) {
+      a.delete(entry);
+    }
+  }
+}
+
+function setUnion(a, b) {
+  return new Set([...a, ...b]);
 }

package/lib/config.js

@@ -4,79 +4,173 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.resolveConfig = resolveConfig;
+exports.resolveConfigSync = resolveConfigSync;
 exports.loadConfig = loadConfig;
 
-var _path = _interopRequireDefault(require("path"));
+function _diagnostic() {
+  const data = _interopRequireDefault(require("@parcel/diagnostic"));
 
-var _clone = _interopRequireDefault(require("clone"));
+  _diagnostic = function () {
+    return data;
+  };
 
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+  return data;
+}
 
-const PARSERS = {
-  json: require('json5').parse,
-  toml: require('@iarna/toml').parse
-};
-const existsCache = new Map();
+function _path() {
+  const data = _interopRequireDefault(require("path"));
 
-async function resolveConfig(fs, filepath, filenames, opts, root = _path.default.parse(filepath).root) {
-  filepath = await fs.realpath(_path.default.dirname(filepath)); // Don't traverse above the module root
+  _path = function () {
+    return data;
+  };
 
-  if (filepath === root || _path.default.basename(filepath) === 'node_modules') {
-    return null;
-  }
+  return data;
+}
 
-  for (const filename of filenames) {
-    let file = _path.default.join(filepath, filename);
+function _clone() {
+  const data = _interopRequireDefault(require("clone"));
 
-    if ((await fs.exists(file)) && (await fs.stat(file)).isFile()) {
-      return file;
-    }
+  _clone = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _json() {
+  const data = require("json5");
+
+  _json = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _toml() {
+  const data = require("@iarna/toml");
+
+  _toml = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _lruCache() {
+  const data = _interopRequireDefault(require("lru-cache"));
+
+  _lruCache = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const configCache = new (_lruCache().default)({
+  max: 500
+});
+const resolveCache = new Map();
+
+function resolveConfig(fs, filepath, filenames, projectRoot) {
+  // Cache the result of resolving config for this directory.
+  // This is automatically invalidated at the end of the current build.
+  let key = _path().default.dirname(filepath) + filenames.join(',');
+  let cached = resolveCache.get(key);
+
+  if (cached !== undefined) {
+    return Promise.resolve(cached);
   }
 
-  return resolveConfig(fs, filepath, filenames, opts);
+  let resolved = fs.findAncestorFile(filenames, _path().default.dirname(filepath), projectRoot);
+  resolveCache.set(key, resolved);
+  return Promise.resolve(resolved);
 }
 
-async function loadConfig(fs, filepath, filenames, opts) {
-  let configFile = await resolveConfig(fs, filepath, filenames, opts);
+function resolveConfigSync(fs, filepath, filenames, projectRoot) {
+  return fs.findAncestorFile(filenames, _path().default.dirname(filepath), projectRoot);
+}
+
+async function loadConfig(fs, filepath, filenames, projectRoot, opts) {
+  var _opts$parse;
+
+  let parse = (_opts$parse = opts === null || opts === void 0 ? void 0 : opts.parse) !== null && _opts$parse !== void 0 ? _opts$parse : true;
+  let configFile = await resolveConfig(fs, filepath, filenames, projectRoot);
 
   if (configFile) {
+    let cachedOutput = configCache.get(String(parse) + configFile);
+
+    if (cachedOutput) {
+      return cachedOutput;
+    }
+
     try {
-      let extname = _path.default.extname(configFile).slice(1);
+      let extname = _path().default.extname(configFile).slice(1);
 
       if (extname === 'js') {
-        return {
+        let output = {
           // $FlowFixMe
-          config: (0, _clone.default)(require(configFile)),
+          config: (0, _clone().default)(require(configFile)),
           files: [{
             filePath: configFile
           }]
         };
+        configCache.set(configFile, output);
+        return output;
       }
 
       let configContent = await fs.readFile(configFile, 'utf8');
-
-      if (!configContent) {
-        return null;
-      }
-
       let config;
 
-      if (opts && opts.parse === false) {
+      if (parse === false) {
         config = configContent;
       } else {
-        let parse = PARSERS[extname] || PARSERS.json;
-        config = parse(configContent);
+        var _opts$parser;
+
+        let parse = (_opts$parser = opts === null || opts === void 0 ? void 0 : opts.parser) !== null && _opts$parser !== void 0 ? _opts$parser : getParser(extname);
+
+        try {
+          config = parse(configContent);
+        } catch (e) {
+          if (extname !== '' && extname !== 'json') {
+            throw e;
+          }
+
+          let pos = {
+            line: e.lineNumber,
+            column: e.columnNumber
+          };
+          throw new (_diagnostic().default)({
+            diagnostic: {
+              message: `Failed to parse ${_path().default.basename(configFile)}`,
+              origin: '@parcel/utils',
+              codeFrames: [{
+                language: 'json5',
+                filePath: configFile,
+                code: configContent,
+                codeHighlights: [{
+                  start: pos,
+                  end: pos,
+                  message: e.message
+                }]
+              }]
+            }
+          });
+        }
       }
 
-      return {
-        config: config,
+      let output = {
+        config,
         files: [{
           filePath: configFile
         }]
       };
+      configCache.set(String(parse) + configFile, output);
+      return output;
     } catch (err) {
       if (err.code === 'MODULE_NOT_FOUND' || err.code === 'ENOENT') {
-        existsCache.delete(configFile);
         return null;
       }
 
@@ -85,4 +179,20 @@ async function loadConfig(fs, filepath, filenames, opts) {
   }
 
   return null;
+}
+
+loadConfig.clear = () => {
+  configCache.reset();
+  resolveCache.clear();
+};
+
+function getParser(extname) {
+  switch (extname) {
+    case 'toml':
+      return _toml().parse;
+
+    case 'json':
+    default:
+      return _json().parse;
+  }
 }

package/lib/countLines.js

@@ -5,10 +5,10 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = countLines;
 
-function countLines(string) {
+function countLines(string, startIndex = 0) {
   let lines = 1;
 
-  for (let i = 0; i < string.length; i++) {
+  for (let i = startIndex; i < string.length; i++) {
     if (string.charAt(i) === '\n') {
       lines++;
     }