@atlaspack/bundler-experimental 2.12.1-canary.3625 → 2.12.1-canary.3627

package/lib/DominatorBundler/EdgeContentGraph.js

@@ -0,0 +1,67 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.EdgeContentGraph = void 0;
+function _graph() {
+  const data = require("@atlaspack/graph");
+  _graph = function () {
+    return data;
+  };
+  return data;
+}
+function _nullthrows() {
+  const data = _interopRequireDefault(require("nullthrows"));
+  _nullthrows = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/**
+ * A `ContentGraph` that also stores weights on edges.
+ *
+ * @template N The type of the node weight.
+ * @template EW The type of the edge weight.
+ */
+class EdgeContentGraph extends _graph().ContentGraph {
+  #edgeWeights = new Map();
+  clone() {
+    const newGraph = new EdgeContentGraph();
+    let nodeId = 0;
+    for (let node of this.nodes) {
+      const contentKey = this._nodeIdToContentKey.get(nodeId);
+      if (node == null) {
+        // Add null node to preserve node ids
+        // $FlowFixMe
+        newGraph.addNode(null);
+      } else if (contentKey == null) {
+        newGraph.addNode(node);
+      } else {
+        newGraph.addNodeByContentKey(contentKey, node);
+      }
+      nodeId += 1;
+    }
+    for (let edge of this.getAllEdges()) {
+      const weight = this.getEdgeWeight(edge.from, edge.to);
+      newGraph.addWeightedEdge(edge.from, edge.to, edge.type, weight);
+    }
+    if (this.rootNodeId != null) {
+      const rootNodeContentKey = this._nodeIdToContentKey.get(this.rootNodeId);
+      const newGraphRootNodeId = newGraph.getNodeIdByContentKey((0, _nullthrows().default)(rootNodeContentKey));
+      newGraph.setRootNodeId(newGraphRootNodeId);
+    }
+    return newGraph;
+  }
+  addWeightedEdge(from, to, type, weight) {
+    this.addEdge(from, to, type);
+    if (weight != null) {
+      this.#edgeWeights.set([String(from), String(to)].join(','), weight);
+    }
+  }
+  getEdgeWeight(from, to) {
+    return this.#edgeWeights.get([String(from), String(to)].join(',')) ?? null;
+  }
+}
+exports.EdgeContentGraph = EdgeContentGraph;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/bundler-experimental",
-  "version": "2.12.1-canary.3625+6c4f222b8",
+  "version": "2.12.1-canary.3627+2d2c23fab",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
     "access": "public"
@@ -16,19 +16,19 @@
     "parcel": "^2.12.0"
   },
   "dependencies": {
-    "@atlaspack/core": "2.12.1-canary.3625+6c4f222b8",
-    "@atlaspack/diagnostic": "2.12.1-canary.3625+6c4f222b8",
-    "@atlaspack/feature-flags": "2.12.1-canary.3625+6c4f222b8",
-    "@atlaspack/graph": "3.2.1-canary.3625+6c4f222b8",
-    "@atlaspack/logger": "2.12.1-canary.3625+6c4f222b8",
-    "@atlaspack/plugin": "2.12.1-canary.3625+6c4f222b8",
-    "@atlaspack/rust": "2.12.1-canary.3625+6c4f222b8",
-    "@atlaspack/types": "2.12.1-canary.3625+6c4f222b8",
-    "@atlaspack/utils": "2.12.1-canary.3625+6c4f222b8",
+    "@atlaspack/core": "2.12.1-canary.3627+2d2c23fab",
+    "@atlaspack/diagnostic": "2.12.1-canary.3627+2d2c23fab",
+    "@atlaspack/feature-flags": "2.12.1-canary.3627+2d2c23fab",
+    "@atlaspack/graph": "3.2.1-canary.3627+2d2c23fab",
+    "@atlaspack/logger": "2.12.1-canary.3627+2d2c23fab",
+    "@atlaspack/plugin": "2.12.1-canary.3627+2d2c23fab",
+    "@atlaspack/rust": "2.12.1-canary.3627+2d2c23fab",
+    "@atlaspack/types": "2.12.1-canary.3627+2d2c23fab",
+    "@atlaspack/utils": "2.12.1-canary.3627+2d2c23fab",
     "nullthrows": "^1.1.1"
   },
   "devDependencies": {
-    "@atlaspack/fs": "2.12.1-canary.3625+6c4f222b8"
+    "@atlaspack/fs": "2.12.1-canary.3627+2d2c23fab"
   },
-  "gitHead": "6c4f222b816a32ea2ac5cef41a1784e8d044f142"
+  "gitHead": "2d2c23fab90eea474aaf2ce0be4e5220a35f43cc"
 }

package/src/DominatorBundler/EdgeContentGraph.js

@@ -0,0 +1,62 @@
+// @flow strict-local
+
+import {ContentGraph, type NodeId} from '@atlaspack/graph';
+import nullthrows from 'nullthrows';
+
+/**
+ * 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 class EdgeContentGraph<N, EW> extends ContentGraph<N, number> {
+  #edgeWeights: Map<string, EW> = new Map();
+
+  clone(): EdgeContentGraph<N, EW> {
+    const newGraph: EdgeContentGraph<N, EW> = new EdgeContentGraph();
+    let nodeId = 0;
+    for (let node of this.nodes) {
+      const contentKey = this._nodeIdToContentKey.get(nodeId);
+      if (node == null) {
+        // Add null node to preserve node ids
+        // $FlowFixMe
+        newGraph.addNode(null);
+      } else if (contentKey == null) {
+        newGraph.addNode(node);
+      } else {
+        newGraph.addNodeByContentKey(contentKey, node);
+      }
+      nodeId += 1;
+    }
+    for (let edge of this.getAllEdges()) {
+      const weight = this.getEdgeWeight(edge.from, edge.to);
+      newGraph.addWeightedEdge(edge.from, edge.to, edge.type, weight);
+    }
+
+    if (this.rootNodeId != null) {
+      const rootNodeContentKey = this._nodeIdToContentKey.get(this.rootNodeId);
+      const newGraphRootNodeId = newGraph.getNodeIdByContentKey(
+        nullthrows(rootNodeContentKey),
+      );
+      newGraph.setRootNodeId(newGraphRootNodeId);
+    }
+
+    return newGraph;
+  }
+
+  addWeightedEdge(
+    from: NodeId,
+    to: NodeId,
+    type: number,
+    weight: EW | null,
+  ): void {
+    this.addEdge(from, to, type);
+    if (weight != null) {
+      this.#edgeWeights.set([String(from), String(to)].join(','), weight);
+    }
+  }
+
+  getEdgeWeight(from: NodeId, to: NodeId): EW | null {
+    return this.#edgeWeights.get([String(from), String(to)].join(',')) ?? null;
+  }
+}

package/test/DominatorBundler/EdgeContentGraph.test.js

@@ -0,0 +1,58 @@
+// @flow strict-local
+
+import assert from 'assert';
+import {EdgeContentGraph} from '../../src/DominatorBundler/EdgeContentGraph';
+
+describe('EdgeContentGraph', () => {
+  describe('addWeightedEdge', () => {
+    it('creates an edge between two nodes', () => {
+      const graph = new EdgeContentGraph<string, number>();
+      const a = graph.addNode('a');
+      const b = graph.addNode('b');
+      const edgeType = 1;
+      const weight = 10;
+      graph.addWeightedEdge(a, b, edgeType, weight);
+      const ids = graph.getNodeIdsConnectedFrom(a);
+      assert.deepEqual(ids, [b]);
+    });
+
+    it('should add and get edge weights', () => {
+      const graph = new EdgeContentGraph<string, number>();
+      const a = graph.addNode('a');
+      const b = graph.addNode('b');
+      const c = graph.addNode('b');
+
+      const edgeType = 1;
+      const weight1 = 10;
+      const weight2 = 20;
+
+      graph.addWeightedEdge(a, b, edgeType, weight1);
+      graph.addWeightedEdge(b, c, edgeType, weight2);
+
+      assert.equal(graph.getEdgeWeight(a, b), weight1);
+      assert.equal(graph.getEdgeWeight(b, c), weight2);
+    });
+  });
+
+  describe('clone', () => {
+    it('clones the graph', () => {
+      const graph = new EdgeContentGraph<string, number>();
+      const a = graph.addNode('a');
+      const b = graph.addNode('b');
+      const c = graph.addNode('c');
+
+      const edgeType = 1;
+      const weight1 = 10;
+      const weight2 = 20;
+
+      graph.addWeightedEdge(a, b, edgeType, weight1);
+      graph.addWeightedEdge(b, c, edgeType, weight2);
+
+      const clonedGraph = graph.clone();
+      assert.deepEqual(clonedGraph.nodes, graph.nodes);
+      assert.deepEqual(clonedGraph.getAllEdges(), graph.getAllEdges());
+      assert.equal(clonedGraph.getEdgeWeight(a, b), weight1);
+      assert.equal(clonedGraph.getEdgeWeight(b, c), weight2);
+    });
+  });
+});