@workglow/util 0.0.121 → 0.0.123

package/dist/graph-entry.js

@@ -0,0 +1,539 @@
+// src/utilities/BaseError.ts
+class BaseError {
+  static type = "BaseError";
+  message;
+  name;
+  stack;
+  constructor(message = "") {
+    this.message = message;
+    const constructor = this.constructor;
+    this.name = constructor.type ?? this.constructor.name;
+    if (typeof Error !== "undefined" && Error.captureStackTrace) {
+      const temp = { stack: "" };
+      Error.captureStackTrace(temp, this.constructor);
+      this.stack = temp.stack;
+    } else {
+      try {
+        throw new Error(message);
+      } catch (err) {
+        if (err instanceof Error) {
+          this.stack = err.stack;
+        }
+      }
+    }
+  }
+  toString() {
+    return `${this.name}: ${this.message}`;
+  }
+}
+
+// src/graph/errors.ts
+class NodeAlreadyExistsError extends BaseError {
+  static type = "NodeAlreadyExistsError";
+  newNode;
+  oldNode;
+  identity;
+  constructor(newNode, oldNode, identity) {
+    super(`${JSON.stringify(newNode)} shares an identity (${String(identity)}) with ${JSON.stringify(oldNode)}`);
+    this.newNode = newNode;
+    this.oldNode = oldNode;
+    this.identity = identity;
+    this.name = "NodeAlreadyExistsError";
+    Object.setPrototypeOf(this, NodeAlreadyExistsError.prototype);
+  }
+}
+
+class NodeDoesntExistError extends BaseError {
+  static type = "NodeDoesntExistError";
+  identity;
+  constructor(identity) {
+    super(`A node with identity ${String(identity)} doesn't exist in the graph`);
+    this.identity = identity;
+    this.name = "NodeDoesntExistError";
+    Object.setPrototypeOf(this, NodeDoesntExistError.prototype);
+  }
+}
+
+class CycleError extends BaseError {
+  static type = "CycleError";
+  constructor(message) {
+    super(message);
+    this.name = "CycleError";
+    Object.setPrototypeOf(this, CycleError.prototype);
+  }
+}
+
+// src/events/EventEmitter.ts
+class EventEmitter {
+  listeners = {};
+  removeAllListeners(event) {
+    if (event) {
+      delete this.listeners[event];
+    } else {
+      this.listeners = {};
+    }
+    return this;
+  }
+  on(event, listener) {
+    const listeners = this.listeners[event] || (this.listeners[event] = []);
+    listeners.push({ listener });
+    return this;
+  }
+  off(event, listener) {
+    const listeners = this.listeners[event];
+    if (!listeners)
+      return this;
+    const index = listeners.findIndex((l) => l.listener === listener);
+    if (index >= 0) {
+      listeners.splice(index, 1);
+    }
+    return this;
+  }
+  once(event, listener) {
+    const listeners = this.listeners[event] || (this.listeners[event] = []);
+    listeners.push({ listener, once: true });
+    return this;
+  }
+  waitOn(event) {
+    return new Promise((resolve) => {
+      const listener = (...args) => {
+        resolve(args);
+      };
+      this.once(event, listener);
+    });
+  }
+  emit(event, ...args) {
+    const listeners = this.listeners[event];
+    if (listeners) {
+      listeners.forEach(({ listener }) => {
+        listener(...args);
+      });
+      this.listeners[event] = listeners.filter((l) => !l.once);
+    }
+  }
+  subscribe(event, listener) {
+    this.on(event, listener);
+    return () => this.off(event, listener);
+  }
+}
+
+// src/graph/graph.ts
+class Graph {
+  nodes;
+  adjacency;
+  nodeIdentity;
+  edgeIdentity;
+  constructor(nodeIdentity, edgeIdentity) {
+    this.nodes = new Map;
+    this.adjacency = [];
+    this.nodeIdentity = nodeIdentity;
+    this.edgeIdentity = edgeIdentity;
+  }
+  events = new EventEmitter;
+  on(name, fn) {
+    this.events.on.call(this.events, name, fn);
+  }
+  off(name, fn) {
+    this.events.off.call(this.events, name, fn);
+  }
+  emit(name, ...args) {
+    this.events.emit(name, ...args);
+  }
+  insert(node) {
+    const id = this.nodeIdentity(node);
+    const isOverwrite = this.nodes.has(id);
+    if (isOverwrite) {
+      throw new NodeAlreadyExistsError(node, this.nodes.get(id), id);
+    }
+    this.nodes.set(id, node);
+    this.adjacency.map((adj) => adj.push(null));
+    this.adjacency.push(new Array(this.adjacency.length + 1).fill(null));
+    this.emit("node-added", id);
+    return id;
+  }
+  replace(node) {
+    const id = this.nodeIdentity(node);
+    const isOverwrite = this.nodes.has(id);
+    if (!isOverwrite) {
+      throw new NodeDoesntExistError(id);
+    }
+    this.nodes.set(id, node);
+    this.emit("node-replaced", id);
+  }
+  upsert(node) {
+    const id = this.nodeIdentity(node);
+    const isOverwrite = this.nodes.has(id);
+    this.nodes.set(id, node);
+    if (!isOverwrite) {
+      this.adjacency.map((adj) => adj.push(null));
+      this.adjacency.push(new Array(this.adjacency.length + 1).fill(null));
+      this.emit("node-added", id);
+    } else {
+      this.emit("node-replaced", id);
+    }
+    return id;
+  }
+  addEdge(node1Identity, node2Identity, edge) {
+    if (edge === undefined) {
+      edge = true;
+    }
+    const node1Exists = this.nodes.has(node1Identity);
+    const node2Exists = this.nodes.has(node2Identity);
+    if (!node1Exists) {
+      throw new NodeDoesntExistError(node1Identity);
+    }
+    if (!node2Exists) {
+      throw new NodeDoesntExistError(node2Identity);
+    }
+    const node1Index = Array.from(this.nodes.keys()).indexOf(node1Identity);
+    const node2Index = Array.from(this.nodes.keys()).indexOf(node2Identity);
+    if (this.adjacency[node1Index][node2Index] === null) {
+      this.adjacency[node1Index][node2Index] = [edge];
+    } else {
+      if (!this.adjacency[node1Index][node2Index].includes(edge)) {
+        this.adjacency[node1Index][node2Index].push(edge);
+      }
+    }
+    const id = this.edgeIdentity(edge, node1Identity, node2Identity);
+    this.emit("edge-added", id);
+    return id;
+  }
+  getNodes(compareFunc) {
+    const temp = Array.from(this.nodes.values());
+    if (compareFunc !== undefined) {
+      return temp.sort(compareFunc);
+    }
+    return temp;
+  }
+  getNode(nodeIdentity) {
+    return this.nodes.get(nodeIdentity);
+  }
+  hasNode(nodeIdentity) {
+    return this.nodes.has(nodeIdentity);
+  }
+  getEdges() {
+    const toReturn = [];
+    const nodeKeys = Array.from(this.nodes.keys());
+    this.adjacency.forEach((row, rowIndex) => {
+      const node1Identity = nodeKeys[rowIndex];
+      if (node1Identity != null) {
+        row.forEach((edges, colIndex) => {
+          if (edges !== null) {
+            const node2Identity = nodeKeys[colIndex];
+            if (node2Identity != null) {
+              for (const edge of edges) {
+                toReturn.push([node1Identity, node2Identity, edge]);
+              }
+            }
+          }
+        });
+      }
+    });
+    return toReturn;
+  }
+  outEdges(node1Identity) {
+    const nodeKeys = Array.from(this.nodes.keys());
+    const nodeIndex = nodeKeys.indexOf(node1Identity);
+    const toReturn = [];
+    this.adjacency[nodeIndex].forEach((edges, colIndex) => {
+      if (edges !== null) {
+        const node2Identity = nodeKeys[colIndex];
+        if (node2Identity != null) {
+          for (const edge of edges) {
+            toReturn.push([node1Identity, node2Identity, edge]);
+          }
+        }
+      }
+    });
+    return toReturn;
+  }
+  inEdges(node2Identity) {
+    const nodeKeys = Array.from(this.nodes.keys());
+    const node2Index = nodeKeys.indexOf(node2Identity);
+    const toReturn = [];
+    this.adjacency.forEach((row, rowIndex) => {
+      const node1Identity = nodeKeys[rowIndex];
+      const edges = row[node2Index];
+      if (edges !== null) {
+        for (const edge of edges) {
+          toReturn.push([node1Identity, node2Identity, edge]);
+        }
+      }
+    });
+    return toReturn;
+  }
+  nodeEdges(nodeIdentity) {
+    return [...this.outEdges(nodeIdentity), ...this.inEdges(nodeIdentity)];
+  }
+  removeEdge(node1Identity, node2Identity, edgeIdentity) {
+    const node1Exists = this.nodes.has(node1Identity);
+    const node2Exists = this.nodes.has(node2Identity);
+    if (!node1Exists) {
+      throw new NodeDoesntExistError(node1Identity);
+    }
+    if (!node2Exists) {
+      throw new NodeDoesntExistError(node2Identity);
+    }
+    const node1Index = Array.from(this.nodes.keys()).indexOf(node1Identity);
+    const node2Index = Array.from(this.nodes.keys()).indexOf(node2Identity);
+    if (edgeIdentity === undefined) {
+      this.adjacency[node1Index][node2Index] = null;
+    } else {
+      for (const row of this.adjacency) {
+        for (const edgelist of row) {
+          if (edgelist !== null) {
+            for (let edgeIndex = 0;edgeIndex < edgelist.length; edgeIndex++) {
+              if (this.edgeIdentity(edgelist[edgeIndex], node1Identity, node2Identity) === edgeIdentity) {
+                edgelist.splice(edgeIndex, 1);
+              }
+            }
+          }
+        }
+      }
+    }
+    this.emit("edge-removed", edgeIdentity);
+  }
+  remove(nodeIdentity) {
+    if (!this.nodes.has(nodeIdentity)) {
+      throw new NodeDoesntExistError(nodeIdentity);
+    }
+    this.nodes.delete(nodeIdentity);
+    const nodeIndex = Array.from(this.nodes.keys()).indexOf(nodeIdentity);
+    this.adjacency.splice(nodeIndex, 1);
+    this.adjacency.forEach((row) => row.splice(nodeIndex, 1));
+    this.emit("node-removed", nodeIdentity);
+  }
+  removeNode(nodeIdentity) {
+    return this.remove(nodeIdentity);
+  }
+  addNode(node) {
+    return this.insert(node);
+  }
+  addNodes(nodes) {
+    return nodes.map((node) => this.insert(node));
+  }
+  addEdges(edges) {
+    return edges.map(([node1Identity, node2Identity, edge]) => this.addEdge(node1Identity, node2Identity, edge));
+  }
+}
+
+// src/graph/directedGraph.ts
+class DirectedGraph extends Graph {
+  hasCycle = false;
+  isAcyclic() {
+    if (this.hasCycle !== undefined) {
+      return !this.hasCycle;
+    }
+    const nodeIndices = Array.from(this.nodes.keys());
+    const nodeInDegrees = new Map(Array.from(this.nodes.keys()).map((n) => [n, this.indegreeOfNode(n)]));
+    const toSearch = Array.from(nodeInDegrees).filter((pair) => pair[1] === 0);
+    let visitedNodes = 0;
+    while (toSearch.length > 0) {
+      const cur = toSearch.pop();
+      if (cur === undefined) {
+        continue;
+      }
+      const nodeIndex = nodeIndices.indexOf(cur[0]);
+      this.adjacency[nodeIndex].forEach((hasAdj, index) => {
+        if (hasAdj !== null) {
+          const currentInDegree = nodeInDegrees.get(nodeIndices[index]);
+          if (currentInDegree !== undefined) {
+            nodeInDegrees.set(nodeIndices[index], currentInDegree - 1);
+            if (currentInDegree - 1 === 0) {
+              toSearch.push([nodeIndices[index], currentInDegree - 1]);
+            }
+          }
+        }
+      });
+      visitedNodes++;
+    }
+    this.hasCycle = !(visitedNodes === this.nodes.size);
+    return visitedNodes === this.nodes.size;
+  }
+  indegreeOfNode(nodeID) {
+    const nodeIdentities = Array.from(this.nodes.keys());
+    const indexOfNode = nodeIdentities.indexOf(nodeID);
+    if (indexOfNode === -1) {
+      throw new NodeDoesntExistError(nodeID);
+    }
+    return this.adjacency.reduce((carry, row) => {
+      return carry + (row[indexOfNode] == null ? 0 : 1);
+    }, 0);
+  }
+  addEdge(sourceNodeIdentity, targetNodeIdentity, edge, skipUpdatingCyclicality = false) {
+    if (edge === undefined) {
+      edge = true;
+    }
+    if (this.hasCycle === false && !skipUpdatingCyclicality) {
+      this.hasCycle = this.wouldAddingEdgeCreateCycle(sourceNodeIdentity, targetNodeIdentity);
+    } else if (skipUpdatingCyclicality) {
+      this.hasCycle = undefined;
+    }
+    return super.addEdge(sourceNodeIdentity, targetNodeIdentity, edge);
+  }
+  canReachFrom(startNode, endNode) {
+    const nodeIdentities = Array.from(this.nodes.keys());
+    const startNodeIndex = nodeIdentities.indexOf(startNode);
+    const endNodeIndex = nodeIdentities.indexOf(endNode);
+    if (this.adjacency[startNodeIndex][endNodeIndex] != null) {
+      return true;
+    }
+    return this.adjacency[startNodeIndex].reduce((carry, edge, index) => {
+      if (carry || edge === null) {
+        return carry;
+      }
+      return this.canReachFrom(nodeIdentities[index], endNode);
+    }, false);
+  }
+  wouldAddingEdgeCreateCycle(sourceNodeIdentity, targetNodeIdentity) {
+    return this.hasCycle || sourceNodeIdentity === targetNodeIdentity || this.canReachFrom(targetNodeIdentity, sourceNodeIdentity);
+  }
+  getSubGraphStartingFrom(startNodeIdentity) {
+    const nodeIndices = Array.from(this.nodes.keys());
+    const initalNode = this.nodes.get(startNodeIdentity);
+    if (initalNode == null) {
+      throw new NodeDoesntExistError(startNodeIdentity);
+    }
+    const recur = (startNodeIdentity2, nodesToInclude) => {
+      let toReturn = [...nodesToInclude];
+      const nodeIndex = nodeIndices.indexOf(startNodeIdentity2);
+      this.adjacency[nodeIndex].forEach((hasAdj, index) => {
+        if (hasAdj !== null && nodesToInclude.find((n) => this.nodeIdentity(n) === nodeIndices[index]) == null) {
+          const newNode = this.nodes.get(nodeIndices[index]);
+          if (newNode != null) {
+            toReturn = [...recur(nodeIndices[index], toReturn), newNode];
+          }
+        }
+      });
+      return toReturn;
+    };
+    const newGraph = new DirectedGraph(this.nodeIdentity, this.edgeIdentity);
+    const nodeList = recur(startNodeIdentity, [initalNode]);
+    const includeIdents = nodeList.map((t) => this.nodeIdentity(t));
+    Array.from(this.nodes.values()).forEach((n) => {
+      if (includeIdents.includes(this.nodeIdentity(n))) {
+        newGraph.insert(n);
+      }
+    });
+    newGraph.adjacency = this.subAdj(nodeList);
+    return newGraph;
+  }
+  subAdj(include) {
+    const includeIdents = include.map((t) => this.nodeIdentity(t));
+    const nodeIndices = Array.from(this.nodes.keys());
+    return this.adjacency.reduce((carry, cur, index) => {
+      if (includeIdents.includes(nodeIndices[index])) {
+        return [...carry, cur.filter((_, index2) => includeIdents.includes(nodeIndices[index2]))];
+      } else {
+        return carry;
+      }
+    }, []);
+  }
+  getEdges() {
+    return super.getEdges();
+  }
+  removeEdge(sourceNodeIdentity, targetNodeIdentity, edgeIdentity) {
+    super.removeEdge(sourceNodeIdentity, targetNodeIdentity, edgeIdentity);
+    this.hasCycle = undefined;
+  }
+  remove(nodeIdentity) {
+    super.remove(nodeIdentity);
+    this.hasCycle = undefined;
+  }
+  addEdges(edges) {
+    return super.addEdges(edges);
+  }
+}
+
+// src/graph/directedAcyclicGraph.ts
+class DirectedAcyclicGraph extends DirectedGraph {
+  _topologicallySortedNodes;
+  static fromDirectedGraph(graph) {
+    if (!graph.isAcyclic()) {
+      throw new CycleError("Can't convert that graph to a DAG because it contains a cycle");
+    }
+    const toRet = new DirectedAcyclicGraph(graph.nodeIdentity, graph.edgeIdentity);
+    toRet.nodes = graph.nodes;
+    toRet.adjacency = graph.adjacency;
+    return toRet;
+  }
+  addEdge(sourceNodeIdentity, targetNodeIdentity, edge) {
+    if (edge === undefined) {
+      edge = true;
+    }
+    if (this.wouldAddingEdgeCreateCycle(sourceNodeIdentity, targetNodeIdentity)) {
+      throw new CycleError(`Can't add edge from ${String(sourceNodeIdentity)} to ${String(targetNodeIdentity)} it would create a cycle`);
+    }
+    this._topologicallySortedNodes = undefined;
+    return super.addEdge(sourceNodeIdentity, targetNodeIdentity, edge, true);
+  }
+  insert(node) {
+    if (this._topologicallySortedNodes !== undefined) {
+      this._topologicallySortedNodes = [node, ...this._topologicallySortedNodes];
+    }
+    return super.insert(node);
+  }
+  topologicallySortedNodes() {
+    if (this._topologicallySortedNodes !== undefined) {
+      return this._topologicallySortedNodes;
+    }
+    const nodeIndices = Array.from(this.nodes.keys());
+    const nodeInDegrees = new Map(Array.from(this.nodes.keys()).map((n) => [n, this.indegreeOfNode(n)]));
+    const adjCopy = this.adjacency.map((a) => [...a]);
+    const toSearch = Array.from(nodeInDegrees).filter((pair) => pair[1] === 0);
+    if (toSearch.length === this.nodes.size) {
+      const arrayOfNodes = Array.from(this.nodes.values());
+      this._topologicallySortedNodes = arrayOfNodes;
+      return arrayOfNodes;
+    }
+    const toReturn = [];
+    while (toSearch.length > 0) {
+      const n = toSearch.pop();
+      if (n === undefined) {
+        throw new Error("Unexpected empty array");
+      }
+      const curNode = this.nodes.get(n[0]);
+      if (curNode == null) {
+        throw new Error("This should never happen");
+      }
+      toReturn.push(curNode);
+      adjCopy[nodeIndices.indexOf(n[0])]?.forEach((edge, index) => {
+        if (edge !== null) {
+          adjCopy[nodeIndices.indexOf(n[0])][index] = null;
+          const target = nodeInDegrees.get(nodeIndices[index]);
+          if (target !== undefined) {
+            nodeInDegrees.set(nodeIndices[index], target - 1);
+            if (target - 1 === 0) {
+              toSearch.push([nodeIndices[index], 0]);
+            }
+          } else {
+            throw new Error("This should never happen");
+          }
+        }
+      });
+    }
+    this._topologicallySortedNodes = toReturn;
+    return toReturn;
+  }
+  getSubGraphStartingFrom(startNodeIdentity) {
+    return DirectedAcyclicGraph.fromDirectedGraph(super.getSubGraphStartingFrom(startNodeIdentity));
+  }
+  removeEdge(sourceNodeIdentity, targetNodeIdentity, edgeIdentity) {
+    super.removeEdge(sourceNodeIdentity, targetNodeIdentity, edgeIdentity);
+    this._topologicallySortedNodes = undefined;
+  }
+  remove(nodeIdentity) {
+    super.remove(nodeIdentity);
+    this._topologicallySortedNodes = undefined;
+  }
+}
+export {
+  NodeDoesntExistError,
+  NodeAlreadyExistsError,
+  Graph,
+  DirectedGraph,
+  DirectedAcyclicGraph,
+  CycleError
+};
+
+//# debugId=1E5D727E61CDDE0164756E2164756E21