@atlaspack/graph 3.5.10-typescript-1fd1095e8.0 → 3.5.10-typescript-e99c742e9.0

package/lib/AdjacencyList.d.ts

@@ -0,0 +1,607 @@
+import { NullEdgeType, AllEdgeTypes } from './Graph';
+import type { NodeId } from './types';
+/** The address of the node in the nodes map. */
+type NodeAddress = number;
+type EdgeHash = number;
+/** The address of the edge in the edges map. */
+type EdgeAddress = number;
+export type SerializedAdjacencyList<TEdgeType> = {
+    nodes: Uint32Array;
+    edges: Uint32Array;
+};
+export type AdjacencyListOptions<TEdgeType> = {
+    /** The initial number of edges to accommodate. */
+    initialCapacity?: number;
+    /** The max amount by which to grow the capacity. */
+    maxGrowFactor?: number;
+    /** The min amount by which to grow the capacity. */
+    minGrowFactor?: number;
+    /** The size after which to grow the capacity by the minimum factor. */
+    peakCapacity?: number;
+    /** The percentage of deleted edges above which the capacity should shrink. */
+    unloadFactor?: number;
+    /** The amount by which to shrink the capacity. */
+    shrinkFactor?: number;
+};
+/**
+ * `AdjacencyList` maps nodes to lists of their adjacent nodes.
+ *
+ * It is implemented as a hashmap of nodes, where each node has
+ * doubly linked lists of edges of each unique edge type.
+ * The edges are stored in a separate hashmap, where each edge has
+ * a pointer to the originating node, the terminating node, and
+ * the next and previous edges to and from adjacent nodes.
+ *
+ * The hash maps are each stored in a `Uint32Array` backed
+ * by a `SharedArrayBuffer`. See `SharedTypeMap` for more details.
+ *
+ * It's primary interface is through the `getNodeIdsConnectedFrom`
+ * and `getNodeIdsConnectedTo` methods, which return the list of
+ * nodes connected from or to a given node, respectively.
+ *
+ * It is also possible to get the lists of edges connected from or to
+ * a given node, using the `getOutboundEdgesByType` and
+ * `getInboundEdgesByType` methods.
+ *
+ */
+export default class AdjacencyList<TEdgeType extends number = NullEdgeType> {
+    #private;
+    /**
+     * Create a new `AdjacencyList` in one of two ways:
+     * - with specified options, or
+     * - with data serialized from a previous `AdjacencyList`.
+     */
+    constructor(opts?: SerializedAdjacencyList<TEdgeType | NullEdgeType> | AdjacencyListOptions<TEdgeType | NullEdgeType>);
+    /**
+     * Create a new `AdjacencyList` with data serialized
+     * from another `AdjacencyList`.
+     */
+    static deserialize<TEdgeType extends number = NullEdgeType>(opts: SerializedAdjacencyList<TEdgeType>): AdjacencyList<TEdgeType>;
+    /**
+     * Returns a serializable object of the nodes and edges in the AdjacencyList.
+     */
+    serialize(): SerializedAdjacencyList<TEdgeType>;
+    /** Statistics about the current state of the `AdjacencyList`. */
+    get stats(): {
+        /** The maximum number of edges the graph can contain. */
+        capacity: number;
+        /** The number of nodes in the graph. */
+        nodes: number;
+        /** The number of edge types associated with nodes in the graph. */
+        nodeEdgeTypes: number;
+        /** The size of the raw nodes buffer, in mb. */
+        nodeBufferSize: string;
+        /** The current load on the nodes array. */
+        nodeLoad: string;
+        /** The number of edges in the graph. */
+        edges: number;
+        /** The number of edges deleted from the graph. */
+        deleted: number;
+        /** The number of unique edge types in the graph. */
+        edgeTypes: number;
+        /** The size of the raw edges buffer, in mb. */
+        edgeBufferSize: string;
+        /** The current load on the edges array, including deletes. */
+        edgeLoadWithDeletes: string;
+        /** The current load on the edges array. */
+        edgeLoad: string;
+        /** The total number of edge hash collisions. */
+        collisions: number;
+        /** The number of collisions for the most common hash. */
+        maxCollisions: number;
+        /** The average number of collisions per hash. */
+        avgCollisions: number;
+        /**
+         * The actual distribution of hashes vs. the expected (uniform) distribution.
+         *
+         * From: https://en.wikipedia.org/wiki/Hash_function#Testing_and_measurement
+         *
+         * > A ratio within one confidence interval (0.95 - 1.05) is indicative
+         * > that the hash function...has an expected uniform distribution.
+         */
+        uniformity: number;
+    };
+    /**
+     * Resize the internal nodes array.
+     *
+     * This is used in `addNode` and in `addEdge` when
+     * the `nodes` array is at capacity,
+     */
+    resizeNodes(size: number): void;
+    /**
+     * Resize the internal edges array.
+     *
+     * This is used in `addEdge` when the `edges` array is at capacity.
+     */
+    resizeEdges(size: number): void;
+    /**
+     * Adds a node to the graph.
+     *
+     * Note that this method does not increment the node count
+     * (that only happens in `addEdge`), it _may_ preemptively resize
+     * the nodes array if it is at capacity, under the assumption that
+     * at least 1 edge to or from this new node will be added.
+     *
+     * Returns the id of the added node.
+     */
+    addNode(): NodeId;
+    /**
+     * Adds an edge to the graph.
+     *
+     * This method will increment the edge count, and it _may_
+     * also increment the node count, if the originating or
+     * terminating node does not yet have any edges of the given type.
+     *
+     * If either the `nodes` or `edges` arrays are at capacity,
+     * this method will resize them before adding.
+     *
+     * Furthermore, if the `edges` array has a high number of
+     * deleted edges, it may reclaim the space before adding.
+     *
+     * Returns `true` if the edge was added,
+     * or `false` if the edge already exists.
+     */
+    addEdge(from: NodeId, to: NodeId, type?: TEdgeType | NullEdgeType): boolean;
+    /**
+     * Iterate over all edges in insertion order.
+     */
+    getAllEdges(): Iterator<{
+        type: TEdgeType | NullEdgeType;
+        from: NodeId;
+        to: NodeId;
+    }>;
+    /**
+     * Check if the graph has an edge connecting the `from` and `to` nodes.
+     */
+    hasEdge(from: NodeId, to: NodeId, type?: TEdgeType | NullEdgeType | Array<TEdgeType | NullEdgeType>): boolean;
+    /**
+     * Remove an edge connecting the `from` and `to` nodes.
+     *
+     * Note that space for the deleted edge is not reclaimed
+     * until the `edges` array is resized.
+     *
+     * This method will increment the edge delete count.
+     */
+    removeEdge(from: NodeId, to: NodeId, type?: TEdgeType | NullEdgeType): void;
+    /**
+     * Check if the given node has any edges incoming from other nodes.
+     *
+     * Essentially, this is an orphan check. If a node has no incoming edges,
+     * it (and its entire subgraph) is completely disconnected from the
+     * rest of the graph.
+     */
+    hasInboundEdges(to: NodeId): boolean;
+    /**
+     * 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;
+    }[];
+    /**
+     * 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;
+    }[];
+    /**
+     * Get the list of node ids connected from this node.
+     *
+     * If `type` is specified, only return nodes connected by edges of that type.
+     * If `type` is an array, return nodes connected by edges of any of those types.
+     * If `type` is `AllEdgeTypes` (`-1`), return nodes connected by edges of any type.
+     */
+    getNodeIdsConnectedFrom(from: NodeId, type?: AllEdgeTypes | TEdgeType | NullEdgeType | Array<TEdgeType | NullEdgeType>): NodeId[];
+    forEachNodeIdConnectedFromReverse(from: NodeId, fn: (nodeId: NodeId) => boolean, type?: AllEdgeTypes | TEdgeType | NullEdgeType): void;
+    forEachNodeIdConnectedTo(to: NodeId, fn: (nodeId: NodeId) => boolean | undefined, type?: AllEdgeTypes | TEdgeType | NullEdgeType): void;
+    /**
+     * Get the list of node ids connected to this node.
+     *
+     * If `type` is specified, only return nodes connected by edges of that type.
+     * If `type` is an array, return nodes connected by edges of any of those types.
+     * If `type` is `AllEdgeTypes` (`-1`), return nodes connected by edges of any type.
+     */
+    getNodeIdsConnectedTo(to: NodeId, type?: AllEdgeTypes | TEdgeType | NullEdgeType | Array<TEdgeType | NullEdgeType>): NodeId[];
+    inspect(): any;
+}
+/**
+ * `SharedTypeMap` is a hashmap of items,
+ * where each item has its own 'type' field.
+ *
+ * The `SharedTypeMap` is backed by a shared array buffer of fixed length.
+ * The buffer is partitioned into:
+ * - a header, which stores the capacity and number of items in the map,
+ * - a hash table, which is an array of pointers to linked lists of items
+ *   with the same hash,
+ * - an items array, which is where the linked items are stored.
+ *
+ *            hash table                 item
+ *            (capacity)             (ITEM_SIZE)
+ *         ┌──────┴──────┐             ┌──┴──┐
+ *   ┌──┬──┬──┬───────┬──┬──┬──┬───────┬──┬──┐
+ *   │  │  │  │  ...  │  │  │  │  ...  │  │  │
+ *   └──┴──┴──┴───────┴──┴──┴──┴───────┴──┴──┘
+ *   └──┬──┘             └─────────┬─────────┘
+ *    header                     items
+ * (HEADER_SIZE)         (capacity * ITEM_SIZE)
+ *
+ *
+ * An item is added with a hash key that fits within the range of the hash
+ * table capacity. The item is stored at the next available address after the
+ * hash table, and a pointer to the address is stored in the hash table at
+ * the index matching the hash. If the hash is already pointing at an item,
+ * the pointer is stored in the `next` field of the existing item instead.
+ *
+ *       hash table                          items
+ * ┌─────────┴────────┐┌───────────────────────┴────────────────────────┐
+ *    0    1    2        11       17        23       29      35
+ * ┌───┐┌───┐┌───┐┌───┐┌───┬───┐┌───┬───┐┌───┬───┐┌───┬───┐┌───┬───┐┌───┐
+ * │17 ││11 ││35 ││...││23 │ 1 ││29 │ 1 ││ 0 │ 2 ││ 0 │ 2 ││ 0 │ 1 ││...│
+ * └───┘└───┘└───┘└───┘└───┴───┘└───┴───┘└───┴───┘└───┴───┘└───┴───┘└───┘
+ *   │    │    │         ▲        ▲        ▲        ▲        ▲
+ *   └────┼────┼─────────┼────────┴────────┼────────┘        │
+ *        └────┼─────────┴─────────────────┘                 │
+ *             └─────────────────────────────────────────────┘
+ */
+export declare class SharedTypeMap<TItemType, THash, TAddress extends number> implements Iterable<TAddress> {
+    #private;
+    /**
+     * The header for the `SharedTypeMap` comprises 2 4-byte chunks:
+     *
+     * struct SharedTypeMapHeader {
+     *   int capacity;
+     *   int count;
+     * }
+     *
+     * ┌──────────┬───────┐
+     * │ CAPACITY │ COUNT │
+     * └──────────┴───────┘
+     */
+    static HEADER_SIZE: number;
+    /**
+     * Each item in `SharedTypeMap` comprises 2 4-byte chunks:
+     *
+     * struct Node {
+     *   int next;
+     *   int type;
+     * }
+     *
+     * ┌──────┬──────┐
+     * │ NEXT │ TYPE │
+     * └──────┴──────┘
+     */
+    static ITEM_SIZE: number;
+    /** The largest possible capacity. */
+    static get MAX_CAPACITY<TItemType, THash, TAddress extends number>(): number;
+    /** Assert that the given `capacity` does not exceed `MAX_CAPACITY`. */
+    static assertMaxCapacity<TItemType, THash, TAddress extends number>(capacity: number): void;
+    data: Uint32Array;
+    /** The total number of items that can fit in the map. */
+    get capacity(): number;
+    /** The number of items in the map. */
+    get count(): number;
+    /** The ratio of the count to the capacity. */
+    get load(): number;
+    /** The total length of the map, in bytes. */
+    get length(): number;
+    /** The address of the first item in the map. */
+    get addressableLimit(): number;
+    /** The size of the map in mb, as a localized string. */
+    get bufferSize(): string;
+    /**
+     * Create a new `SharedTypeMap` in one of two ways:
+     * - with a capacity of `capacityOrData` if it is a number,
+     * - or with `capacityOrData` as its data, if it is a `Uint32Array`.
+     */
+    constructor(capacityOrData: number | Uint32Array);
+    /**
+     * Overwrite the data in this map with the given `data`.
+     *
+     * The `data` is expected to conform to the same
+     * partitioning and schema as the data in this map,
+     * and is expected to be of equal or smaller capacity to this map.
+     */
+    set(data: Uint32Array): void;
+    /**
+     * Given a `count` (defaulting to `this.count`),
+     * get the load on the map.
+     *
+     * The load is the ratio of the `count` the capacity of the map.
+     *
+     * If the load is `1`, it means the map is at capacity, and needs
+     * to be resized before adding more items.
+     */
+    getLoad(count?: number): number;
+    /**
+     * Given a `capacity` (defaulting to `this.capacity`),
+     * get the length of the map, in bytes.
+     */
+    getLength(capacity?: number): number;
+    /** Get the next available address in the map. */
+    getNextAddress(): TAddress;
+    /** Get the address of the first item with the given hash. */
+    head(hash: THash): TAddress | null;
+    /** Get the address of the next item with the same hash as the given item. */
+    next(item: TAddress): TAddress | null;
+    /** Get the type of the item at the given `item` address. */
+    typeOf(item: TAddress): TItemType;
+    /**
+     * Store an item of `type` at the `item` address and
+     * link the address to the `hash` bucket.
+     */
+    link(hash: THash, item: TAddress, type: TItemType): void;
+    /**
+     * Remove the link to the `item` address from the `hash` bucket.
+     */
+    unlink(hash: THash, item: TAddress): void;
+    forEach(cb: (item: TAddress) => void): void;
+    [Symbol.iterator](): Iterator<TAddress>;
+    inspect(): {
+        header: Uint32Array;
+        table: Uint32Array;
+        data: Uint32Array;
+    };
+}
+/**
+ * Nodes are stored in a `SharedTypeMap`, keyed on node id plus an edge type.
+ * This means that for any given unique node id, there may be `e` nodes in the
+ * map, where `e` is the number of unique edge types in the graph.
+ *
+ * The _hash_ for a node is simply the node id (as issued by `getId`),
+ * and forms the head of linked list of unique _edge types_ connected
+ * to or from the same node id.
+ *
+ * In addition to a unique edge type, each Node contains the heads and tails
+ * of doubly linked lists of incoming and outgoing edges of the same type.
+ *
+ * Note that the links in the doubly linked lists are Edges (not Nodes),
+ * which are stored in a corresponding `EdgeTypeMap`.
+ */
+export declare class NodeTypeMap<TEdgeType> extends SharedTypeMap<TEdgeType, NodeId, NodeAddress> {
+    #private;
+    /**
+     * In addition to the header defined by `SharedTypeMap`, the header for
+     * the node map includes a 4-byte `nextId` chunk:
+     *
+     * struct NodeTypeMapHeader {
+     *   int capacity; // from `SharedTypeMap`
+     *   int count; // from `SharedTypeMap`
+     *   int nextId;
+     * }
+     *
+     * ┌──────────┬───────┬─────────┐
+     * │ CAPACITY │ COUNT │ NEXT_ID │
+     * └──────────┴───────┴─────────┘
+     *
+     * The `nextId` is a count of the number of times `getId` has been called.
+     * This is distinct concept from the `count`, which tracks the number of times
+     * `add` has been called.
+     *
+     * The reason for this distinction is that `getId` is called once per node
+     * (to issue a _unique_ id) and will _always increment_ the `nextId` counter,
+     * whereas `add` is called once per edge, and will only increment the `count`
+     * if the _type_ of edge is new for the given node.
+     */
+    static HEADER_SIZE: number;
+    /**
+     * In addition to the item fields defined by `SharedTypeMap`,
+     * each node includes another 4 4-byte chunks:
+     *
+     * struct Node {
+     *   int next; // from `SharedTypeMap`
+     *   int type; // from `SharedTypeMap`
+     *   int firstIn;
+     *   int firstOut;
+     *   int lastIn;
+     *   int lastOut;
+     * }
+     *
+     * ┌──────┬──────┬──────────┬───────────┬─────────┬──────────┐
+     * │ NEXT │ TYPE │ FIRST_IN │ FIRST_OUT │ LAST_IN │ LAST_OUT │
+     * └──────┴──────┴──────────┴───────────┴─────────┴──────────┘
+     *
+     * The `Node` implicitly maps a node id (the hash the node was added with)
+     * to the first and last incoming and outgoing edges of the same _edge type_.
+     */
+    static ITEM_SIZE: number;
+    get nextId(): NodeId;
+    set nextId(nextId: NodeId);
+    /**
+     * Get the load on the node map.
+     *
+     * The load is the greater of either:
+     * - the ratio of the number of node ids to the capacity of the map,
+     * - or the ratio of the `count` to the capacity of the map.
+     *
+     * if `count` is not provided, the default is the number of items
+     * currently added to the map.
+     */
+    getLoad(count?: number): number;
+    /** Increment the node counter to get a unique node id. */
+    getId(): NodeId;
+    /**
+     * Add new lists of edges of the given `type` to and from the given `node`.
+     */
+    add(node: NodeId, type: TEdgeType): NodeAddress;
+    /**
+     * Get the address of the lists edges of the given `type`
+     * to and from the given `node`.
+     */
+    addressOf(node: NodeId, type: TEdgeType): NodeAddress | null;
+    /**
+     * Given a `node` address, get the _head_ of the linked list
+     * of incoming edges of the same type to the same node.
+     */
+    firstIn(node: NodeAddress): EdgeAddress | null;
+    /**
+     * Given a `node` address, get the _head_ of the linked list
+     * of outgoing edges of the same type from the same node.
+     */
+    firstOut(node: NodeAddress): EdgeAddress | null;
+    /**
+     * Given a `node` address, get the _tail_ of the linked list
+     * of incoming edges of the same type to the same node.
+     */
+    lastIn(node: NodeAddress): EdgeAddress | null;
+    /**
+     * Given a `node` address, get the _tail_ of the linked list
+     * of outgoing edges of the same type from the same node.
+     */
+    lastOut(node: NodeAddress): EdgeAddress | null;
+    /**
+     * Set `edge` as the last incoming edge to `node`.
+     * If `node` has no incoming edges, set `edge`
+     * as the first incoming edge, as well.
+     *
+     * Returns the address of the old last incoming edge, if any.
+     */
+    linkIn(node: NodeAddress, edge: EdgeAddress): EdgeAddress | null;
+    /**
+     * If `edge` is the last incoming edge to `node`,
+     * update the node's last incoming edge to `prev`.
+     *
+     * If `edge` is the first incoming edge to `node`,
+     * update the node's first incoming edge to `next`.
+     */
+    unlinkIn(node: NodeAddress, edge: EdgeAddress, prev: EdgeAddress | null, next: EdgeAddress | null): void;
+    /**
+     * Set `edge` as the last outgoing edge from `node`.
+     * If `node` has no outgoing edges, set `edge`
+     * as the first outgoing edge, as well.
+     *
+     * Returns the address of the old last outgoing edge, if any.
+     */
+    linkOut(node: NodeAddress, edge: EdgeAddress): EdgeAddress | null;
+    /**
+     * If `edge` is the last outgoing edge from `node`,
+     * update the node's last outgoing edge to `prev`.
+     *
+     * If `edge` is the first outgoing edge from `node`,
+     * update the node's first outgoing edge to `next`.
+     */
+    unlinkOut(node: NodeAddress, edge: EdgeAddress, prev: EdgeAddress | null, next: EdgeAddress | null): void;
+}
+/**
+ * Edges are stored in a `SharedTypeMap`,
+ * keyed on the 'from' and 'to' node ids, and the edge type.
+ *
+ * The _hash_ for an edge is a hash of the edge's `from`, `to`, and `type` values,
+ * and forms the head of linked list of edges with the same hash.
+ *
+ * In addition to the `from`, `to` and `type` values, each Edge contains
+ * the next and previous links of doubly linked lists of the _adjacent_ edges
+ * of the same type, both incoming to the `to` node, and outgoing from
+ * the `from` node.
+ */
+export declare class EdgeTypeMap<TEdgeType> extends SharedTypeMap<TEdgeType, EdgeHash, EdgeAddress> {
+    #private;
+    /**
+     * In addition to the header defined by `SharedTypeMap`, the header for
+     * the edge map includes a 4-byte `deletes` chunk:
+     *
+     * struct EdgeTypeMapHeader {
+     *   int capacity; // from `SharedTypeMap`
+     *   int count; // from `SharedTypeMap`
+     *   int deletes;
+     * }
+     *
+     * ┌──────────┬───────┬─────────┐
+     * │ CAPACITY │ COUNT │ DELETES │
+     * └──────────┴───────┴─────────┘
+     *
+     * Since new edges are always appended, the space for deleted edges
+     * is not reused. Instead, the `deletes` count is incremented when an
+     * edge is deleted. The next available address is calculated by
+     * adding the `count` and `deletes` values to the header size.
+     *
+     * The only way to reclaim the space used by deleted edges is to resize the map.
+     */
+    static HEADER_SIZE: number;
+    /**
+     * In addition to the item fields defined by `SharedTypeMap`,
+     * each edge includes another 6 4-byte chunks:
+     *
+     * struct Edge {
+     *   int next; // from `SharedTypeMap`
+     *   int type; // from `SharedTypeMap`
+     *   int from;
+     *   int to;
+     *   int nextIn;
+     *   int prevIn;
+     *   int nextOut;
+     *   int prevOut;
+     * }
+     *
+     * ┌──────┬──────┬──────┬────┬─────────┬─────────┬──────────┬──────────┐
+     * │ NEXT │ TYPE │ FROM │ TO │ NEXT_IN │ PREV_IN │ NEXT_OUT │ PREV_OUT │
+     * └──────┴──────┴──────┴────┴─────────┴─────────┴──────────┴──────────┘
+     *
+     * The `Edge` implicitly maps an edge hash (the hash of the edge's `FROM`,
+     * `TO`, and `TYPE` values) to the next and previous adjacent edges of the
+     * same _edge type_.
+     */
+    static ITEM_SIZE: number;
+    /** The number of deleted edges currently occupying space in the map. */
+    get deletes(): number;
+    /** Get the next available address in the map. */
+    getNextAddress(): EdgeAddress;
+    /**
+     * Add an edge of the given `type` between the `to` and `from` nodes
+     * and link the address to the `hash` bucket.
+     */
+    add(hash: EdgeHash, from: NodeId, to: NodeId, type: TEdgeType): EdgeAddress;
+    /**
+     * Remove the `to` and `from` nodes for the given `edge` address
+     * and increment the `deletes` counter.
+     */
+    delete(edge: EdgeAddress): void;
+    /**
+     * Get the address of the edge with the given `hash`, `from` and `to` nodes,
+     * and edge `type`.
+     */
+    addressOf(hash: EdgeHash, from: NodeId, to: NodeId, type: TEdgeType): EdgeAddress | null;
+    /** Get the id of the 'from' node for the given `edge` address. */
+    from(edge: EdgeAddress): NodeId;
+    /** Get the id of the 'to' node for the given `edge` address. */
+    to(edge: EdgeAddress): NodeId;
+    /**
+     * Get the address of the next edge _of the same type_
+     * incoming _to the same node_ as the edge at the given address.
+     */
+    nextIn(edge: EdgeAddress): EdgeAddress | null;
+    /**
+     * Get the address of the previous edge _of the same type_
+     * incoming _to the same node_ as the edge at the given address.
+     */
+    prevIn(edge: EdgeAddress): EdgeAddress | null;
+    /** Link two adjacent edges of the same type incoming to the same node. */
+    linkIn(edge: EdgeAddress, next: EdgeAddress): void;
+    /**
+     * Unlink an edge from the doubly linked list of incoming edges
+     * to the same node.
+     */
+    unlinkIn(edge: EdgeAddress): void;
+    /**
+     * Get the address of the next edge _of the same type_
+     * outgoing _from the same node_ as the edge at the given address.
+     */
+    nextOut(edge: EdgeAddress): EdgeAddress | null;
+    /**
+     * Get the address of the previous edge _of the same type_
+     * outgoing _from the same node_ as the edge at the given address.
+     */
+    prevOut(edge: EdgeAddress): EdgeAddress | null;
+    /** Link two adjacent edges of the same type outgoing from the same node. */
+    linkOut(edge: EdgeAddress, next: EdgeAddress): void;
+    /**
+     * Unlink an edge from the doubly linked list of outgoing edges
+     * of the same type from the same node.
+     */
+    unlinkOut(edge: EdgeAddress): void;
+    /** Create a hash of the edge connecting the `from` and `to` nodes.  */
+    hash(from: NodeId, to: NodeId, type: TEdgeType): EdgeHash;
+}
+export {};

package/lib/BitSet.d.ts

@@ -0,0 +1,19 @@
+export declare class BitSet {
+    bits: Uint32Array;
+    constructor(maxBits: number);
+    clone(): BitSet;
+    static union(a: BitSet, b: BitSet): BitSet;
+    static intersect(a: BitSet, b: BitSet): BitSet;
+    get capacity(): number;
+    add(bit: number): void;
+    delete(bit: number): void;
+    has(bit: number): boolean;
+    empty(): boolean;
+    clear(): void;
+    intersect(other: BitSet): void;
+    union(other: BitSet): void;
+    remove(other: BitSet): void;
+    size(): number;
+    equals(other: BitSet): boolean;
+    forEach(fn: (bit: number) => void): void;
+}

package/lib/ContentGraph.d.ts

@@ -0,0 +1,23 @@
+import type { ContentKey, NodeId } from './types';
+import Graph, { SerializedGraph, GraphOpts } from './Graph';
+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 default class ContentGraph<TNode, TEdgeType extends number = 1> extends Graph<TNode, TEdgeType> {
+    _contentKeyToNodeId: Map<ContentKey, NodeId>;
+    _nodeIdToContentKey: Map<NodeId, ContentKey>;
+    constructor(opts?: ContentGraphOpts<TNode, TEdgeType> | null);
+    static deserialize<TNode, TEdgeType extends number = 1>(opts: ContentGraphOpts<TNode, TEdgeType>): ContentGraph<TNode, TEdgeType>;
+    serialize(): SerializedContentGraph<TNode, TEdgeType>;
+    addNodeByContentKey(contentKey: ContentKey, node: TNode): NodeId;
+    addNodeByContentKeyIfNeeded(contentKey: ContentKey, node: TNode): NodeId;
+    getNodeByContentKey(contentKey: ContentKey): TNode | null | undefined;
+    getContentKeyByNodeId(nodeId: NodeId): ContentKey;
+    getNodeIdByContentKey(contentKey: ContentKey): NodeId;
+    hasContentKey(contentKey: ContentKey): boolean;
+    removeNode(nodeId: NodeId, removeOrphans?: boolean): void;
+}

package/lib/Graph.d.ts

@@ -0,0 +1,91 @@
+import AdjacencyList, { SerializedAdjacencyList } from './AdjacencyList';
+import type { Edge, NodeId } from './types';
+import type { TraversalActions, GraphVisitor, GraphTraversalCallback } from '@atlaspack/types';
+import { BitSet } from './BitSet';
+export type NullEdgeType = 1;
+export declare const NULL_EDGE_TYPE: NullEdgeType;
+export type GraphOpts<TNode, TEdgeType extends number = NullEdgeType> = {
+    nodes?: Array<TNode | null>;
+    adjacencyList?: SerializedAdjacencyList<TEdgeType>;
+    rootNodeId?: NodeId | null | undefined;
+    initialCapacity?: number;
+};
+export type SerializedGraph<TNode, TEdgeType extends number = NullEdgeType> = {
+    nodes: Array<TNode | null>;
+    adjacencyList: SerializedAdjacencyList<TEdgeType>;
+    rootNodeId: NodeId | null | undefined;
+};
+export type AllEdgeTypes = -1;
+export declare const ALL_EDGE_TYPES: AllEdgeTypes;
+/**
+ * Options for DFS traversal.
+ */
+export type DFSParams<TContext> = {
+    visit: GraphVisitor<NodeId, TContext>;
+    /**
+     * Custom function to get next entries to visit.
+     *
+     * This can be a performance bottleneck as arrays are created on every node visit.
+     *
+     * @deprecated This will be replaced by a static `traversalType` set of orders in the future
+     *
+     * Currently, this is only used in 3 ways:
+     *
+     * - Traversing down the tree (normal DFS)
+     * - Traversing up the tree (ancestors)
+     * - Filtered version of traversal; which does not need to exist at the DFS level as the visitor
+     *   can handle filtering
+     * - Sorted traversal of BundleGraph entries, which does not have a clear use-case, but may
+     *   not be safe to remove
+     *
+     * Only due to the latter we aren't replacing this.
+     */
+    getChildren: (nodeId: NodeId) => Array<NodeId>;
+    startNodeId?: NodeId | null | undefined;
+};
+export default class Graph<TNode, TEdgeType extends number = NullEdgeType> {
+    nodes: Array<TNode | null>;
+    adjacencyList: AdjacencyList<TEdgeType>;
+    rootNodeId: NodeId | null | undefined;
+    _visited: BitSet | null | undefined;
+    constructor(opts?: GraphOpts<TNode, TEdgeType> | null);
+    setRootNodeId(id?: NodeId | null): void;
+    static deserialize<TNode, TEdgeType extends number = NullEdgeType>(opts: GraphOpts<TNode, TEdgeType>): Graph<TNode, TEdgeType>;
+    serialize(): SerializedGraph<TNode, TEdgeType>;
+    getAllEdges(): Iterator<Edge<TEdgeType | NullEdgeType>>;
+    addNode(node: TNode): NodeId;
+    hasNode(id: NodeId): boolean;
+    getNode(id: NodeId): TNode | null | undefined;
+    addEdge(from: NodeId, to: NodeId, type?: TEdgeType | NullEdgeType): boolean;
+    hasEdge(from: NodeId, to: NodeId, type?: TEdgeType | NullEdgeType | Array<TEdgeType | NullEdgeType>): boolean;
+    forEachNodeIdConnectedTo(to: NodeId, fn: (nodeId: NodeId) => boolean | undefined, type?: AllEdgeTypes | TEdgeType | NullEdgeType): void;
+    forEachNodeIdConnectedFrom(from: NodeId, fn: (nodeId: NodeId) => void, type?: AllEdgeTypes | TEdgeType | NullEdgeType): void;
+    getNodeIdsConnectedTo(nodeId: NodeId, type?: TEdgeType | NullEdgeType | Array<TEdgeType | NullEdgeType> | AllEdgeTypes): Array<NodeId>;
+    getNodeIdsConnectedFrom(nodeId: NodeId, type?: TEdgeType | NullEdgeType | Array<TEdgeType | NullEdgeType> | AllEdgeTypes): Array<NodeId>;
+    removeNode(nodeId: NodeId, removeOrphans?: boolean): void;
+    removeEdges(nodeId: NodeId, type?: TEdgeType | NullEdgeType): void;
+    removeEdge(from: NodeId, to: NodeId, type?: TEdgeType | NullEdgeType, removeOrphans?: boolean): void;
+    _removeEdge(from: NodeId, to: NodeId, type?: TEdgeType | NullEdgeType, removeOrphans?: boolean): void;
+    isOrphanedNode(nodeId: NodeId): boolean;
+    updateNode(nodeId: NodeId, node: TNode): void;
+    replaceNodeIdsConnectedTo(fromNodeId: NodeId, toNodeIds: ReadonlyArray<NodeId>, replaceFilter?: null | ((arg1: NodeId) => boolean), type?: TEdgeType | NullEdgeType, removeOrphans?: boolean): void;
+    traverse<TContext>(visit: GraphVisitor<NodeId, TContext>, startNodeId?: NodeId | null, type?: TEdgeType | NullEdgeType | Array<TEdgeType | NullEdgeType> | AllEdgeTypes): TContext | null | undefined;
+    filteredTraverse<TValue, TContext>(filter: (arg1: NodeId, arg2: TraversalActions) => TValue | null | undefined, visit: GraphVisitor<TValue, TContext>, startNodeId?: NodeId | null, type?: TEdgeType | Array<TEdgeType | NullEdgeType> | AllEdgeTypes): TContext | null | undefined;
+    traverseAncestors<TContext>(startNodeId: NodeId | null | undefined, visit: GraphVisitor<NodeId, TContext>, type?: TEdgeType | NullEdgeType | Array<TEdgeType | NullEdgeType> | AllEdgeTypes): TContext | null | undefined;
+    dfsFast<TContext>(visit: GraphTraversalCallback<NodeId, TContext>, startNodeId?: NodeId | null): TContext | null | undefined;
+    postOrderDfsFast(visit: GraphTraversalCallback<NodeId, TraversalActions>, startNodeId?: NodeId | null): void;
+    /**
+     * Iterative implementation of DFS that supports all use-cases.
+     *
+     * This replaces `dfs` and will replace `dfsFast`.
+     */
+    dfs<TContext>({ visit, startNodeId, getChildren, }: DFSParams<TContext>): TContext | null | undefined;
+    bfs(visit: (nodeId: NodeId) => boolean | null | undefined): NodeId | null | undefined;
+    topoSort(type?: TEdgeType): Array<NodeId>;
+    findAncestor(nodeId: NodeId, fn: (nodeId: NodeId) => boolean): NodeId | null | undefined;
+    findAncestors(nodeId: NodeId, fn: (nodeId: NodeId) => boolean): Array<NodeId>;
+    findDescendant(nodeId: NodeId, fn: (nodeId: NodeId) => boolean): NodeId | null | undefined;
+    findDescendants(nodeId: NodeId, fn: (nodeId: NodeId) => boolean): Array<NodeId>;
+    _assertHasNodeId(nodeId: NodeId): void;
+}
+export declare function mapVisitor<NodeId, TValue, TContext>(filter: (arg1: NodeId, arg2: TraversalActions) => TValue | null | undefined, visit: GraphVisitor<TValue, TContext>): GraphVisitor<NodeId, TContext>;

package/lib/index.d.ts

@@ -0,0 +1,7 @@
+export type { NodeId, ContentKey, Edge } from './types';
+export type { GraphOpts } from './Graph';
+export type { ContentGraphOpts, SerializedContentGraph } from './ContentGraph';
+export { toNodeId, fromNodeId } from './types';
+export { default as Graph, ALL_EDGE_TYPES, mapVisitor } from './Graph';
+export { default as ContentGraph } from './ContentGraph';
+export { BitSet } from './BitSet';

package/lib/shared-buffer.d.ts

@@ -0,0 +1,2 @@
+export type Class<T> = new (...args: any[]) => T;
+export declare let SharedBuffer: Class<ArrayBuffer> | Class<SharedArrayBuffer>;

package/lib/types.d.ts

@@ -0,0 +1,9 @@
+export type NodeId = number;
+export declare function toNodeId(x: number): NodeId;
+export declare function fromNodeId(x: NodeId): number;
+export type ContentKey = string;
+export type Edge<TEdgeType extends number> = {
+    from: NodeId;
+    to: NodeId;
+    type: TEdgeType;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/graph",
-  "version": "3.5.10-typescript-1fd1095e8.0",
+  "version": "3.5.10-typescript-e99c742e9.0",
   "description": "Blazing fast, zero configuration web application bundler",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
@@ -10,24 +10,24 @@
     "type": "git",
     "url": "https://github.com/atlassian-labs/atlaspack.git"
   },
-  "main": "lib/index.js",
-  "source": "src/index.ts",
+  "main": "./lib/index.js",
+  "source": "./src/index.ts",
+  "types": "./lib/index.d.ts",
   "engines": {
     "node": ">= 16.0.0"
   },
   "scripts": {
     "benchmark": "node ./benchmark/BitSet.js",
-    "check-ts": "tsc --noEmit"
+    "check-ts": "tsc --emitDeclarationOnly --rootDir src"
   },
   "dependencies": {
-    "@atlaspack/feature-flags": "2.19.3-typescript-1fd1095e8.0",
+    "@atlaspack/feature-flags": "2.19.3-typescript-e99c742e9.0",
     "nullthrows": "^1.1.1"
   },
   "devDependencies": {
-    "@atlaspack/babel-register": "2.14.2-typescript-1fd1095e8.0",
+    "@atlaspack/babel-register": "2.14.2-typescript-e99c742e9.0",
     "benny": "^3.7.1"
   },
   "type": "commonjs",
-  "types": "src/index.ts",
-  "gitHead": "1fd1095e86da1e50d6c7819c0f132ce09a2bf396"
-}
+  "gitHead": "e99c742e92175ac411d807daf2ba45d5bacebb58"
+}