@atlaspack/bundler-experimental 2.13.7-canary.138 → 2.13.7-canary.139

package/lib/DominatorBundler/EdgeContentGraph.d.ts

@@ -0,0 +1,13 @@
+import { ContentGraph, NodeId } from '@atlaspack/graph';
+/**
+ * A `ContentGraph` that also stores weights on edges.
+ *
+ * @template N The type of the node weight.
+ * @template EW The type of the edge weight.
+ */
+export declare class EdgeContentGraph<N, EW> extends ContentGraph<N, number> {
+    #private;
+    clone(): EdgeContentGraph<N, EW>;
+    addWeightedEdge(from: NodeId, to: NodeId, type: number, weight: EW | null): void;
+    getEdgeWeight(from: NodeId, to: NodeId): EW | null;
+}

package/lib/DominatorBundler/EdgeContentGraph.js

@@ -34,7 +34,7 @@ class EdgeContentGraph extends _graph().ContentGraph {
       const contentKey = this._nodeIdToContentKey.get(nodeId);
       if (node == null) {
         // Add null node to preserve node ids
-        // $FlowFixMe
+        // @ts-expect-error TS2345
         newGraph.addNode(null);
       } else if (contentKey == null) {
         newGraph.addNode(node);
@@ -43,6 +43,7 @@ class EdgeContentGraph extends _graph().ContentGraph {
       }
       nodeId += 1;
     }
+    // @ts-expect-error TS2488
     for (let edge of this.getAllEdges()) {
       const weight = this.getEdgeWeight(edge.from, edge.to);
       newGraph.addWeightedEdge(edge.from, edge.to, edge.type, weight);

package/lib/DominatorBundler/cycleBreaker/findStronglyConnectedComponents.d.ts

@@ -0,0 +1,12 @@
+import type { Graph, NodeId } from '@atlaspack/graph';
+export type StronglyConnectedComponent = NodeId[];
+/**
+ * Robert Tarjan's algorithm to find strongly connected components in a graph.
+ *
+ * Time complexity: O(V + E)
+ * Space complexity (worst case): O(V)
+ *
+ * * https://web.archive.org/web/20170829214726id_/http://www.cs.ucsb.edu/~gilbert/cs240a/old/cs240aSpr2011/slides/TarjanDFS.pdf
+ * * https://en.wikipedia.org/wiki/Tarjan%27s_strongly_connected_components_algorithm
+ */
+export declare function findStronglyConnectedComponents<T, E extends number>(graph: Graph<T, E>): StronglyConnectedComponent[];

package/lib/DominatorBundler/cycleBreaker/findStronglyConnectedComponents.js

@@ -48,7 +48,9 @@ function findStronglyConnectedComponents(graph) {
       let member;
       do {
         member = stack.pop();
+        // @ts-expect-error TS2538
         state[member].onStack = false;
+        // @ts-expect-error TS2345
         component.push(member);
       } while (member !== nodeId);
       result.push(component);

package/lib/DominatorBundler/findAssetDominators/simpleFastDominance.d.ts

@@ -0,0 +1,58 @@
+import { NodeId, Graph } from '@atlaspack/graph';
+/**
+ * Implements "A simple, fast dominance algorithm", to find the immediate
+ * dominators of all nodes in a graph.
+ *
+ * Returns a map of node IDs to their immediate dominator's node ID.
+ * This map is represented by an array where the index is the node ID and the
+ * value is its dominator.
+ *
+ * For example, given a node `3`, `dominators[3]` is the immediate dominator
+ * of node 3.
+ *
+ * - https://www.cs.tufts.edu/comp/150FP/archive/keith-cooper/dom14.pdf
+ */
+export declare function simpleFastDominance<T>(graph: Graph<T, number>): NodeId[];
+/**
+ * Return the post-order of the graph.
+ */
+export declare function getGraphPostOrder<T>(graph: Graph<T, number>, type?: number): NodeId[];
+/**
+ * From "A Simple, Fast Dominance Algorithm"
+ * Keith D. Cooper, Timothy J. Harvey, and Ken Kennedy:
+ *
+ * > The intersection routine appears at the bottom of the figure.
+ * > It implements a “two-finger” algorithm – one can imagine a finger pointing
+ * > to each dominator set, each finger moving independently as the comparisons
+ * > dictate. In this case, the comparisons are on postorder numbers; for each
+ * > intersection, we start the two fingers at the ends of the two sets, and,
+ * > until the fingers point to the same postorder number, we move the finger
+ * > pointing to the smaller number back one element. Remember that nodes higher
+ * > in the dominator tree have higher postorder numbers, which is why intersect
+ * > moves the finger whose value is less than the other finger’s. When the two
+ * > fingers point at the same element, intersect returns that element. The set
+ * > resulting from the intersection begins with the returned element and chains
+ * > its way up the doms array to the entry node.
+ *
+ * `postOrder` is the post-order node list of the graph.
+ *
+ * `dominators` is the current immediate dominator state for node in the graph.
+ *
+ * This is coupled with the fact node ids are indexes into an array. It is a map
+ * of NodeId -> NodeId, where the value at index `i` is the immediate dominator
+ * of the node `i`.
+ *
+ * `predecessor` is one predecessor node id of the node we're currently
+ * computing the immediate dominator for.
+ *
+ * `newImmediateDominator` is current best immediate dominator candidate for the
+ * node we're computing the immediate dominator for.
+ *
+ * The algorithm is intersecting the dominator sets of the two predecessors and
+ * returning dominator node with the highest post-order number by walking up
+ * the dominator tree until the two sets intersect.
+ *
+ * The node with the highest post-order index is the immediate dominator, as
+ * it is the closest to the node we're computing for.
+ */
+export declare function intersect(postOrderIndexes: number[], dominators: NodeId | null[], predecessor: NodeId, newImmediateDominator: NodeId): NodeId;

package/lib/DominatorBundler/findAssetDominators/simpleFastDominance.js

@@ -44,15 +44,22 @@ function simpleFastDominance(graph) {
     changed = false;
     for (let node of reversedPostOrder) {
       if (node === graph.rootNodeId) continue;
+
+      // @ts-expect-error TS7034
       let newImmediateDominator = null;
-      graph.forEachNodeIdConnectedTo(node, predecessor => {
+      graph.forEachNodeIdConnectedTo(node,
+      // @ts-expect-error TS2345
+      predecessor => {
+        // @ts-expect-error TS7005
         if (newImmediateDominator == null) {
           newImmediateDominator = predecessor;
         } else {
           if (dominators[predecessor] == null) {
             return;
           }
-          newImmediateDominator = intersect(postOrderIndexes, dominators, predecessor, newImmediateDominator);
+          newImmediateDominator = intersect(postOrderIndexes, dominators, predecessor,
+          // @ts-expect-error TS7005
+          newImmediateDominator);
         }
       }, _graph().ALL_EDGE_TYPES);
       if (dominators[node] !== newImmediateDominator) {
@@ -120,9 +127,11 @@ function intersect(postOrderIndexes, dominators, predecessor, newImmediateDomina
   let n2 = newImmediateDominator;
   while (n1 !== n2) {
     while (postOrderIndexes[n1] < postOrderIndexes[n2]) {
+      // @ts-expect-error TS7053
       n1 = Number(dominators[n1]);
     }
     while (postOrderIndexes[n2] < postOrderIndexes[n1]) {
+      // @ts-expect-error TS7053
       n2 = Number(dominators[n2]);
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/bundler-experimental",
-  "version": "2.13.7-canary.138+eda07caaf",
+  "version": "2.13.7-canary.139+d2fd84977",
   "license": "(MIT OR Apache-2.0)",
   "type": "commonjs",
   "publishConfig": {
@@ -10,25 +10,29 @@
     "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"
   },
   "dependencies": {
-    "@atlaspack/core": "2.16.2-canary.138+eda07caaf",
-    "@atlaspack/diagnostic": "2.14.1-canary.206+eda07caaf",
-    "@atlaspack/feature-flags": "2.14.1-canary.206+eda07caaf",
-    "@atlaspack/graph": "3.4.1-canary.206+eda07caaf",
-    "@atlaspack/logger": "2.14.5-canary.138+eda07caaf",
-    "@atlaspack/plugin": "2.14.5-canary.138+eda07caaf",
-    "@atlaspack/rust": "3.2.1-canary.138+eda07caaf",
-    "@atlaspack/types": "2.14.5-canary.138+eda07caaf",
-    "@atlaspack/utils": "2.14.5-canary.138+eda07caaf",
+    "@atlaspack/core": "2.16.2-canary.139+d2fd84977",
+    "@atlaspack/diagnostic": "2.14.1-canary.207+d2fd84977",
+    "@atlaspack/feature-flags": "2.14.1-canary.207+d2fd84977",
+    "@atlaspack/graph": "3.4.1-canary.207+d2fd84977",
+    "@atlaspack/logger": "2.14.5-canary.139+d2fd84977",
+    "@atlaspack/plugin": "2.14.5-canary.139+d2fd84977",
+    "@atlaspack/rust": "3.2.1-canary.139+d2fd84977",
+    "@atlaspack/types": "2.14.5-canary.139+d2fd84977",
+    "@atlaspack/utils": "2.14.5-canary.139+d2fd84977",
     "nullthrows": "^1.1.1"
   },
   "devDependencies": {
-    "@atlaspack/fs": "2.14.5-canary.138+eda07caaf"
+    "@atlaspack/fs": "2.14.5-canary.139+d2fd84977"
   },
-  "gitHead": "eda07caafd2ebb814bbdbfd0ec12fa63124e213f"
-}
+  "scripts": {
+    "check-ts": "tsc --emitDeclarationOnly --rootDir src"
+  },
+  "gitHead": "d2fd849770fe6305e9c694bd97b1bd905abd9d94"
+}

package/src/DominatorBundler/{EdgeContentGraph.js → EdgeContentGraph.ts}

@@ -1,6 +1,4 @@
-// @flow strict-local
-
-import {ContentGraph, type NodeId} from '@atlaspack/graph';
+import {ContentGraph, NodeId} from '@atlaspack/graph';
 import nullthrows from 'nullthrows';
 
 /**
@@ -19,7 +17,7 @@ export class EdgeContentGraph<N, EW> extends ContentGraph<N, number> {
       const contentKey = this._nodeIdToContentKey.get(nodeId);
       if (node == null) {
         // Add null node to preserve node ids
-        // $FlowFixMe
+        // @ts-expect-error TS2345
         newGraph.addNode(null);
       } else if (contentKey == null) {
         newGraph.addNode(node);
@@ -28,6 +26,7 @@ export class EdgeContentGraph<N, EW> extends ContentGraph<N, number> {
       }
       nodeId += 1;
     }
+    // @ts-expect-error TS2488
     for (let edge of this.getAllEdges()) {
       const weight = this.getEdgeWeight(edge.from, edge.to);
       newGraph.addWeightedEdge(edge.from, edge.to, edge.type, weight);

package/src/DominatorBundler/cycleBreaker/{findStronglyConnectedComponents.js → findStronglyConnectedComponents.ts}

@@ -1,5 +1,3 @@
-// @flow strict-local
-
 import type {Graph, NodeId} from '@atlaspack/graph';
 
 export type StronglyConnectedComponent = NodeId[];
@@ -13,17 +11,17 @@ export type StronglyConnectedComponent = NodeId[];
  * * https://web.archive.org/web/20170829214726id_/http://www.cs.ucsb.edu/~gilbert/cs240a/old/cs240aSpr2011/slides/TarjanDFS.pdf
  * * https://en.wikipedia.org/wiki/Tarjan%27s_strongly_connected_components_algorithm
  */
-export function findStronglyConnectedComponents<T, E: number>(
+export function findStronglyConnectedComponents<T, E extends number>(
   graph: Graph<T, E>,
 ): StronglyConnectedComponent[] {
-  type State = {|
-    index: null | NodeId,
-    lowlink: null | NodeId,
-    onStack: boolean,
-  |};
-  const result = [];
+  type State = {
+    index: null | NodeId;
+    lowlink: null | NodeId;
+    onStack: boolean;
+  };
+  const result: Array<StronglyConnectedComponent> = [];
   let index = 0;
-  const stack = [];
+  const stack: Array<NodeId | number> = [];
   const state: State[] = new Array(graph.nodes.length).fill(null).map(() => ({
     index: null,
     lowlink: null,
@@ -34,7 +32,7 @@ export function findStronglyConnectedComponents<T, E: number>(
       strongConnect(nodeId);
     }
   });
-  function strongConnect(nodeId) {
+  function strongConnect(nodeId: NodeId | number) {
     const nodeState = state[nodeId];
     nodeState.index = index;
     nodeState.lowlink = index;
@@ -62,12 +60,14 @@ export function findStronglyConnectedComponents<T, E: number>(
     }
 
     if (nodeState.lowlink === nodeState.index) {
-      const component = [];
+      const component: Array<NodeId> = [];
       let member;
 
       do {
         member = stack.pop();
+        // @ts-expect-error TS2538
         state[member].onStack = false;
+        // @ts-expect-error TS2345
         component.push(member);
       } while (member !== nodeId);
 

package/src/DominatorBundler/findAssetDominators/{simpleFastDominance.js → simpleFastDominance.ts}

@@ -1,6 +1,4 @@
-// @flow strict-local
-
-import {type NodeId, Graph, ALL_EDGE_TYPES} from '@atlaspack/graph';
+import {NodeId, Graph, ALL_EDGE_TYPES} from '@atlaspack/graph';
 
 /**
  * Implements "A simple, fast dominance algorithm", to find the immediate
@@ -40,10 +38,13 @@ export function simpleFastDominance<T>(graph: Graph<T, number>): NodeId[] {
     for (let node of reversedPostOrder) {
       if (node === graph.rootNodeId) continue;
 
+      // @ts-expect-error TS7034
       let newImmediateDominator = null;
       graph.forEachNodeIdConnectedTo(
         node,
+        // @ts-expect-error TS2345
         (predecessor) => {
+          // @ts-expect-error TS7005
           if (newImmediateDominator == null) {
             newImmediateDominator = predecessor;
           } else {
@@ -55,6 +56,7 @@ export function simpleFastDominance<T>(graph: Graph<T, number>): NodeId[] {
               postOrderIndexes,
               dominators,
               predecessor,
+              // @ts-expect-error TS7005
               newImmediateDominator,
             );
           }
@@ -79,7 +81,7 @@ export function getGraphPostOrder<T>(
   graph: Graph<T, number>,
   type: number = 1,
 ): NodeId[] {
-  const postOrder = [];
+  const postOrder: Array<NodeId> = [];
   graph.traverse(
     {
       exit: (node) => {
@@ -132,7 +134,7 @@ export function getGraphPostOrder<T>(
  */
 export function intersect(
   postOrderIndexes: number[],
-  dominators: (NodeId | null)[],
+  dominators: NodeId | null[],
   predecessor: NodeId,
   newImmediateDominator: NodeId,
 ): NodeId {
@@ -140,9 +142,11 @@ export function intersect(
   let n2: number = newImmediateDominator;
   while (n1 !== n2) {
     while (postOrderIndexes[n1] < postOrderIndexes[n2]) {
+      // @ts-expect-error TS7053
       n1 = Number(dominators[n1]);
     }
     while (postOrderIndexes[n2] < postOrderIndexes[n1]) {
+      // @ts-expect-error TS7053
       n2 = Number(dominators[n2]);
     }
   }

package/test/DominatorBundler/{EdgeContentGraph.test.js → EdgeContentGraph.test.ts}

@@ -1,5 +1,3 @@
-// @flow strict-local
-
 import assert from 'assert';
 import {EdgeContentGraph} from '../../src/DominatorBundler/EdgeContentGraph';
 

package/test/DominatorBundler/cycleBreaker/{findStronglyConnectedComponents.js → findStronglyConnectedComponents.ts}

@@ -1,5 +1,3 @@
-// @flow strict-local
-
 import {Graph} from '@atlaspack/graph';
 import assert from 'assert';
 import {findStronglyConnectedComponents} from '../../../src/DominatorBundler/cycleBreaker/findStronglyConnectedComponents';

package/test/DominatorBundler/findAssetDominators/{simpleFastDominance.test.js → simpleFastDominance.test.ts}

@@ -1,5 +1,3 @@
-// @flow strict-local
-
 import assert from 'assert';
 import {Graph} from '@atlaspack/graph';
 import {simpleFastDominance} from '../../../src/DominatorBundler/findAssetDominators/simpleFastDominance';

package/test/{fixtureFromGraph.test.js → fixtureFromGraph.test.ts}

@@ -1,5 +1,3 @@
-// @flow strict-local
-
 import {MemoryFS} from '@atlaspack/fs';
 import assert from 'assert';
 import {workerFarm} from '@atlaspack/test-utils';

package/test/{fixtureFromGraph.js → fixtureFromGraph.ts}

@@ -1,5 +1,3 @@
-// @flow strict-local
-
 /*!
  * This module provides a way to write fixtures where we don't care about the
  * code within the assets; only the shape of the asset graphs.
@@ -15,44 +13,44 @@ export type GraphEntry = AssetEntry;
 /**
  * An asset in the fixture graph. Just a path and dependencies
  */
-export type AssetEntry = {|
-  type: 'asset',
-  value: {|
-    filePath: string,
-    dependencies: DependencyEntry[],
-  |},
-|};
+export type AssetEntry = {
+  type: 'asset';
+  value: {
+    filePath: string;
+    dependencies: DependencyEntry[];
+  };
+};
 
 /**
  * Sync or async dependency between assets
  */
-export type DependencyEntry = {|
-  type: 'dependency',
-  value: {|
-    from: string,
-    to: string,
-    type: 'sync' | 'async',
-  |},
-|};
+export type DependencyEntry = {
+  type: 'dependency';
+  value: {
+    from: string;
+    to: string;
+    type: 'sync' | 'async';
+  };
+};
 
-export type DependencySpec = {|
-  to: string,
-  type: 'sync' | 'async',
-|};
+export type DependencySpec = {
+  to: string;
+  type: 'sync' | 'async';
+};
 
 /**
  * Create an asset node in the fixture graph
  */
 export function asset(
   path: string,
-  dependencies?: (string | DependencySpec)[],
+  dependencies?: string | DependencySpec[],
 ): GraphEntry {
   return {
     type: 'asset',
     value: {
       filePath: path,
       dependencies:
-        dependencies?.map((dependency) => {
+        dependencies?.map((dependency: DependencySpec | string) => {
           if (typeof dependency === 'string') {
             return {
               type: 'dependency',
@@ -159,7 +157,7 @@ export async function fixtureFromGraph(
  *
  */
 export function dotFromGraph(entries: GraphEntry[]): string {
-  const contents = [];
+  const contents: Array<string> = [];
 
   for (let entry of entries) {
     if (entry.type === 'asset') {

package/tsconfig.json

@@ -0,0 +1,4 @@
+{
+  "extends": "../../../tsconfig.json",
+  "include": ["src"]
+}