@parcel/utils 2.8.2 → 2.8.4-nightly.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@parcel/utils",
-  "version": "2.8.2",
+  "version": "2.8.4-nightly.0+7b79c6d",
   "description": "Blazing fast, zero configuration web application bundler",
   "license": "MIT",
   "publishConfig": {
@@ -33,19 +33,20 @@
     }
   },
   "dependencies": {
-    "@parcel/codeframe": "2.8.2",
-    "@parcel/diagnostic": "2.8.2",
-    "@parcel/hash": "2.8.2",
-    "@parcel/logger": "2.8.2",
-    "@parcel/markdown-ansi": "2.8.2",
+    "@parcel/codeframe": "2.8.4-nightly.0+7b79c6d",
+    "@parcel/diagnostic": "2.8.4-nightly.0+7b79c6d",
+    "@parcel/hash": "2.8.4-nightly.0+7b79c6d",
+    "@parcel/logger": "2.8.4-nightly.0+7b79c6d",
+    "@parcel/markdown-ansi": "2.8.4-nightly.0+7b79c6d",
     "@parcel/source-map": "^2.1.1",
-    "chalk": "^4.1.0"
+    "chalk": "^4.1.0",
+    "nullthrows": "^1.1.1"
   },
   "devDependencies": {
     "@iarna/toml": "^2.2.0",
     "ansi-html-community": "0.0.8",
     "clone": "^2.1.1",
-    "fast-glob": "3.1.1",
+    "fast-glob": "^3.2.12",
     "fastest-levenshtein": "^1.0.8",
     "is-glob": "^4.0.0",
     "is-url": "^1.2.2",
@@ -56,6 +57,7 @@
     "nullthrows": "^1.1.1",
     "open": "^7.0.3",
     "random-int": "^1.0.0",
+    "strip-ansi": "^6.0.0",
     "terminal-link": "^2.1.1"
   },
   "browser": {
@@ -63,5 +65,5 @@
     "./src/http-server.js": false,
     "./src/openInBrowser.js": false
   },
-  "gitHead": "3437f64e4c6f57d911614c480b742e229149f200"
+  "gitHead": "7b79c6d69ffabef89810a8db61e9abdeb70d6990"
 }

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/alternatives.js

@@ -42,6 +42,8 @@ export async function findAlternativeNodeModules(
               potentialModules.push(...orgDirContent.map(i => `${item}/${i}`));
             }),
           );
+        } else {
+          potentialModules.push(...modules);
         }
       }
     } catch (err) {

package/src/collection.js

@@ -34,17 +34,25 @@ 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: Set<T>): void {
+export function setIntersect<T>(a: Set<T>, b: $ReadOnlySet<T>): void {
   for (let entry of a) {
     if (!b.has(entry)) {
       a.delete(entry);
@@ -56,7 +64,7 @@ export function setUnion<T>(a: Iterable<T>, b: Iterable<T>): Set<T> {
   return new Set([...a, ...b]);
 }
 
-export function setEqual<T>(a: Set<T>, b: Set<T>): boolean {
+export function setEqual<T>(a: $ReadOnlySet<T>, b: $ReadOnlySet<T>): boolean {
   if (a.size != b.size) {
     return false;
   }

package/src/config.js

@@ -74,7 +74,7 @@ export async function loadConfig(
       if (extname === 'js' || extname === 'cjs') {
         let output = {
           // $FlowFixMe
-          config: clone(require(configFile)),
+          config: clone(module.require(configFile)),
           files: [{filePath: configFile}],
         };
 
@@ -82,55 +82,7 @@ export async function loadConfig(
         return output;
       }
 
-      let configContent = await fs.readFile(configFile, 'utf8');
-
-      let config;
-      if (parse === false) {
-        config = configContent;
-      } else {
-        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;
+      return readConfig(fs, configFile, opts);
     } catch (err) {
       if (err.code === 'MODULE_NOT_FOUND' || err.code === 'ENOENT') {
         return null;
@@ -148,6 +100,76 @@ loadConfig.clear = () => {
   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':

package/src/hash.js

@@ -29,6 +29,21 @@ export function hashObject(obj: {+[string]: mixed, ...}): string {
   return hashString(JSON.stringify(objectSortedEntriesDeep(obj)));
 }
 
+let testCache: {|[string]: Promise<string>|} = {
+  /*:: ...null */
+};
 export function hashFile(fs: FileSystem, filePath: string): Promise<string> {
+  if (process.env.PARCEL_BUILD_ENV === 'test') {
+    // Development builds of these native modules are especially big and slow to hash.
+    if (
+      /parcel-swc\.[^\\/]+\.node$|lightningcss.[^\\/]+.node$/.test(filePath)
+    ) {
+      let cacheEntry = testCache[filePath];
+      if (cacheEntry) return cacheEntry;
+      let v = hashStream(fs.createReadStream(filePath));
+      testCache[filePath] = v;
+      return v;
+    }
+  }
   return hashStream(fs.createReadStream(filePath));
 }

package/src/index.js

@@ -40,7 +40,12 @@ export {
   setIntersect,
   setUnion,
 } from './collection';
-export {resolveConfig, resolveConfigSync, loadConfig} from './config';
+export {
+  resolveConfig,
+  resolveConfigSync,
+  loadConfig,
+  readConfig,
+} from './config';
 export {DefaultMap, DefaultWeakMap} from './DefaultMap';
 export {makeDeferredWithPromise} from './Deferred';
 export {getProgressMessage} from './progress-message.js';
@@ -73,3 +78,5 @@ export {
   loadSourceMap,
   remapSourceLocation,
 } from './sourcemap';
+export {BitSet} from './BitSet';
+export {default as stripAnsi} from 'strip-ansi';

package/src/prettyDiagnostic.js

@@ -77,10 +77,14 @@ export default async function prettyDiagnostic(
         });
       }
 
-      let location =
-        typeof filePath !== 'string'
-          ? ''
-          : `${filePath}:${highlights[0].start.line}:${highlights[0].start.column}`;
+      let location;
+      if (typeof filePath !== 'string') {
+        location = '';
+      } else if (highlights.length === 0) {
+        location = filePath;
+      } else {
+        location = `${filePath}:${highlights[0].start.line}:${highlights[0].start.column}`;
+      }
       result.codeframe += location ? chalk.gray.underline(location) + '\n' : '';
       result.codeframe += formattedCodeFrame;
       if (codeFrame !== codeFrames[codeFrames.length - 1]) {

package/src/shared-buffer.js

@@ -1,5 +1,4 @@
 // @flow
-/* global MessageChannel:readonly */
 
 export let SharedBuffer: Class<ArrayBuffer> | Class<SharedArrayBuffer>;
 

package/test/BitSet.test.js

@@ -0,0 +1,119 @@
+// @flow strict-local
+
+import assert from 'assert';
+import {BitSet} from '../src/BitSet';
+
+function assertValues<Item>(set: BitSet<Item>, values: Array<Item>) {
+  let setValues = set.values();
+
+  for (let value of values) {
+    assert(set.has(value), 'Set.has returned false');
+    assert(
+      setValues.some(v => v === value),
+      'Set values is missing value',
+    );
+  }
+
+  assert(
+    setValues.length === values.length,
+    `Expected ${values.length} values but got ${setValues.length}`,
+  );
+}
+
+describe('BitSet', () => {
+  it('cloneEmpty should return an empty set', () => {
+    let set1 = BitSet.from([1, 2, 3, 4, 5]);
+    set1.add(1);
+    set1.add(3);
+
+    let set2 = set1.cloneEmpty();
+
+    assertValues(set2, []);
+  });
+
+  it('clone should return a set with the same values', () => {
+    let set1 = BitSet.from([1, 2, 3, 4, 5]);
+    set1.add(1);
+    set1.add(3);
+
+    let set2 = set1.clone();
+
+    assertValues(set2, [1, 3]);
+  });
+
+  it('clear should remove all values from the set', () => {
+    let set1 = BitSet.from([1, 2, 3, 4, 5]);
+    set1.add(1);
+    set1.add(3);
+
+    set1.clear();
+
+    assertValues(set1, []);
+  });
+
+  it('delete should remove values from the set', () => {
+    let set1 = BitSet.from([1, 2, 3, 4, 5]);
+    set1.add(1);
+    set1.add(3);
+    set1.add(5);
+
+    set1.delete(3);
+
+    assertValues(set1, [1, 5]);
+  });
+
+  it('should intersect with another BitSet', () => {
+    let set1 = BitSet.from([1, 2, 3, 4, 5]);
+    set1.add(1);
+    set1.add(3);
+
+    let set2 = set1.cloneEmpty();
+    set2.add(3);
+    set2.add(5);
+
+    set1.intersect(set2);
+    assertValues(set1, [3]);
+  });
+
+  it('should union with another BitSet', () => {
+    let set1 = BitSet.from([1, 2, 3, 4, 5]);
+    set1.add(1);
+    set1.add(3);
+
+    let set2 = set1.cloneEmpty();
+    set2.add(3);
+    set2.add(5);
+
+    set1.union(set2);
+    assertValues(set1, [1, 3, 5]);
+  });
+
+  it('BitSet.union should create a new BitSet with the union', () => {
+    let set1 = BitSet.from([1, 2, 3, 4, 5]);
+    set1.add(1);
+    set1.add(3);
+
+    let set2 = set1.cloneEmpty();
+    set2.add(3);
+    set2.add(5);
+
+    let set3 = BitSet.union(set1, set2);
+    assertValues(set1, [1, 3]);
+    assertValues(set2, [3, 5]);
+    assertValues(set3, [1, 3, 5]);
+  });
+
+  it('returns an array of all values', () => {
+    let set = BitSet.from([1, 2, 3, 4]);
+    set.add(1);
+    set.add(3);
+
+    assertValues(set, [3, 1]);
+  });
+
+  it('should return an error if a new item is added', () => {
+    let set = BitSet.from([1, 2, 3, 4]);
+
+    assert.throws(() => set.add(5), /Item is missing from BitSet/);
+  });
+});

package/test/collection.test.js

@@ -1,7 +1,11 @@
 // @flow
 
 import assert from 'assert';
-import {objectSortedEntries, objectSortedEntriesDeep} from '../src/collection';
+import {
+  objectSortedEntries,
+  objectSortedEntriesDeep,
+  setDifference,
+} from '../src/collection';
 
 describe('objectSortedEntries', () => {
   it('returns a sorted list of key/value tuples', () => {
@@ -38,3 +42,11 @@ describe('objectSortedEntriesDeep', () => {
     );
   });
 });
+describe('setDifference', () => {
+  it('returns a setDifference of two sets of T type', () => {
+    assert.deepEqual(
+      setDifference(new Set([1, 2, 3]), new Set([3, 4, 5])),
+      new Set([1, 2, 4, 5]),
+    );
+  });
+});