@parcel/utils 2.9.2 → 2.10.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@parcel/utils",
-  "version": "2.9.2",
+  "version": "2.10.0",
   "description": "Blazing fast, zero configuration web application bundler",
   "license": "MIT",
   "publishConfig": {
@@ -24,7 +24,7 @@
       "includeNodeModules": {
         "@parcel/codeframe": false,
         "@parcel/diagnostic": false,
-        "@parcel/hash": false,
+        "@parcel/rust": false,
         "@parcel/logger": false,
         "@parcel/markdown-ansi": false,
         "@parcel/source-map": false,
@@ -33,11 +33,11 @@
     }
   },
   "dependencies": {
-    "@parcel/codeframe": "2.9.2",
-    "@parcel/diagnostic": "2.9.2",
-    "@parcel/hash": "2.9.2",
-    "@parcel/logger": "2.9.2",
-    "@parcel/markdown-ansi": "2.9.2",
+    "@parcel/codeframe": "2.10.0",
+    "@parcel/diagnostic": "2.10.0",
+    "@parcel/logger": "2.10.0",
+    "@parcel/markdown-ansi": "2.10.0",
+    "@parcel/rust": "2.10.0",
     "@parcel/source-map": "^2.1.1",
     "chalk": "^4.1.0",
     "nullthrows": "^1.1.1"
@@ -65,5 +65,5 @@
     "./src/http-server.js": false,
     "./src/openInBrowser.js": false
   },
-  "gitHead": "76aa20fc2f752fae9c7347f071ea457b112a5dad"
+  "gitHead": "0e235842b5b93301379bdfa626e7a4e2ee42ea98"
 }

package/src/hash.js

@@ -4,7 +4,7 @@ import type {Readable} from 'stream';
 import type {FileSystem} from '@parcel/fs';
 
 import {objectSortedEntriesDeep} from './collection';
-import {hashString, Hash} from '@parcel/hash';
+import {hashString, Hash} from '@parcel/rust';
 
 export function hashStream(stream: Readable): Promise<string> {
   let hash = new Hash();

package/src/index.js

@@ -85,5 +85,4 @@ export {
   loadSourceMap,
   remapSourceLocation,
 } from './sourcemap';
-export {BitSet} from './BitSet';
 export {default as stripAnsi} from 'strip-ansi';

package/src/BitSet.js

@@ -1,126 +0,0 @@
-// @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/test/BitSet.test.js

@@ -1,119 +0,0 @@
-// @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/);
-  });
-});