@parcel/utils 2.0.0-nightly.137 → 2.0.0-nightly.1370

package/package.json

@@ -1,11 +1,15 @@
 {
   "name": "@parcel/utils",
-  "version": "2.0.0-nightly.137+a07a8b84",
+  "version": "2.0.0-nightly.1370+5ac45672b",
   "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,53 @@
   "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.1370+5ac45672b",
+    "@parcel/diagnostic": "2.0.0-nightly.1370+5ac45672b",
+    "@parcel/logger": "2.0.0-nightly.1370+5ac45672b",
+    "@parcel/markdown-ansi": "2.0.0-nightly.1370+5ac45672b",
+    "@parcel/rust": "2.9.4-nightly.2993+5ac45672b",
+    "@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.137+a07a8b84",
-    "@parcel/diagnostic": "2.0.0-nightly.137+a07a8b84",
-    "@parcel/logger": "2.0.0-nightly.137+a07a8b84",
-    "@parcel/markdown-ansi": "2.0.0-nightly.137+a07a8b84",
-    "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",
+    "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
   },
-  "gitHead": "a07a8b84923a74077b70a4d2fcbc5a9f17736f3b"
+  "gitHead": "5ac45672bb603841bf294c66019930be4354625a"
 }

package/src/BitSet.js

@@ -0,0 +1,126 @@
+// @flow strict-local
+import nullthrows from 'nullthrows';
+
+// As our current version of flow doesn't support BigInt's, these values/types
+// have been hoisted to keep the flow errors to a minimum. This can be removed
+// if we upgrade to a flow version that supports BigInt's
+// $FlowFixMe
+type TmpBigInt = bigint;
+// $FlowFixMe
+const BIGINT_ZERO = 0n;
+// $FlowFixMe
+const BIGINT_ONE = 1n;
+// $FlowFixMe
+let numberToBigInt = (v: number): TmpBigInt => BigInt(v);
+
+let bitUnion = (a: TmpBigInt, b: TmpBigInt): TmpBigInt => a | b;
+
+export class BitSet<Item> {
+  _value: TmpBigInt;
+  _lookup: Map<Item, TmpBigInt>;
+  _items: Array<Item>;
+
+  constructor({
+    initial,
+    items,
+    lookup,
+  }: {|
+    items: Array<Item>,
+    lookup: Map<Item, number>,
+    initial?: BitSet<Item> | TmpBigInt,
+  |}) {
+    if (initial instanceof BitSet) {
+      this._value = initial?._value;
+    } else if (initial) {
+      this._value = initial;
+    } else {
+      this._value = BIGINT_ZERO;
+    }
+
+    this._items = items;
+    this._lookup = lookup;
+  }
+
+  static from(items: Array<Item>): BitSet<Item> {
+    let lookup: Map<Item, TmpBigInt> = new Map();
+    for (let i = 0; i < items.length; i++) {
+      lookup.set(items[i], numberToBigInt(i));
+    }
+
+    return new BitSet({items, lookup});
+  }
+
+  static union(a: BitSet<Item>, b: BitSet<Item>): BitSet<Item> {
+    return new BitSet({
+      initial: bitUnion(a._value, b._value),
+      lookup: a._lookup,
+      items: a._items,
+    });
+  }
+
+  #getIndex(item: Item) {
+    return nullthrows(this._lookup.get(item), 'Item is missing from BitSet');
+  }
+
+  add(item: Item) {
+    this._value |= BIGINT_ONE << this.#getIndex(item);
+  }
+
+  delete(item: Item) {
+    this._value &= ~(BIGINT_ONE << this.#getIndex(item));
+  }
+
+  has(item: Item): boolean {
+    return Boolean(this._value & (BIGINT_ONE << this.#getIndex(item)));
+  }
+
+  intersect(v: BitSet<Item>) {
+    this._value = this._value & v._value;
+  }
+
+  union(v: BitSet<Item>) {
+    this._value = bitUnion(this._value, v._value);
+  }
+
+  clear() {
+    this._value = BIGINT_ZERO;
+  }
+
+  cloneEmpty(): BitSet<Item> {
+    return new BitSet({
+      lookup: this._lookup,
+      items: this._items,
+    });
+  }
+
+  clone(): BitSet<Item> {
+    return new BitSet({
+      lookup: this._lookup,
+      items: this._items,
+      initial: this._value,
+    });
+  }
+
+  values(): Array<Item> {
+    let values = [];
+    let tmpValue = this._value;
+    let i;
+
+    // This implementation is optimized for BitSets that contain a very small percentage
+    // of items compared to the total number of potential items. This makes sense for
+    // our bundler use-cases where Sets often contain <1% coverage of the total item count.
+    // In cases where Sets contain a larger percentage of the total items, a regular looping
+    // strategy would be more performant.
+    while (tmpValue > BIGINT_ZERO) {
+      // Get last set bit
+      i = tmpValue.toString(2).length - 1;
+
+      values.push(this._items[i]);
+
+      // Unset last set bit
+      tmpValue &= ~(BIGINT_ONE << numberToBigInt(i));
+    }
+
+    return values;
+  }
+}

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,6 +10,7 @@ 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> = [];
 
@@ -74,7 +75,7 @@ export default class PromiseQueue<T> {
     if (this._queue.length) {
       this._next();
     } else if (this._numRunning === 0) {
-      this._resolve();
+      this._done();
     }
   }
 
@@ -82,10 +83,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 +104,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;
+}