@atlaspack/graph 3.2.1-canary.3354

package/src/BitSet.js

@@ -0,0 +1,98 @@
+// @flow strict-local
+
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/clz32#implementing_count_leading_ones_and_beyond
+function ctz32(n: number): number {
+  if (n === 0) {
+    return 32;
+  }
+  let reversed = n & -n;
+  return 31 - Math.clz32(reversed);
+}
+
+export class BitSet {
+  bits: Uint32Array;
+
+  constructor(maxBits: number) {
+    this.bits = new Uint32Array(Math.ceil(maxBits / 32));
+  }
+
+  clone(): BitSet {
+    let res = new BitSet(this.capacity);
+    res.bits.set(this.bits);
+    return res;
+  }
+
+  static union(a: BitSet, b: BitSet): BitSet {
+    let res = a.clone();
+    res.union(b);
+    return res;
+  }
+
+  get capacity(): number {
+    return this.bits.length * 32;
+  }
+
+  add(bit: number) {
+    let i = bit >>> 5;
+    let b = bit & 31;
+    this.bits[i] |= 1 << b;
+  }
+
+  delete(bit: number) {
+    let i = bit >>> 5;
+    let b = bit & 31;
+    this.bits[i] &= ~(1 << b);
+  }
+
+  has(bit: number): boolean {
+    let i = bit >>> 5;
+    let b = bit & 31;
+    return Boolean(this.bits[i] & (1 << b));
+  }
+
+  empty(): boolean {
+    for (let k = 0; k < this.bits.length; k++) {
+      if (this.bits[k] !== 0) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  clear() {
+    this.bits.fill(0);
+  }
+
+  intersect(other: BitSet) {
+    for (let i = 0; i < this.bits.length; i++) {
+      this.bits[i] &= other.bits[i];
+    }
+  }
+
+  union(other: BitSet) {
+    for (let i = 0; i < this.bits.length; i++) {
+      this.bits[i] |= other.bits[i];
+    }
+  }
+
+  remove(other: BitSet) {
+    for (let i = 0; i < this.bits.length; i++) {
+      this.bits[i] &= ~other.bits[i];
+    }
+  }
+
+  forEach(fn: (bit: number) => void) {
+    // https://lemire.me/blog/2018/02/21/iterating-over-set-bits-quickly/
+    let bits = this.bits;
+    for (let k = 0; k < bits.length; k++) {
+      let v = bits[k];
+      while (v !== 0) {
+        let t = (v & -v) >>> 0;
+        // $FlowFixMe
+        fn((k << 5) + ctz32(v));
+        v ^= t;
+      }
+    }
+  }
+}

package/src/ContentGraph.js

@@ -0,0 +1,96 @@
+// @flow strict-local
+import type {ContentKey, NodeId} from './types';
+
+import Graph, {type SerializedGraph, type GraphOpts} from './Graph';
+import nullthrows from 'nullthrows';
+
+export type ContentGraphOpts<TNode, TEdgeType: number = 1> = {|
+  ...GraphOpts<TNode, TEdgeType>,
+  _contentKeyToNodeId: Map<ContentKey, NodeId>,
+  _nodeIdToContentKey: Map<NodeId, ContentKey>,
+|};
+export type SerializedContentGraph<TNode, TEdgeType: number = 1> = {|
+  ...SerializedGraph<TNode, TEdgeType>,
+  _contentKeyToNodeId: Map<ContentKey, NodeId>,
+|};
+
+export default class ContentGraph<TNode, TEdgeType: number = 1> extends Graph<
+  TNode,
+  TEdgeType,
+> {
+  _contentKeyToNodeId: Map<ContentKey, NodeId>;
+  _nodeIdToContentKey: Map<NodeId, ContentKey>;
+
+  constructor(opts: ?ContentGraphOpts<TNode, TEdgeType>) {
+    if (opts) {
+      let {_contentKeyToNodeId, _nodeIdToContentKey, ...rest} = opts;
+      super(rest);
+      this._contentKeyToNodeId = _contentKeyToNodeId;
+      this._nodeIdToContentKey = _nodeIdToContentKey;
+    } else {
+      super();
+      this._contentKeyToNodeId = new Map();
+      this._nodeIdToContentKey = new Map();
+    }
+  }
+
+  // $FlowFixMe[prop-missing]
+  static deserialize(
+    opts: ContentGraphOpts<TNode, TEdgeType>,
+  ): ContentGraph<TNode, TEdgeType> {
+    return new ContentGraph(opts);
+  }
+
+  // $FlowFixMe[prop-missing]
+  serialize(): SerializedContentGraph<TNode, TEdgeType> {
+    // $FlowFixMe[prop-missing]
+    return {
+      ...super.serialize(),
+      _contentKeyToNodeId: this._contentKeyToNodeId,
+      _nodeIdToContentKey: this._nodeIdToContentKey,
+    };
+  }
+
+  addNodeByContentKey(contentKey: ContentKey, node: TNode): NodeId {
+    if (this.hasContentKey(contentKey)) {
+      throw new Error('Graph already has content key ' + contentKey);
+    }
+
+    let nodeId = super.addNode(node);
+    this._contentKeyToNodeId.set(contentKey, nodeId);
+    this._nodeIdToContentKey.set(nodeId, contentKey);
+    return nodeId;
+  }
+
+  addNodeByContentKeyIfNeeded(contentKey: ContentKey, node: TNode): NodeId {
+    return this.hasContentKey(contentKey)
+      ? this.getNodeIdByContentKey(contentKey)
+      : this.addNodeByContentKey(contentKey, node);
+  }
+
+  getNodeByContentKey(contentKey: ContentKey): ?TNode {
+    let nodeId = this._contentKeyToNodeId.get(contentKey);
+    if (nodeId != null) {
+      return super.getNode(nodeId);
+    }
+  }
+
+  getNodeIdByContentKey(contentKey: ContentKey): NodeId {
+    return nullthrows(
+      this._contentKeyToNodeId.get(contentKey),
+      `Expected content key ${contentKey} to exist`,
+    );
+  }
+
+  hasContentKey(contentKey: ContentKey): boolean {
+    return this._contentKeyToNodeId.has(contentKey);
+  }
+
+  removeNode(nodeId: NodeId): void {
+    this._assertHasNodeId(nodeId);
+    let contentKey = nullthrows(this._nodeIdToContentKey.get(nodeId));
+    this._contentKeyToNodeId.delete(contentKey);
+    this._nodeIdToContentKey.delete(nodeId);
+    super.removeNode(nodeId);
+  }
+}