@atlaspack/graph 3.4.7 → 3.5.1

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # @atlaspack/graph
 
+## 3.5.1
+
+### Patch Changes
+
+- Updated dependencies [[`73ea3c4`](https://github.com/atlassian-labs/atlaspack/commit/73ea3c4d85d4401fdd15abcbf988237e890e7ad3), [`b1b3693`](https://github.com/atlassian-labs/atlaspack/commit/b1b369317c66f8a431c170df2ebba4fa5b2e38ef)]:
+  - @atlaspack/feature-flags@2.17.0
+
+## 3.5.0
+
+### Minor Changes
+
+- [#600](https://github.com/atlassian-labs/atlaspack/pull/600) [`1b52b99`](https://github.com/atlassian-labs/atlaspack/commit/1b52b99db4298b04c1a6eb0f97994d75a2d436f9) Thanks [@mattcompiles](https://github.com/mattcompiles)! - Add static intersect, size and equals methods to BitSet
+
 ## 3.4.7
 
 ### Patch Changes

package/benchmark/BitSet.js

@@ -0,0 +1,37 @@
+/*
+ * BitSets are primarily used for performance reasons, so we want to be able to
+ * validate that changes we make to it are performace improvements.
+ *
+ * This file exists as a ready-made playground for benchmarking changes you may
+ * want to make to the BitSet implementation.
+ *
+ * Run with `yarn workspace @atlaspack/graph benchmark` from the root
+ */
+
+// Needed to make Flow work in the benchmarks
+require('@atlaspack/babel-register');
+
+const {BitSet} = require('../src/BitSet.js');
+const b = require('benny');
+
+function createBitSetWithEntries(capacity, entries) {
+  let bitSet = new BitSet(capacity);
+  for (const index of entries) {
+    bitSet.add(index);
+  }
+  return bitSet;
+}
+
+let bundleIndices = [4334, 348, 2145, 480, 747, 1446, 326, 2791, 2658, 1334];
+
+let bundleBitSet = createBitSetWithEntries(5000, bundleIndices);
+
+b.suite(
+  'BitSet - size',
+  b.add('Control', () => {
+    bundleBitSet.size();
+  }),
+  b.configure({minSamples: 100}),
+  b.cycle(),
+  b.complete(),
+);

package/lib/BitSet.js

@@ -25,6 +25,11 @@ class BitSet {
     res.union(b);
     return res;
   }
+  static intersect(a, b) {
+    let res = a.clone();
+    res.intersect(b);
+    return res;
+  }
   get capacity() {
     return this.bits.length * 32;
   }
@@ -63,6 +68,26 @@ class BitSet {
       this.bits[i] &= ~other.bits[i];
     }
   }
+  size() {
+    let bits = this.bits;
+    let setBitsCount = 0;
+    for (let k = 0; k < bits.length; k++) {
+      let chunk = bits[k];
+      while (chunk !== 0) {
+        chunk &= chunk - 1; // Clear the least significant bit set
+        setBitsCount++;
+      }
+    }
+    return setBitsCount;
+  }
+  equals(other) {
+    for (let i = 0; i < this.bits.length; i++) {
+      if (this.bits[i] !== other.bits[i]) {
+        return false;
+      }
+    }
+    return true;
+  }
   forEach(fn) {
     // https://lemire.me/blog/2018/02/21/iterating-over-set-bits-quickly/
     let bits = this.bits;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/graph",
-  "version": "3.4.7",
+  "version": "3.5.1",
   "description": "Blazing fast, zero configuration web application bundler",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
@@ -15,9 +15,16 @@
   "engines": {
     "node": ">= 16.0.0"
   },
+  "scripts": {
+    "benchmark": "node ./benchmark/BitSet.js"
+  },
   "dependencies": {
-    "@atlaspack/feature-flags": "2.16.0",
+    "@atlaspack/feature-flags": "2.17.0",
     "nullthrows": "^1.1.1"
   },
+  "devDependencies": {
+    "@atlaspack/babel-register": "2.14.1",
+    "benny": "^3.7.1"
+  },
   "type": "commonjs"
 }

package/src/BitSet.js

@@ -28,6 +28,12 @@ export class BitSet {
     return res;
   }
 
+  static intersect(a: BitSet, b: BitSet): BitSet {
+    let res = a.clone();
+    res.intersect(b);
+    return res;
+  }
+
   get capacity(): number {
     return this.bits.length * 32;
   }
@@ -82,6 +88,31 @@ export class BitSet {
     }
   }
 
+  size(): number {
+    let bits = this.bits;
+    let setBitsCount = 0;
+
+    for (let k = 0; k < bits.length; k++) {
+      let chunk = bits[k];
+
+      while (chunk !== 0) {
+        chunk &= chunk - 1; // Clear the least significant bit set
+        setBitsCount++;
+      }
+    }
+
+    return setBitsCount;
+  }
+
+  equals(other: BitSet): boolean {
+    for (let i = 0; i < this.bits.length; i++) {
+      if (this.bits[i] !== other.bits[i]) {
+        return false;
+      }
+    }
+    return true;
+  }
+
   forEach(fn: (bit: number) => void) {
     // https://lemire.me/blog/2018/02/21/iterating-over-set-bits-quickly/
     let bits = this.bits;

package/test/BitSet.test.js

@@ -107,4 +107,46 @@ describe('BitSet', () => {
     assertValues(set2, [3, 5]);
     assertValues(set3, [1, 3, 5]);
   });
+
+  it('BitSet.intersect should create a new BitSet with the intersect', () => {
+    let set1 = new BitSet(5);
+    set1.add(1);
+    set1.add(3);
+
+    let set2 = new BitSet(5);
+    set2.add(3);
+    set2.add(5);
+
+    let set3 = BitSet.intersect(set1, set2);
+    assertValues(set1, [1, 3]);
+    assertValues(set2, [3, 5]);
+    assertValues(set3, [3]);
+  });
+
+  it('should identify equality with another BitSet', () => {
+    let set1 = new BitSet(5);
+    set1.add(1);
+    set1.add(3);
+
+    let set2 = new BitSet(5);
+    set2.add(3);
+    set2.add(5);
+
+    let set3 = set1.clone();
+
+    assert(set1.equals(set3));
+    assert(!set1.equals(set2));
+  });
+
+  it('should calculate size of BitSet', () => {
+    let set1 = new BitSet(5);
+    set1.add(1);
+    set1.add(3);
+
+    assert.equal(set1.size(), 2);
+
+    set1.add(3);
+    set1.add(4);
+    assert.equal(set1.size(), 3);
+  });
 });