@parcel/utils 2.0.0-nightly.151 → 2.0.0-nightly.1511

package/package.json

@@ -1,11 +1,15 @@
 {
   "name": "@parcel/utils",
-  "version": "2.0.0-nightly.151+1af603e1",
+  "version": "2.0.0-nightly.1511+2059029ee",
   "description": "Blazing fast, zero configuration web application bundler",
   "license": "MIT",
   "publishConfig": {
     "access": "public"
   },
+  "funding": {
+    "type": "opencollective",
+    "url": "https://opencollective.com/parcel"
+  },
   "repository": {
     "type": "git",
     "url": "https://github.com/parcel-bundler/parcel.git"
@@ -13,32 +17,55 @@
   "main": "lib/index.js",
   "source": "src/index.js",
   "engines": {
-    "node": ">= 10.0.0"
+    "node": ">= 12.0.0"
+  },
+  "targets": {
+    "main": {
+      "includeNodeModules": {
+        "@parcel/codeframe": false,
+        "@parcel/diagnostic": false,
+        "@parcel/rust": false,
+        "@parcel/logger": false,
+        "@parcel/markdown-ansi": false,
+        "@parcel/source-map": false,
+        "chalk": false
+      }
+    }
   },
   "dependencies": {
+    "@parcel/codeframe": "2.0.0-nightly.1511+2059029ee",
+    "@parcel/diagnostic": "2.0.0-nightly.1511+2059029ee",
+    "@parcel/logger": "2.0.0-nightly.1511+2059029ee",
+    "@parcel/markdown-ansi": "2.0.0-nightly.1511+2059029ee",
+    "@parcel/rust": "2.12.1-nightly.3134+2059029ee",
+    "@parcel/source-map": "^2.1.1",
+    "chalk": "^4.1.0",
+    "nullthrows": "^1.1.1"
+  },
+  "devDependencies": {
     "@iarna/toml": "^2.2.0",
-    "@parcel/codeframe": "2.0.0-nightly.151+1af603e1",
-    "@parcel/diagnostic": "2.0.0-nightly.151+1af603e1",
-    "@parcel/logger": "2.0.0-nightly.151+1af603e1",
-    "@parcel/markdown-ansi": "2.0.0-nightly.151+1af603e1",
-    "ansi-html": "^0.0.7",
-    "chalk": "^2.4.2",
+    "ansi-html-community": "0.0.8",
     "clone": "^2.1.1",
-    "fast-glob": "3.1.1",
+    "fast-glob": "^3.2.12",
+    "fastest-levenshtein": "^1.0.16",
     "is-glob": "^4.0.0",
     "is-url": "^1.2.2",
-    "js-levenshtein": "^1.1.6",
-    "json5": "^1.0.1",
-    "micromatch": "^4.0.2",
-    "node-forge": "^0.8.1",
+    "json5": "^2.2.0",
+    "lru-cache": "^6.0.0",
+    "micromatch": "^4.0.4",
+    "node-forge": "^1.2.1",
     "nullthrows": "^1.1.1",
-    "resolve": "^1.12.0",
-    "serialize-to-js": "^3.0.1",
-    "terser": "^3.7.3"
+    "open": "^7.0.3",
+    "random-int": "^1.0.0",
+    "snarkdown": "^2.0.0",
+    "strip-ansi": "^6.0.0",
+    "terminal-link": "^2.1.1"
   },
-  "devDependencies": {
-    "@babel/plugin-transform-flow-strip-types": "^7.2.0",
-    "random-int": "^1.0.0"
+  "browser": {
+    "./src/generateCertificate.js": false,
+    "./src/http-server.js": false,
+    "./src/openInBrowser.js": false,
+    "@parcel/markdown-ansi": false
   },
-  "gitHead": "1af603e1cfab014585ded8aec4d3dcdb7e685987"
+  "gitHead": "2059029ee91e5f03a273b0954d3e629d7375f986"
 }

package/src/DefaultMap.js

@@ -24,7 +24,7 @@ export class DefaultMap<K, V> extends Map<K, V> {
 
 // Duplicated from DefaultMap implementation for Flow
 // Roughly mirrors https://github.com/facebook/flow/blob/2eb5a78d92c167117ba9caae070afd2b9f598599/lib/core.js#L617
-export class DefaultWeakMap<K: {...}, V> extends WeakMap<K, V> {
+export class DefaultWeakMap<K: interface {}, V> extends WeakMap<K, V> {
   _getDefault: K => V;
 
   constructor(getDefault: K => V, entries?: Iterable<[K, V]>) {

package/src/PromiseQueue.js

@@ -10,8 +10,10 @@ export default class PromiseQueue<T> {
   _numRunning: number = 0;
   _queue: Array<() => Promise<void>> = [];
   _runPromise: ?Promise<Array<T>> = null;
+  _error: mixed;
   _count: number = 0;
   _results: Array<T> = [];
+  _addSubscriptions: Set<() => void> = new Set();
 
   constructor(opts: PromiseQueueOpts = {maxConcurrent: Infinity}) {
     if (opts.maxConcurrent <= 0) {
@@ -42,12 +44,24 @@ export default class PromiseQueue<T> {
 
       this._queue.push(wrapped);
 
+      for (const addFn of this._addSubscriptions) {
+        addFn();
+      }
+
       if (this._numRunning > 0 && this._numRunning < this._maxConcurrent) {
         this._next();
       }
     });
   }
 
+  subscribeToAdd(fn: () => void): () => void {
+    this._addSubscriptions.add(fn);
+
+    return () => {
+      this._addSubscriptions.delete(fn);
+    };
+  }
+
   run(): Promise<Array<T>> {
     if (this._runPromise != null) {
       return this._runPromise;
@@ -74,7 +88,7 @@ export default class PromiseQueue<T> {
     if (this._queue.length) {
       this._next();
     } else if (this._numRunning === 0) {
-      this._resolve();
+      this._done();
     }
   }
 
@@ -82,10 +96,15 @@ export default class PromiseQueue<T> {
     this._numRunning++;
     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--;
     }
   }
 
@@ -98,17 +117,15 @@ export default class PromiseQueue<T> {
     this._deferred = null;
   }
 
-  _reject(err: mixed): void {
+  _done(): void {
     if (this._deferred != null) {
-      this._deferred.reject(err);
+      if (this._error != null) {
+        this._deferred.reject(this._error);
+      } else {
+        this._deferred.resolve(this._results);
+      }
     }
-    this._resetState();
-  }
 
-  _resolve(): void {
-    if (this._deferred != null) {
-      this._deferred.resolve(this._results);
-    }
     this._resetState();
   }
 }

package/src/alternatives.js

@@ -0,0 +1,145 @@
+// @flow
+import path from 'path';
+import type {FileSystem} from '@parcel/fs';
+import {fuzzySearch} from './schema';
+import {relativePath} from './path';
+import {resolveConfig} from './config';
+
+export async function findAlternativeNodeModules(
+  fs: FileSystem,
+  moduleName: string,
+  dir: string,
+): Promise<Array<string>> {
+  let potentialModules: Array<string> = [];
+  let root = path.parse(dir).root;
+  let isOrganisationModule = moduleName.startsWith('@');
+
+  while (dir !== root) {
+    // Skip node_modules directories
+    if (path.basename(dir) === 'node_modules') {
+      dir = path.dirname(dir);
+    }
+
+    try {
+      let modulesDir = path.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.join(modulesDir, item);
+              let orgDirContent = (await fs.readdir(orgDirPath)).sort();
+
+              // Add all org packages
+              potentialModules.push(...orgDirContent.map(i => `${item}/${i}`));
+            }),
+          );
+        } else {
+          potentialModules.push(...modules);
+        }
+      }
+    } catch (err) {
+      // ignore
+    }
+
+    // Move up a directory
+    dir = path.dirname(dir);
+  }
+
+  return fuzzySearch(potentialModules.sort(), moduleName).slice(0, 2);
+}
+
+async function findAllFilesUp({
+  fs,
+  dir,
+  root,
+  basedir,
+  maxlength,
+  collected,
+  leadingDotSlash = true,
+  includeDirectories = true,
+}: {|
+  fs: FileSystem,
+  dir: string,
+  root: string,
+  basedir: string,
+  maxlength: number,
+  collected: Array<string>,
+  leadingDotSlash?: boolean,
+  includeDirectories?: boolean,
+|}): Promise<mixed> {
+  let dirContent = (await fs.readdir(dir)).sort();
+  return Promise.all(
+    dirContent.map(async item => {
+      let fullPath = path.join(dir, item);
+      let relativeFilePath = 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,
+          });
+        }
+      }
+    }),
+  );
+}
+
+export async function findAlternativeFiles(
+  fs: FileSystem,
+  fileSpecifier: string,
+  dir: string,
+  projectRoot: string,
+  leadingDotSlash?: boolean = true,
+  includeDirectories?: boolean = true,
+  includeExtension?: boolean = false,
+): Promise<Array<string>> {
+  let potentialFiles: Array<string> = [];
+  // Find our root, we won't recommend files above the package root as that's bad practise
+  let pkg = await resolveConfig(
+    fs,
+    path.join(dir, 'index'),
+    ['package.json'],
+    projectRoot,
+  );
+
+  let pkgRoot = pkg ? path.dirname(pkg) : projectRoot;
+  await findAllFilesUp({
+    fs,
+    dir: pkgRoot,
+    root: pkgRoot,
+    basedir: dir,
+    maxlength: fileSpecifier.length + 10,
+    collected: potentialFiles,
+    leadingDotSlash,
+    includeDirectories,
+  });
+
+  if (path.extname(fileSpecifier) === '' && !includeExtension) {
+    potentialFiles = potentialFiles.map(p => {
+      let ext = path.extname(p);
+      return ext.length > 0 ? p.slice(0, -ext.length) : p;
+    });
+  }
+
+  return fuzzySearch(potentialFiles, fileSpecifier).slice(0, 2);
+}

package/src/ansi-html.js

@@ -1,5 +1,5 @@
-// @flow
-import ansiHTML from 'ansi-html';
+// @flow strict-local
+import ansiHTML from 'ansi-html-community';
 import {escapeHTML} from './escape-html';
 
 export function ansiHtml(ansi: string): string {

package/src/blob.js

@@ -2,7 +2,8 @@
 
 import type {Blob} from '@parcel/types';
 
-import {bufferStream} from '../';
+import {Buffer} from 'buffer';
+import {bufferStream} from './';
 import {Readable} from 'stream';
 
 export function blobToBuffer(blob: Blob): Promise<Buffer> {

package/src/bundle-url.js

@@ -1,7 +1,7 @@
 // @flow strict-local
 
 let bundleURL: ?string = null;
-function getBundleURLCached() {
+function getBundleURLCached(): string {
   if (bundleURL == null) {
     bundleURL = _getBundleURL();
   }

package/src/collection.js

@@ -4,28 +4,16 @@ export function unique<T>(array: Array<T>): Array<T> {
   return [...new Set(array)];
 }
 
-export function flatMap<T, U>(
-  array: Array<T>,
-  projectFn: (T, number, Array<T>) => Array<U>,
-): Array<U> {
-  let out = [];
-
-  for (let arr of array.map(projectFn)) {
-    out.push(...arr);
-  }
-  return out;
-}
-
 export function objectSortedEntries(obj: {
   +[string]: mixed,
-  ...,
+  ...
 }): Array<[string, mixed]> {
   return Object.entries(obj).sort(([keyA], [keyB]) => keyA.localeCompare(keyB));
 }
 
 export function objectSortedEntriesDeep(object: {
   +[string]: mixed,
-  ...,
+  ...
 }): Array<[string, mixed]> {
   let sortedEntries = objectSortedEntries(object);
   for (let i = 0; i < sortedEntries.length; i++) {
@@ -46,12 +34,44 @@ function sortEntry(entry: mixed) {
   return entry;
 }
 
-export function setDifference<T>(a: Set<T>, b: Set<T>): Set<T> {
+export function setDifference<T>(
+  a: $ReadOnlySet<T>,
+  b: $ReadOnlySet<T>,
+): Set<T> {
   let difference = new Set();
   for (let e of a) {
     if (!b.has(e)) {
       difference.add(e);
     }
   }
+  for (let d of b) {
+    if (!a.has(d)) {
+      difference.add(d);
+    }
+  }
   return difference;
 }
+
+export function setIntersect<T>(a: Set<T>, b: $ReadOnlySet<T>): void {
+  for (let entry of a) {
+    if (!b.has(entry)) {
+      a.delete(entry);
+    }
+  }
+}
+
+export function setUnion<T>(a: Iterable<T>, b: Iterable<T>): Set<T> {
+  return new Set([...a, ...b]);
+}
+
+export function setEqual<T>(a: $ReadOnlySet<T>, b: $ReadOnlySet<T>): boolean {
+  if (a.size != b.size) {
+    return false;
+  }
+  for (let entry of a) {
+    if (!b.has(entry)) {
+      return false;
+    }
+  }
+  return true;
+}

package/src/config.js

@@ -2,87 +2,89 @@
 
 import type {ConfigResult, File, FilePath} from '@parcel/types';
 import type {FileSystem} from '@parcel/fs';
+import ThrowableDiagnostic from '@parcel/diagnostic';
 import path from 'path';
 import clone from 'clone';
+import json5 from 'json5';
+import {parse as toml} from '@iarna/toml';
+import LRU from 'lru-cache';
 
-type ConfigOutput = {|
+export type ConfigOutput = {|
   config: ConfigResult,
   files: Array<File>,
 |};
 
-type ConfigOptions = {|
+export type ConfigOptions = {|
   parse?: boolean,
+  parser?: string => any,
 |};
 
-const PARSERS = {
-  json: require('json5').parse,
-  toml: require('@iarna/toml').parse,
-};
-
-const existsCache = new Map();
+const configCache = new LRU<FilePath, ConfigOutput>({max: 500});
+const resolveCache = new Map();
 
-export async function resolveConfig(
+export function resolveConfig(
   fs: FileSystem,
   filepath: FilePath,
   filenames: Array<FilePath>,
-  opts: ?ConfigOptions,
-  root: FilePath = path.parse(filepath).root,
-): Promise<FilePath | null> {
-  filepath = await fs.realpath(path.dirname(filepath));
-
-  // Don't traverse above the module root
-  if (filepath === root || path.basename(filepath) === 'node_modules') {
-    return null;
+  projectRoot: FilePath,
+): Promise<?FilePath> {
+  // Cache the result of resolving config for this directory.
+  // This is automatically invalidated at the end of the current build.
+  let key = path.dirname(filepath) + filenames.join(',');
+  let cached = resolveCache.get(key);
+  if (cached !== undefined) {
+    return Promise.resolve(cached);
   }
 
-  for (const filename of filenames) {
-    let file = path.join(filepath, filename);
-    if ((await fs.exists(file)) && (await fs.stat(file)).isFile()) {
-      return file;
-    }
-  }
+  let resolved = fs.findAncestorFile(
+    filenames,
+    path.dirname(filepath),
+    projectRoot,
+  );
+  resolveCache.set(key, resolved);
+  return Promise.resolve(resolved);
+}
 
-  return resolveConfig(fs, filepath, filenames, opts);
+export function resolveConfigSync(
+  fs: FileSystem,
+  filepath: FilePath,
+  filenames: Array<FilePath>,
+  projectRoot: FilePath,
+): ?FilePath {
+  return fs.findAncestorFile(filenames, path.dirname(filepath), projectRoot);
 }
 
 export async function loadConfig(
   fs: FileSystem,
   filepath: FilePath,
   filenames: Array<FilePath>,
+  projectRoot: FilePath,
   opts: ?ConfigOptions,
 ): Promise<ConfigOutput | null> {
-  let configFile = await resolveConfig(fs, filepath, filenames, opts);
+  let parse = 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.extname(configFile).slice(1);
-      if (extname === 'js') {
-        return {
+      if (extname === 'js' || extname === 'cjs') {
+        let output = {
           // $FlowFixMe
-          config: clone(require(configFile)),
+          config: clone(module.require(configFile)),
           files: [{filePath: configFile}],
         };
-      }
-
-      let configContent = await fs.readFile(configFile, 'utf8');
-      if (!configContent) {
-        return null;
-      }
 
-      let config;
-      if (opts && opts.parse === false) {
-        config = configContent;
-      } else {
-        let parse = PARSERS[extname] || PARSERS.json;
-        config = parse(configContent);
+        configCache.set(configFile, output);
+        return output;
       }
 
-      return {
-        config: config,
-        files: [{filePath: configFile}],
-      };
+      return readConfig(fs, configFile, opts);
     } catch (err) {
       if (err.code === 'MODULE_NOT_FOUND' || err.code === 'ENOENT') {
-        existsCache.delete(configFile);
         return null;
       }
 
@@ -92,3 +94,88 @@ export async function loadConfig(
 
   return null;
 }
+
+loadConfig.clear = () => {
+  configCache.reset();
+  resolveCache.clear();
+};
+
+export async function readConfig(
+  fs: FileSystem,
+  configFile: FilePath,
+  opts: ?ConfigOptions,
+): Promise<ConfigOutput | null> {
+  let parse = opts?.parse ?? true;
+  let cachedOutput = configCache.get(String(parse) + configFile);
+  if (cachedOutput) {
+    return cachedOutput;
+  }
+
+  try {
+    let configContent = await fs.readFile(configFile, 'utf8');
+    let config;
+    if (parse === false) {
+      config = configContent;
+    } else {
+      let extname = path.extname(configFile).slice(1);
+      let parse = 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 ThrowableDiagnostic({
+          diagnostic: {
+            message: `Failed to parse ${path.basename(configFile)}`,
+            origin: '@parcel/utils',
+            codeFrames: [
+              {
+                language: 'json5',
+                filePath: configFile,
+                code: configContent,
+                codeHighlights: [
+                  {
+                    start: pos,
+                    end: pos,
+                    message: e.message,
+                  },
+                ],
+              },
+            ],
+          },
+        });
+      }
+    }
+
+    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') {
+      return null;
+    }
+
+    throw err;
+  }
+}
+
+function getParser(extname) {
+  switch (extname) {
+    case 'toml':
+      return toml;
+    case 'json':
+    default:
+      return json5.parse;
+  }
+}

package/src/countLines.js

@@ -1,8 +1,11 @@
 // @flow strict-local
 
-export default function countLines(string: string): number {
+export default function countLines(
+  string: string,
+  startIndex: number = 0,
+): number {
   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++;
     }

package/src/debounce.js

@@ -6,7 +6,7 @@ export default function debounce<TArgs: Array<mixed>>(
 ): (...args: TArgs) => void {
   let timeout;
 
-  return function(...args: TArgs) {
+  return function (...args: TArgs) {
     if (timeout) {
       clearTimeout(timeout);
     }