@atlaspack/graph 3.5.10 → 3.5.11-typescript-5ad950d33.0

package/lib/AdjacencyList.js

@@ -23,9 +23,13 @@ var _types = require("./types");
 var _Graph = require("./Graph");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 /** The address of the node in the nodes map. */
+
 /** The address of the edge in the edges map. */
+
 // eslint-disable-next-line no-unused-vars
+
 // eslint-disable-next-line no-unused-vars
+
 const DEFAULT_PARAMS = {
   initialCapacity: 2,
   unloadFactor: 0.3,
@@ -99,7 +103,10 @@ class AdjacencyList {
   constructor(opts) {
     let nodes;
     let edges;
+
+    // @ts-expect-error TS2339
     if (opts !== null && opts !== void 0 && opts.nodes) {
+      // @ts-expect-error TS2339
       ({
         nodes,
         edges
@@ -152,6 +159,7 @@ class AdjacencyList {
   get stats() {
     let edgeTypes = new Set();
     let buckets = new Map();
+    // @ts-expect-error TS2488
     for (let {
       from,
       to,
@@ -224,13 +232,17 @@ class AdjacencyList {
 
     // Copy the existing edges into the new array.
     nodes.nextId = this.#nodes.nextId;
-    this.#edges.forEach(edge => void link(this.#edges.from(edge), this.#edges.to(edge), this.#edges.typeOf(edge), edges, nodes, this.#params.unloadFactor));
+    this.#edges.forEach(edge => void link(this.#edges.from(edge), this.#edges.to(edge), this.#edges.typeOf(edge),
+    // @ts-expect-error TS2345
+    edges, nodes, this.#params.unloadFactor));
 
     // We expect to preserve the same number of edges.
     (0, _assert().default)(this.#edges.count === edges.count, `Edge mismatch! ${this.#edges.count} does not match ${edges.count}.`);
 
     // Finally, copy the new data arrays over to this graph.
+    // @ts-expect-error TS2322
     this.#nodes = nodes;
+    // @ts-expect-error TS2322
     this.#edges = edges;
   }
 
@@ -599,6 +611,7 @@ class SharedTypeMap {
   static #TYPE = 1;
 
   /** The largest possible capacity. */
+  // @ts-expect-error TS1094
   static get MAX_CAPACITY() {
     return Math.floor(
     // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Invalid_array_length#what_went_wrong
@@ -631,6 +644,7 @@ class SharedTypeMap {
 
   /** The address of the first item in the map. */
   get addressableLimit() {
+    // @ts-expect-error TS2339
     return this.constructor.HEADER_SIZE + this.capacity;
   }
 
@@ -653,7 +667,6 @@ class SharedTypeMap {
         BYTES_PER_ELEMENT
       } = Uint32Array;
       let CAPACITY = SharedTypeMap.#CAPACITY;
-      // $FlowFixMe[incompatible-call]
       this.data = new Uint32Array(new _sharedBuffer.SharedBuffer(this.getLength(capacityOrData) * BYTES_PER_ELEMENT));
       this.data[CAPACITY] = capacityOrData;
     } else {
@@ -670,6 +683,7 @@ class SharedTypeMap {
    * and is expected to be of equal or smaller capacity to this map.
    */
   set(data) {
+    // @ts-expect-error TS2339
     let {
       HEADER_SIZE,
       ITEM_SIZE
@@ -720,6 +734,7 @@ class SharedTypeMap {
    * get the length of the map, in bytes.
    */
   getLength(capacity = this.capacity) {
+    // @ts-expect-error TS2339
     let {
       HEADER_SIZE,
       ITEM_SIZE
@@ -729,6 +744,7 @@ class SharedTypeMap {
 
   /** Get the next available address in the map. */
   getNextAddress() {
+    // @ts-expect-error TS2339
     let {
       HEADER_SIZE,
       ITEM_SIZE
@@ -738,6 +754,7 @@ class SharedTypeMap {
 
   /** Get the address of the first item with the given hash. */
   head(hash) {
+    // @ts-expect-error TS2339
     let {
       HEADER_SIZE
     } = this.constructor;
@@ -763,6 +780,7 @@ class SharedTypeMap {
     let COUNT = SharedTypeMap.#COUNT;
     let NEXT = SharedTypeMap.#NEXT;
     let TYPE = SharedTypeMap.#TYPE;
+    // @ts-expect-error TS2339
     let {
       HEADER_SIZE
     } = this.constructor;
@@ -789,6 +807,7 @@ class SharedTypeMap {
     let COUNT = SharedTypeMap.#COUNT;
     let NEXT = SharedTypeMap.#NEXT;
     let TYPE = SharedTypeMap.#TYPE;
+    // @ts-expect-error TS2339
     let {
       HEADER_SIZE
     } = this.constructor;
@@ -801,6 +820,7 @@ class SharedTypeMap {
     let candidate = head;
     while (candidate !== null && candidate !== item) {
       prev = candidate;
+      // @ts-expect-error TS2322
       candidate = this.next(candidate);
     }
     if (prev !== null && next !== null) {
@@ -818,6 +838,7 @@ class SharedTypeMap {
   forEach(cb) {
     let max = this.count;
     let len = this.length;
+    // @ts-expect-error TS2339
     let {
       ITEM_SIZE
     } = this.constructor;
@@ -834,10 +855,10 @@ class SharedTypeMap {
   // See https://github.com/facebook/flow/issues/1163#issuecomment-353523840
   /*:: @@iterator(): Iterator<TAddress> { return ({}: any); } */
 
-  // $FlowFixMe[unsupported-syntax]
   *[Symbol.iterator]() {
     let max = this.count;
     let len = this.length;
+    // @ts-expect-error TS2339
     let {
       ITEM_SIZE
     } = this.constructor;
@@ -849,6 +870,7 @@ class SharedTypeMap {
     }
   }
   inspect() {
+    // @ts-expect-error TS2339
     const {
       HEADER_SIZE
     } = this.constructor;
@@ -1168,6 +1190,7 @@ class EdgeTypeMap extends SharedTypeMap {
 
   /** Get the next available address in the map. */
   getNextAddress() {
+    // @ts-expect-error TS2339
     let {
       ITEM_SIZE
     } = this.constructor;

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/BitSet.js

@@ -102,7 +102,6 @@ class BitSet {
       let v = bits[k];
       while (v !== 0) {
         let t = (v & -v) >>> 0;
-        // $FlowFixMe
         fn((k << 5) + ctz32(v));
         v ^= t;
       }

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/ContentGraph.js

@@ -30,18 +30,14 @@ class ContentGraph extends _Graph.default {
       this._nodeIdToContentKey = new Map();
     }
   }
-
-  // $FlowFixMe[prop-missing]
   static deserialize(opts) {
     return new ContentGraph(opts);
   }
-
-  // $FlowFixMe[prop-missing]
   serialize() {
-    // $FlowFixMe[prop-missing]
     return {
       ...super.serialize(),
       _contentKeyToNodeId: this._contentKeyToNodeId,
+      // @ts-expect-error TS2353
       _nodeIdToContentKey: this._nodeIdToContentKey
     };
   }

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/Graph.js

@@ -248,6 +248,7 @@ class Graph {
       context: null
     }];
     while (queue.length !== 0) {
+      // @ts-expect-error TS2339
       let {
         nodeId,
         context
@@ -257,7 +258,6 @@ class Graph {
       skipped = false;
       let newContext = visit(nodeId, context, actions);
       if (typeof newContext !== 'undefined') {
-        // $FlowFixMe[reassign-const]
         context = newContext;
       }
       if (skipped) {
@@ -366,15 +366,18 @@ class Graph {
     const enter = typeof visit === 'function' ? visit : visit.enter;
     while (queue.length !== 0) {
       const command = queue.pop();
+
+      // @ts-expect-error TS18048
       if (command.exit != null) {
+        // @ts-expect-error TS2339
         let {
           nodeId,
           context,
           exit
         } = command;
+        // @ts-expect-error TS18048
         let newContext = exit(nodeId, command.context, actions);
         if (typeof newContext !== 'undefined') {
-          // $FlowFixMe[reassign-const]
           context = newContext;
         }
         if (skipped) {
@@ -385,6 +388,7 @@ class Graph {
           return context;
         }
       } else {
+        // @ts-expect-error TS2339
         let {
           nodeId,
           context
@@ -395,7 +399,6 @@ class Graph {
         if (enter) {
           let newContext = enter(nodeId, context, actions);
           if (typeof newContext !== 'undefined') {
-            // $FlowFixMe[reassign-const]
             context = newContext;
           }
         }
@@ -440,6 +443,8 @@ class Graph {
       if (stop === true) {
         return node;
       }
+
+      // @ts-expect-error TS2345
       for (let child of this.getNodeIdsConnectedFrom(node)) {
         if (!visited.has(child)) {
           visited.add(child);

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/shared-buffer.js

@@ -4,10 +4,14 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.SharedBuffer = void 0;
+// flow-to-ts helpers
+
+// /flow-to-ts helpers
+
 // Copy from @atlaspack/utils to fix: https://github.com/stackblitz/core/issues/1855
 let SharedBuffer = exports.SharedBuffer = void 0;
 
-// $FlowFixMe[prop-missing]
+// @ts-expect-error TS2339
 if (process.browser) {
   exports.SharedBuffer = SharedBuffer = ArrayBuffer;
   // Safari has removed the constructor

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/lib/types.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.fromNodeId = fromNodeId;
 exports.toNodeId = toNodeId;
 // forcing NodeId to be opaque as it should only be created once
+
 function toNodeId(x) {
   return x;
 }

package/package.json

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