@atlaspack/graph 3.5.10-typescript-5b4d3ad41.0 → 3.5.10

package/src/{AdjacencyList.ts → AdjacencyList.js}

@@ -1,3 +1,4 @@
+// @flow
 import assert from 'assert';
 import nullthrows from 'nullthrows';
 import {SharedBuffer} from './shared-buffer';
@@ -5,49 +6,49 @@ import {fromNodeId, toNodeId} from './types';
 import {
   ALL_EDGE_TYPES,
   NULL_EDGE_TYPE,
-  NullEdgeType,
-  AllEdgeTypes,
+  type NullEdgeType,
+  type AllEdgeTypes,
 } from './Graph';
 import type {NodeId} from './types';
 
 /** The address of the node in the nodes map. */
-type NodeAddress = number;
+opaque type NodeAddress = number;
 
-type EdgeHash = number;
+opaque type EdgeHash = number;
 
 /** The address of the edge in the edges map. */
-type EdgeAddress = number;
+opaque type EdgeAddress = number;
 
 // eslint-disable-next-line no-unused-vars
-export type SerializedAdjacencyList<TEdgeType> = {
-  nodes: Uint32Array;
-  edges: Uint32Array;
-};
+export type SerializedAdjacencyList<TEdgeType> = {|
+  nodes: Uint32Array,
+  edges: Uint32Array,
+|};
 
 // eslint-disable-next-line no-unused-vars
-export type AdjacencyListOptions<TEdgeType> = {
+export type AdjacencyListOptions<TEdgeType> = {|
   /** The initial number of edges to accommodate. */
-  initialCapacity?: number;
+  initialCapacity?: number,
   /** The max amount by which to grow the capacity. */
-  maxGrowFactor?: number;
+  maxGrowFactor?: number,
   /** The min amount by which to grow the capacity. */
-  minGrowFactor?: number;
+  minGrowFactor?: number,
   /** The size after which to grow the capacity by the minimum factor. */
-  peakCapacity?: number;
+  peakCapacity?: number,
   /** The percentage of deleted edges above which the capacity should shrink. */
-  unloadFactor?: number;
+  unloadFactor?: number,
   /** The amount by which to shrink the capacity. */
-  shrinkFactor?: number;
-};
-
-type AdjacencyListParams = {
-  initialCapacity: number;
-  unloadFactor: number;
-  maxGrowFactor: number;
-  minGrowFactor: number;
-  peakCapacity: number;
-  shrinkFactor: number;
-};
+  shrinkFactor?: number,
+|};
+
+type AdjacencyListParams = {|
+  initialCapacity: number,
+  unloadFactor: number,
+  maxGrowFactor: number,
+  minGrowFactor: number,
+  peakCapacity: number,
+  shrinkFactor: number,
+|};
 
 const DEFAULT_PARAMS: AdjacencyListParams = {
   initialCapacity: 2,
@@ -67,18 +68,18 @@ const DEFAULT_PARAMS: AdjacencyListParams = {
  * `TooManyDeletes`  = `3`: the edge map has too many deleted edges
  * `NodesOverloaded` = `4`: the node map is overloaded
  */
-const LinkResult: {
+const LinkResult: {|
   /** The edge was successfully linked */
-  EdgeAdded: 0;
+  EdgeAdded: 0,
   /** The edge already exists */
-  EdgeExists: 1;
+  EdgeExists: 1,
   /** The edge map is overloaded */
-  EdgesOverloaded: 2;
+  EdgesOverloaded: 2,
   /** The edge map has too many deleted edges */
-  TooManyDeletes: 3;
+  TooManyDeletes: 3,
   /** The node map is overloaded */
-  NodesOverloaded: 4;
-} = {
+  NodesOverloaded: 4,
+|} = {
   EdgeAdded: 0,
   EdgeExists: 1,
   EdgesOverloaded: 2,
@@ -120,7 +121,7 @@ const MAX_LINK_TRIES: 3 = 3;
  * `getInboundEdgesByType` methods.
  *
  */
-export default class AdjacencyList<TEdgeType extends number = NullEdgeType> {
+export default class AdjacencyList<TEdgeType: number = NullEdgeType> {
   #nodes: NodeTypeMap<TEdgeType | NullEdgeType>;
   #edges: EdgeTypeMap<TEdgeType | NullEdgeType>;
 
@@ -139,9 +140,7 @@ export default class AdjacencyList<TEdgeType extends number = NullEdgeType> {
     let nodes;
     let edges;
 
-    // @ts-expect-error TS2339
     if (opts?.nodes) {
-      // @ts-expect-error TS2339
       ({nodes, edges} = opts);
       this.#nodes = new NodeTypeMap(nodes);
       this.#edges = new EdgeTypeMap(edges);
@@ -168,7 +167,7 @@ export default class AdjacencyList<TEdgeType extends number = NullEdgeType> {
    * Create a new `AdjacencyList` with data serialized
    * from another `AdjacencyList`.
    */
-  static deserialize<TEdgeType extends number = NullEdgeType>(
+  static deserialize(
     opts: SerializedAdjacencyList<TEdgeType>,
   ): AdjacencyList<TEdgeType> {
     return new AdjacencyList(opts);
@@ -185,35 +184,35 @@ export default class AdjacencyList<TEdgeType extends number = NullEdgeType> {
   }
 
   /** Statistics about the current state of the `AdjacencyList`. */
-  get stats(): {
+  get stats(): {|
     /** The maximum number of edges the graph can contain. */
-    capacity: number;
+    capacity: number,
     /** The number of nodes in the graph. */
-    nodes: number;
+    nodes: number,
     /** The number of edge types associated with nodes in the graph. */
-    nodeEdgeTypes: number;
+    nodeEdgeTypes: number,
     /** The size of the raw nodes buffer, in mb. */
-    nodeBufferSize: string;
+    nodeBufferSize: string,
     /** The current load on the nodes array. */
-    nodeLoad: string;
+    nodeLoad: string,
     /** The number of edges in the graph. */
-    edges: number;
+    edges: number,
     /** The number of edges deleted from the graph. */
-    deleted: number;
+    deleted: number,
     /** The number of unique edge types in the graph. */
-    edgeTypes: number;
+    edgeTypes: number,
     /** The size of the raw edges buffer, in mb. */
-    edgeBufferSize: string;
+    edgeBufferSize: string,
     /** The current load on the edges array, including deletes. */
-    edgeLoadWithDeletes: string;
+    edgeLoadWithDeletes: string,
     /** The current load on the edges array. */
-    edgeLoad: string;
+    edgeLoad: string,
     /** The total number of edge hash collisions. */
-    collisions: number;
+    collisions: number,
     /** The number of collisions for the most common hash. */
-    maxCollisions: number;
+    maxCollisions: number,
     /** The average number of collisions per hash. */
-    avgCollisions: number;
+    avgCollisions: number,
     /**
      * The actual distribution of hashes vs. the expected (uniform) distribution.
      *
@@ -222,11 +221,10 @@ export default class AdjacencyList<TEdgeType extends number = NullEdgeType> {
      * > A ratio within one confidence interval (0.95 - 1.05) is indicative
      * > that the hash function...has an expected uniform distribution.
      */
-    uniformity: number;
-  } {
+    uniformity: number,
+  |} {
     let edgeTypes = new Set();
     let buckets = new Map();
-    // @ts-expect-error TS2488
     for (let {from, to, type} of this.getAllEdges()) {
       let hash = this.#edges.hash(from, to, type);
       let bucket = buckets.get(hash) || new Set();
@@ -313,7 +311,6 @@ export default class AdjacencyList<TEdgeType extends number = NullEdgeType> {
           this.#edges.from(edge),
           this.#edges.to(edge),
           this.#edges.typeOf(edge),
-          // @ts-expect-error TS2345
           edges,
           nodes,
           this.#params.unloadFactor,
@@ -327,9 +324,7 @@ export default class AdjacencyList<TEdgeType extends number = NullEdgeType> {
     );
 
     // Finally, copy the new data arrays over to this graph.
-    // @ts-expect-error TS2322
     this.#nodes = nodes;
-    // @ts-expect-error TS2322
     this.#edges = edges;
   }
 
@@ -423,11 +418,11 @@ export default class AdjacencyList<TEdgeType extends number = NullEdgeType> {
   /**
    * Iterate over all edges in insertion order.
    */
-  *getAllEdges(): Iterator<{
-    type: TEdgeType | NullEdgeType;
-    from: NodeId;
-    to: NodeId;
-  }> {
+  *getAllEdges(): Iterator<{|
+    type: TEdgeType | NullEdgeType,
+    from: NodeId,
+    to: NodeId,
+  |}> {
     for (let edge of this.#edges) {
       yield {
         from: this.#edges.from(edge),
@@ -528,14 +523,10 @@ export default class AdjacencyList<TEdgeType extends number = NullEdgeType> {
    * Get a list of every node (labeled `from`) connecting _to_
    * the given `to` node, along with the edge `type` connecting them.
    */
-  getInboundEdgesByType(to: NodeId): {
-    type: TEdgeType | NullEdgeType;
-    from: NodeId;
-  }[] {
-    let edges: Array<{
-      from: NodeId;
-      type: TEdgeType | NullEdgeType;
-    }> = [];
+  getInboundEdgesByType(
+    to: NodeId,
+  ): {|type: TEdgeType | NullEdgeType, from: NodeId|}[] {
+    let edges = [];
     let node = this.#nodes.head(to);
     while (node !== null) {
       let type = this.#nodes.typeOf(node);
@@ -554,14 +545,10 @@ export default class AdjacencyList<TEdgeType extends number = NullEdgeType> {
    * Get a list of every node (labeled `to`) connected _from_
    * the given `from` node, along with the edge `type` connecting them.
    */
-  getOutboundEdgesByType(from: NodeId): {
-    type: TEdgeType | NullEdgeType;
-    to: NodeId;
-  }[] {
-    let edges: Array<{
-      to: NodeId;
-      type: TEdgeType | NullEdgeType;
-    }> = [];
+  getOutboundEdgesByType(
+    from: NodeId,
+  ): {|type: TEdgeType | NullEdgeType, to: NodeId|}[] {
+    let edges = [];
     let node = this.#nodes.head(from);
     while (node !== null) {
       let type = this.#nodes.typeOf(node);
@@ -591,12 +578,12 @@ export default class AdjacencyList<TEdgeType extends number = NullEdgeType> {
       | NullEdgeType
       | Array<TEdgeType | NullEdgeType> = NULL_EDGE_TYPE,
   ): NodeId[] {
-    let matches = (node: number) =>
+    let matches = (node) =>
       type === ALL_EDGE_TYPES ||
       (Array.isArray(type)
         ? type.includes(this.#nodes.typeOf(node))
         : type === this.#nodes.typeOf(node));
-    let nodes: Array<NodeId> = [];
+    let nodes = [];
     let seen = new Set<NodeId>();
     let node = this.#nodes.head(from);
     while (node !== null) {
@@ -621,7 +608,7 @@ export default class AdjacencyList<TEdgeType extends number = NullEdgeType> {
     fn: (nodeId: NodeId) => boolean,
     type: AllEdgeTypes | TEdgeType | NullEdgeType = ALL_EDGE_TYPES,
   ) {
-    const matches = (node: number) =>
+    const matches = (node) =>
       type === ALL_EDGE_TYPES || type === this.#nodes.typeOf(node);
 
     let node = this.#nodes.head(from);
@@ -642,10 +629,10 @@ export default class AdjacencyList<TEdgeType extends number = NullEdgeType> {
 
   forEachNodeIdConnectedTo(
     to: NodeId,
-    fn: (nodeId: NodeId) => boolean | undefined,
+    fn: (nodeId: NodeId) => boolean | void,
     type: AllEdgeTypes | TEdgeType | NullEdgeType = NULL_EDGE_TYPE,
   ) {
-    const matches = (node: number) =>
+    const matches = (node) =>
       type === ALL_EDGE_TYPES || type === this.#nodes.typeOf(node);
 
     let node = this.#nodes.head(to);
@@ -679,13 +666,13 @@ export default class AdjacencyList<TEdgeType extends number = NullEdgeType> {
       | NullEdgeType
       | Array<TEdgeType | NullEdgeType> = NULL_EDGE_TYPE,
   ): NodeId[] {
-    let matches = (node: number) =>
+    let matches = (node) =>
       type === ALL_EDGE_TYPES ||
       (Array.isArray(type)
         ? type.includes(this.#nodes.typeOf(node))
         : type === this.#nodes.typeOf(node));
 
-    let nodes: Array<NodeId> = [];
+    let nodes = [];
     let seen = new Set<NodeId>();
     let node = this.#nodes.head(to);
     while (node !== null) {
@@ -752,7 +739,7 @@ export default class AdjacencyList<TEdgeType extends number = NullEdgeType> {
  *        └────┼─────────┴─────────────────┘                 │
  *             └─────────────────────────────────────────────┘
  */
-export class SharedTypeMap<TItemType, THash, TAddress extends number>
+export class SharedTypeMap<TItemType, THash, TAddress: number>
   implements Iterable<TAddress>
 {
   /**
@@ -792,8 +779,7 @@ export class SharedTypeMap<TItemType, THash, TAddress extends number>
   static #TYPE: 1 = 1;
 
   /** The largest possible capacity. */
-  // @ts-expect-error TS1094
-  static get MAX_CAPACITY<TItemType, THash, TAddress extends number>(): number {
+  static get MAX_CAPACITY(): number {
     return Math.floor(
       // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Invalid_array_length#what_went_wrong
       (2 ** 31 - 1 - this.HEADER_SIZE) / this.ITEM_SIZE,
@@ -801,9 +787,7 @@ export class SharedTypeMap<TItemType, THash, TAddress extends number>
   }
 
   /** Assert that the given `capacity` does not exceed `MAX_CAPACITY`. */
-  static assertMaxCapacity<TItemType, THash, TAddress extends number>(
-    capacity: number,
-  ): void {
+  static assertMaxCapacity(capacity: number): void {
     assert(capacity <= this.MAX_CAPACITY, `${this.name} capacity overflow!`);
   }
 
@@ -831,7 +815,6 @@ export class SharedTypeMap<TItemType, THash, TAddress extends number>
 
   /** The address of the first item in the map. */
   get addressableLimit(): number {
-    // @ts-expect-error TS2339
     return this.constructor.HEADER_SIZE + this.capacity;
   }
 
@@ -852,6 +835,7 @@ export class SharedTypeMap<TItemType, THash, TAddress extends number>
     if (typeof capacityOrData === 'number') {
       let {BYTES_PER_ELEMENT} = Uint32Array;
       let CAPACITY = SharedTypeMap.#CAPACITY;
+      // $FlowFixMe[incompatible-call]
       this.data = new Uint32Array(
         new SharedBuffer(this.getLength(capacityOrData) * BYTES_PER_ELEMENT),
       );
@@ -870,7 +854,6 @@ export class SharedTypeMap<TItemType, THash, TAddress extends number>
    * and is expected to be of equal or smaller capacity to this map.
    */
   set(data: Uint32Array): void {
-    // @ts-expect-error TS2339
     let {HEADER_SIZE, ITEM_SIZE} = this.constructor;
     let NEXT = SharedTypeMap.#NEXT;
     let COUNT = SharedTypeMap.#COUNT;
@@ -919,34 +902,31 @@ export class SharedTypeMap<TItemType, THash, TAddress extends number>
    * get the length of the map, in bytes.
    */
   getLength(capacity: number = this.capacity): number {
-    // @ts-expect-error TS2339
     let {HEADER_SIZE, ITEM_SIZE} = this.constructor;
     return capacity + HEADER_SIZE + ITEM_SIZE * capacity;
   }
 
   /** Get the next available address in the map. */
   getNextAddress(): TAddress {
-    // @ts-expect-error TS2339
     let {HEADER_SIZE, ITEM_SIZE} = this.constructor;
-    return (HEADER_SIZE + this.capacity + this.count * ITEM_SIZE) as any;
+    return (HEADER_SIZE + this.capacity + this.count * ITEM_SIZE: any);
   }
 
   /** Get the address of the first item with the given hash. */
   head(hash: THash): TAddress | null {
-    // @ts-expect-error TS2339
     let {HEADER_SIZE} = this.constructor;
-    return (this.data[HEADER_SIZE + (hash as any)] as any) || null;
+    return (this.data[HEADER_SIZE + (hash: any)]: any) || null;
   }
 
   /** Get the address of the next item with the same hash as the given item. */
   next(item: TAddress): TAddress | null {
     let NEXT = SharedTypeMap.#NEXT;
-    return (this.data[(item as any) + NEXT] as any) || null;
+    return (this.data[(item: any) + NEXT]: any) || null;
   }
 
   /** Get the type of the item at the given `item` address. */
   typeOf(item: TAddress): TItemType {
-    return this.data[item + SharedTypeMap.#TYPE] as any;
+    return (this.data[item + SharedTypeMap.#TYPE]: any);
   }
 
   /**
@@ -957,10 +937,9 @@ export class SharedTypeMap<TItemType, THash, TAddress extends number>
     let COUNT = SharedTypeMap.#COUNT;
     let NEXT = SharedTypeMap.#NEXT;
     let TYPE = SharedTypeMap.#TYPE;
-    // @ts-expect-error TS2339
     let {HEADER_SIZE} = this.constructor;
 
-    this.data[item + TYPE] = type as any;
+    this.data[item + TYPE] = (type: any);
 
     let prev = this.head(hash);
     if (prev !== null) {
@@ -972,7 +951,7 @@ export class SharedTypeMap<TItemType, THash, TAddress extends number>
       this.data[prev + NEXT] = item;
     } else {
       // This is the first item in the bucket!
-      this.data[HEADER_SIZE + (hash as any)] = item;
+      this.data[HEADER_SIZE + (hash: any)] = item;
     }
     this.data[COUNT]++;
   }
@@ -984,7 +963,6 @@ export class SharedTypeMap<TItemType, THash, TAddress extends number>
     let COUNT = SharedTypeMap.#COUNT;
     let NEXT = SharedTypeMap.#NEXT;
     let TYPE = SharedTypeMap.#TYPE;
-    // @ts-expect-error TS2339
     let {HEADER_SIZE} = this.constructor;
 
     this.data[item + TYPE] = 0;
@@ -998,7 +976,6 @@ export class SharedTypeMap<TItemType, THash, TAddress extends number>
     let candidate = head;
     while (candidate !== null && candidate !== item) {
       prev = candidate;
-      // @ts-expect-error TS2322
       candidate = this.next(candidate);
     }
     if (prev !== null && next !== null) {
@@ -1006,9 +983,9 @@ export class SharedTypeMap<TItemType, THash, TAddress extends number>
     } else if (prev !== null) {
       this.data[prev + NEXT] = 0;
     } else if (next !== null) {
-      this.data[HEADER_SIZE + (hash as any)] = next;
+      this.data[HEADER_SIZE + (hash: any)] = next;
     } else {
-      this.data[HEADER_SIZE + (hash as any)] = 0;
+      this.data[HEADER_SIZE + (hash: any)] = 0;
     }
     this.data[item + NEXT] = 0;
     this.data[COUNT]--;
@@ -1017,7 +994,6 @@ export class SharedTypeMap<TItemType, THash, TAddress extends number>
   forEach(cb: (item: TAddress) => void): void {
     let max = this.count;
     let len = this.length;
-    // @ts-expect-error TS2339
     let {ITEM_SIZE} = this.constructor;
     for (
       let i = this.addressableLimit, count = 0;
@@ -1025,8 +1001,8 @@ export class SharedTypeMap<TItemType, THash, TAddress extends number>
       i += ITEM_SIZE
     ) {
       // Skip items that don't have a type.
-      if (this.typeOf(i as any)) {
-        cb(i as any);
+      if (this.typeOf((i: any))) {
+        cb((i: any));
         count++;
       }
     }
@@ -1036,10 +1012,10 @@ export class SharedTypeMap<TItemType, THash, TAddress extends number>
   // See https://github.com/facebook/flow/issues/1163#issuecomment-353523840
   /*:: @@iterator(): Iterator<TAddress> { return ({}: any); } */
 
+  // $FlowFixMe[unsupported-syntax]
   *[Symbol.iterator](): Iterator<TAddress> {
     let max = this.count;
     let len = this.length;
-    // @ts-expect-error TS2339
     let {ITEM_SIZE} = this.constructor;
     for (
       let i = this.addressableLimit, count = 0;
@@ -1047,18 +1023,17 @@ export class SharedTypeMap<TItemType, THash, TAddress extends number>
       i += ITEM_SIZE
     ) {
       if (this.data.subarray(i, i + ITEM_SIZE).some(Boolean)) {
-        yield i as any;
+        yield (i: any);
         count++;
       }
     }
   }
 
-  inspect(): {
-    header: Uint32Array;
-    table: Uint32Array;
-    data: Uint32Array;
-  } {
-    // @ts-expect-error TS2339
+  inspect(): {|
+    header: Uint32Array,
+    table: Uint32Array,
+    data: Uint32Array,
+  |} {
     const {HEADER_SIZE} = this.constructor;
     let min = this.addressableLimit;
 
@@ -1088,7 +1063,7 @@ export class SharedTypeMap<TItemType, THash, TAddress extends number>
 export class NodeTypeMap<TEdgeType> extends SharedTypeMap<
   TEdgeType,
   NodeId,
-  NodeAddress
+  NodeAddress,
 > {
   /**
    * In addition to the header defined by `SharedTypeMap`, the header for
@@ -1330,7 +1305,7 @@ export class NodeTypeMap<TEdgeType> extends SharedTypeMap<
 export class EdgeTypeMap<TEdgeType> extends SharedTypeMap<
   TEdgeType,
   EdgeHash,
-  EdgeAddress
+  EdgeAddress,
 > {
   /**
    * In addition to the header defined by `SharedTypeMap`, the header for
@@ -1401,7 +1376,6 @@ export class EdgeTypeMap<TEdgeType> extends SharedTypeMap<
 
   /** Get the next available address in the map. */
   getNextAddress(): EdgeAddress {
-    // @ts-expect-error TS2339
     let {ITEM_SIZE} = this.constructor;
     return this.addressableLimit + (this.count + this.deletes) * ITEM_SIZE;
   }
@@ -1561,9 +1535,9 @@ export class EdgeTypeMap<TEdgeType> extends SharedTypeMap<
     // the output widely. Then we do a series of prime multiplications and
     // additions to combine the hashes into one value.
     let hash = 17;
-    hash = hash * 37 + hash32shift(from as any);
-    hash = hash * 37 + hash32shift(to as any);
-    hash = hash * 37 + hash32shift(type as any);
+    hash = hash * 37 + hash32shift((from: any));
+    hash = hash * 37 + hash32shift((to: any));
+    hash = hash * 37 + hash32shift((type: any));
     // Finally, we map the hash to a value modulo the edge capacity.
     hash %= this.capacity;
     return hash;
@@ -1580,14 +1554,14 @@ export class EdgeTypeMap<TEdgeType> extends SharedTypeMap<
  * - `3` TooManyDeletes: the edge map has too many deleted edges
  * - `4` NodesOverloaded: the node map is overloaded
  */
-function link<TEdgeType extends number>(
+function link<TEdgeType: number>(
   from: NodeId,
   to: NodeId,
   type: TEdgeType | NullEdgeType,
   edges: EdgeTypeMap<TEdgeType | NullEdgeType>,
   nodes: NodeTypeMap<TEdgeType | NullEdgeType>,
   unloadFactor: number = DEFAULT_PARAMS.unloadFactor,
-): (typeof LinkResult)[keyof typeof LinkResult] {
+): $Values<typeof LinkResult> {
   let hash = edges.hash(from, to, type);
   let edge = edges.addressOf(hash, from, to, type);
 

package/src/{BitSet.ts → BitSet.js}

@@ -1,3 +1,5 @@
+// @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) {
@@ -118,6 +120,7 @@ export class BitSet {
       let v = bits[k];
       while (v !== 0) {
         let t = (v & -v) >>> 0;
+        // $FlowFixMe
         fn((k << 5) + ctz32(v));
         v ^= t;
       }

package/src/{ContentGraph.ts → ContentGraph.js}

@@ -1,30 +1,27 @@
+// @flow strict-local
 import type {ContentKey, NodeId} from './types';
 
-import Graph, {SerializedGraph, GraphOpts} from './Graph';
+import Graph, {type SerializedGraph, type GraphOpts} from './Graph';
 import nullthrows from 'nullthrows';
 
-export type ContentGraphOpts<TNode, TEdgeType extends number = 1> = GraphOpts<
-  TNode,
-  TEdgeType
-> & {
-  _contentKeyToNodeId: Map<ContentKey, NodeId>;
-  _nodeIdToContentKey: Map<NodeId, ContentKey>;
-};
-export type SerializedContentGraph<
-  TNode,
-  TEdgeType extends number = 1,
-> = SerializedGraph<TNode, TEdgeType> & {
-  _contentKeyToNodeId: Map<ContentKey, NodeId>;
-};
+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<
+export default class ContentGraph<TNode, TEdgeType: number = 1> extends Graph<
   TNode,
-  TEdgeType extends number = 1,
-> extends Graph<TNode, TEdgeType> {
+  TEdgeType,
+> {
   _contentKeyToNodeId: Map<ContentKey, NodeId>;
   _nodeIdToContentKey: Map<NodeId, ContentKey>;
 
-  constructor(opts?: ContentGraphOpts<TNode, TEdgeType> | null) {
+  constructor(opts: ?ContentGraphOpts<TNode, TEdgeType>) {
     if (opts) {
       let {_contentKeyToNodeId, _nodeIdToContentKey, ...rest} = opts;
       super(rest);
@@ -37,17 +34,19 @@ export default class ContentGraph<
     }
   }
 
-  static deserialize<TNode, TEdgeType extends number = 1>(
+  // $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,
-      // @ts-expect-error TS2353
       _nodeIdToContentKey: this._nodeIdToContentKey,
     };
   }
@@ -69,7 +68,7 @@ export default class ContentGraph<
       : this.addNodeByContentKey(contentKey, node);
   }
 
-  getNodeByContentKey(contentKey: ContentKey): TNode | null | undefined {
+  getNodeByContentKey(contentKey: ContentKey): ?TNode {
     let nodeId = this._contentKeyToNodeId.get(contentKey);
     if (nodeId != null) {
       return super.getNode(nodeId);