@hpcc-js/util 2.45.0 → 2.46.1

package/lib-es6/graph2.js

@@ -1,604 +1,604 @@
-import { __extends, __spreadArray } from "tslib";
-import { compare2 } from "./array";
-var GraphItem = /** @class */ (function () {
-    function GraphItem(g, _) {
-        this._graph = g;
-        this._ = _;
-    }
-    GraphItem.prototype.id = function () {
-        return this._graph.id(this._);
-    };
-    return GraphItem;
-}());
-var ChildGraphItem = /** @class */ (function (_super) {
-    __extends(ChildGraphItem, _super);
-    function ChildGraphItem(g, _) {
-        return _super.call(this, g, _) || this;
-    }
-    ChildGraphItem.prototype.clearParent = function () {
-        if (this._parent) {
-            this._parent.removeChild(this);
-            delete this._parent;
-        }
-        return this;
-    };
-    ChildGraphItem.prototype.parent = function (_) {
-        if (arguments.length === 0)
-            return this._parent;
-        if (this._parent !== _) {
-            if (this._parent) {
-                this._parent.removeChild(this);
-            }
-            this._parent = _;
-            if (this._parent) {
-                this._parent.addChild(this);
-            }
-        }
-        return this;
-    };
-    return ChildGraphItem;
-}(GraphItem));
-var Subgraph = /** @class */ (function (_super) {
-    __extends(Subgraph, _super);
-    function Subgraph(g, _) {
-        var _this = _super.call(this, g, _) || this;
-        _this._children = [];
-        return _this;
-    }
-    Subgraph.prototype.children = function () {
-        return this._children;
-    };
-    Subgraph.prototype.addChild = function (_) {
-        this._children.push(_);
-    };
-    Subgraph.prototype.removeChild = function (_) {
-        this._children = this._children.filter(function (row) { return row.id !== _.id; });
-    };
-    return Subgraph;
-}(ChildGraphItem));
-var Vertex = /** @class */ (function (_super) {
-    __extends(Vertex, _super);
-    function Vertex(g, _) {
-        var _this = _super.call(this, g, _) || this;
-        _this._inEdges = [];
-        _this._outEdges = [];
-        return _this;
-    }
-    Vertex.prototype.edges = function () {
-        return __spreadArray(__spreadArray([], this._inEdges), this._outEdges);
-    };
-    Vertex.prototype.edgeCount = function () {
-        return this._outEdges.length + this._inEdges.length;
-    };
-    Vertex.prototype.inEdges = function () {
-        return this._inEdges;
-    };
-    Vertex.prototype.addInEdge = function (e) {
-        this._inEdges.push(e);
-    };
-    Vertex.prototype.removeInEdge = function (id) {
-        this._inEdges = this._inEdges.filter(function (e) { return e._.id !== id; });
-    };
-    Vertex.prototype.outEdges = function () {
-        return this._outEdges;
-    };
-    Vertex.prototype.addOutEdge = function (e) {
-        this._outEdges.push(e);
-    };
-    Vertex.prototype.removeOutEdge = function (id) {
-        this._outEdges = this._outEdges.filter(function (e) { return e._.id !== id; });
-    };
-    return Vertex;
-}(ChildGraphItem));
-var Edge = /** @class */ (function (_super) {
-    __extends(Edge, _super);
-    function Edge(g, _, source, target) {
-        var _this = _super.call(this, g, _) || this;
-        _this._source = source;
-        _this._target = target;
-        return _this;
-    }
-    return Edge;
-}(ChildGraphItem));
-var Graph2 = /** @class */ (function () {
-    function Graph2(directed) {
-        if (directed === void 0) { directed = true; }
-        this._subgraphMap = {};
-        this._vertexMap = {};
-        this._edgeMap = {};
-        this._idFunc = function (_) { return typeof _.id === "function" ? _.id() : _.id; };
-        this._sourceFunc = function (_) { return typeof _.source === "function" ? _.source() : _.source; };
-        this._targetFunc = function (_) { return typeof _.target === "function" ? _.target() : _.target; };
-        this._updateFunc = function (before, after) { return after; };
-        this._directed = directed;
-    }
-    Graph2.prototype.clear = function () {
-        this._subgraphMap = {};
-        this._vertexMap = {};
-        this._edgeMap = {};
-        return this;
-    };
-    Graph2.prototype.clearParents = function () {
-        for (var key in this._subgraphMap) {
-            this._subgraphMap[key].clearParent();
-        }
-        for (var key in this._vertexMap) {
-            this._vertexMap[key].clearParent();
-        }
-        return this;
-    };
-    Graph2.prototype.isDirected = function () {
-        return this._directed;
-    };
-    Graph2.prototype.idFunc = function (_) {
-        this._idFunc = _;
-        return this;
-    };
-    Graph2.prototype.sourceFunc = function (_) {
-        this._sourceFunc = _;
-        return this;
-    };
-    Graph2.prototype.targetFunc = function (_) {
-        this._targetFunc = _;
-        return this;
-    };
-    Graph2.prototype.updateFunc = function (_) {
-        this._updateFunc = _;
-        return this;
-    };
-    Graph2.prototype.id = function (_) {
-        return this._idFunc(_);
-    };
-    Graph2.prototype.type = function (id) {
-        if (this.subgraphExists(id))
-            return "S";
-        if (this.vertexExists(id))
-            return "V";
-        if (this.edgeExists(id))
-            return "E";
-        return "";
-    };
-    Graph2.prototype.isSubgraph = function (_) {
-        return this.subgraphExists(this.id(_));
-    };
-    Graph2.prototype.isVertex = function (_) {
-        return this.vertexExists(this.id(_));
-    };
-    Graph2.prototype.isEdge = function (_) {
-        return this.edgeExists(this.id(_));
-    };
-    Graph2.prototype.allItems = function () {
-        return __spreadArray(__spreadArray(__spreadArray([], this.allSubgraphs()), this.allVertices()), this.allEdges());
-    };
-    Graph2.prototype.item = function (id) {
-        if (this.subgraphExists(id))
-            return this.subgraph(id);
-        if (this.vertexExists(id))
-            return this.vertex(id);
-        if (this.edgeExists(id))
-            return this.edge(id);
-        return undefined;
-    };
-    Graph2.prototype.itemExists = function (id) {
-        return this.edgeExists(id) || this.vertexExists(id) || this.subgraphExists(id);
-    };
-    // Subgraphs  ---
-    Graph2.prototype.allSubgraphs = function () {
-        var retVal = [];
-        for (var key in this._subgraphMap) {
-            retVal.push(this._subgraphMap[key]._);
-        }
-        return retVal;
-    };
-    Graph2.prototype.subgraphs = function () {
-        var retVal = [];
-        for (var key in this._subgraphMap) {
-            if (this._subgraphMap[key].parent() === undefined) {
-                retVal.push(this._subgraphMap[key]._);
-            }
-        }
-        return retVal;
-    };
-    Graph2.prototype.subgraphExists = function (id) {
-        return !!this._subgraphMap[id];
-    };
-    Graph2.prototype.subgraph = function (id) {
-        return this._subgraphMap[id]._;
-    };
-    Graph2.prototype.subgraphSubgraphs = function (id) {
-        var _this = this;
-        return this._subgraphMap[id].children().filter(function (child) { return _this.isSubgraph(child._); }).map(function (child) { return child._; });
-    };
-    Graph2.prototype.subgraphVertices = function (id) {
-        var _this = this;
-        return this._subgraphMap[id].children().filter(function (child) { return _this.isVertex(child._); }).map(function (child) { return child._; });
-    };
-    Graph2.prototype.subgraphEdges = function (id) {
-        var _this = this;
-        return this._subgraphMap[id].children().filter(function (child) { return _this.isEdge(child._); }).map(function (child) { return child._; });
-    };
-    Graph2.prototype.addSubgraph = function (s, parent) {
-        var s_id = this._idFunc(s);
-        if (this._subgraphMap[s_id])
-            throw new Error("Subgraph '" + s_id + "' already exists.");
-        var subgraph = new Subgraph(this, s);
-        if (parent) {
-            var p_id = this._idFunc(parent);
-            if (!this._subgraphMap[p_id])
-                throw new Error("Subgraph '" + p_id + "' does not exist.");
-            subgraph.parent(this._subgraphMap[p_id]);
-        }
-        this._subgraphMap[s_id] = subgraph;
-        return this;
-    };
-    Graph2.prototype.mergeSubgraphs = function (_subgraphs) {
-        var _this = this;
-        if (_subgraphs === void 0) { _subgraphs = []; }
-        var sgDiff = compare2(this.allSubgraphs(), _subgraphs, function (sg) { return _this._idFunc(sg); }, this._updateFunc);
-        sgDiff.exit.forEach(function (sg) { return _this.removeSubgraph(_this._idFunc(sg)); });
-        sgDiff.enter.forEach(function (sg) { return _this.addSubgraph(sg); });
-        sgDiff.update.forEach(function (sg) { return _this.updateSubgraph(sg); });
-        return this;
-    };
-    Graph2.prototype.updateSubgraph = function (sg) {
-        var sg_id = this._idFunc(sg);
-        var subgraph = this._subgraphMap[sg_id];
-        if (!subgraph)
-            throw new Error("Subgraph '" + sg_id + "' does not exist.");
-        subgraph._ = sg;
-        return this;
-    };
-    Graph2.prototype.removeSubgraph = function (id, promoteChildren) {
-        var _this = this;
-        if (promoteChildren === void 0) { promoteChildren = true; }
-        var sg = this._subgraphMap[id];
-        if (!sg)
-            throw new Error("Subgraph '" + id + "' does not exist.");
-        sg.children().forEach(function (child) {
-            if (promoteChildren) {
-                child.parent(sg.parent());
-            }
-            else {
-                if (child instanceof Subgraph) {
-                    _this.removeSubgraph(child.id());
-                }
-                else {
-                    _this.removeVertex(child.id());
-                }
-            }
-        });
-        delete this._subgraphMap[id];
-        return this;
-    };
-    Graph2.prototype.subgraphParent = function (id, parentID) {
-        var item = this._subgraphMap[id];
-        if (!item)
-            throw new Error("Subgraph '" + id + "' does not exist.");
-        if (parentID === void 0) {
-            var parent_1 = item.parent();
-            return parent_1 ? parent_1._ : undefined;
-        }
-        var parent = this._subgraphMap[parentID];
-        if (!parent)
-            throw new Error("Vertex parent '" + parent + "' does not exist.");
-        item.parent(parent);
-        return this;
-    };
-    // Vertices  ---
-    Graph2.prototype.allVertices = function () {
-        var retVal = [];
-        for (var key in this._vertexMap) {
-            retVal.push(this._vertexMap[key]._);
-        }
-        return retVal;
-    };
-    Graph2.prototype.vertices = function () {
-        var retVal = [];
-        for (var key in this._vertexMap) {
-            if (this._vertexMap[key].parent() === undefined) {
-                retVal.push(this._vertexMap[key]._);
-            }
-        }
-        return retVal;
-    };
-    Graph2.prototype.vertexExists = function (id) {
-        return !!this._vertexMap[id];
-    };
-    Graph2.prototype.vertex = function (id) {
-        return this._vertexMap[id]._;
-    };
-    Graph2.prototype.allEdges = function () {
-        var retVal = [];
-        for (var key in this._edgeMap) {
-            retVal.push(this._edgeMap[key]._);
-        }
-        return retVal;
-    };
-    Graph2.prototype.edges = function () {
-        var retVal = [];
-        for (var key in this._edgeMap) {
-            if (this._edgeMap[key].parent() === undefined) {
-                retVal.push(this._edgeMap[key]._);
-            }
-        }
-        return retVal;
-    };
-    Graph2.prototype.vertexEdges = function (vertexID) {
-        return this._vertexMap[vertexID].edges().map(function (e) { return e._; });
-    };
-    Graph2.prototype.inEdges = function (vertexID) {
-        return this._vertexMap[vertexID].inEdges().map(function (e) { return e._; });
-    };
-    Graph2.prototype.outEdges = function (vertexID) {
-        return this._vertexMap[vertexID].outEdges().map(function (e) { return e._; });
-    };
-    Graph2.prototype._neighbors = function (id) {
-        return __spreadArray(__spreadArray([], this._vertexMap[id].outEdges().map(function (e) { return e._target; })), this._vertexMap[id].inEdges().map(function (e) { return e._source; }));
-    };
-    Graph2.prototype.neighbors = function (id) {
-        return this._neighbors(id).map(function (n) { return n._; });
-    };
-    Graph2.prototype.singleNeighbors = function (id) {
-        return this._neighbors(id).filter(function (n) { return n.edgeCount() === 1; }).map(function (n) { return n._; });
-    };
-    Graph2.prototype.addVertex = function (v, parent) {
-        var v_id = this._idFunc(v);
-        if (this._vertexMap[v_id])
-            throw new Error("Vertex '" + v_id + "' already exists.");
-        var vertex = new Vertex(this, v);
-        if (parent) {
-            var p_id = this._idFunc(parent);
-            if (!this.subgraphExists(p_id))
-                throw new Error("Subgraph '" + p_id + "' does not exist.");
-            vertex.parent(this._subgraphMap[p_id]);
-        }
-        this._vertexMap[v_id] = vertex;
-        return this;
-    };
-    Graph2.prototype.mergeVertices = function (_vertices) {
-        var _this = this;
-        var vDiff = compare2(this.allVertices(), _vertices, function (v) { return _this._idFunc(v); }, this._updateFunc);
-        vDiff.exit.forEach(function (v) { return _this.removeVertex(_this._idFunc(v)); });
-        vDiff.enter.forEach(function (v) { return _this.addVertex(v); });
-        vDiff.update.forEach(function (v) { return _this.updateVertex(v); });
-        return this;
-    };
-    Graph2.prototype.updateVertex = function (v) {
-        var v_id = this._idFunc(v);
-        var vertex = this._vertexMap[v_id];
-        if (!vertex)
-            throw new Error("Vertex '" + v_id + "' does not exist.");
-        vertex._ = v;
-        return this;
-    };
-    Graph2.prototype.removeVertex = function (id) {
-        var _this = this;
-        var v = this._vertexMap[id];
-        if (!v)
-            throw new Error("Vertex '" + id + "' does not exist.");
-        v.edges().forEach(function (e) {
-            _this.removeEdge(e.id());
-        });
-        delete this._vertexMap[id];
-        return this;
-    };
-    Graph2.prototype.vertexParent = function (id, parentID) {
-        var item = this._vertexMap[id];
-        if (!item)
-            throw new Error("Vertex '" + id + "' does not exist.");
-        if (parentID === void 0) {
-            var parent_2 = item.parent();
-            return parent_2 ? parent_2._ : undefined;
-        }
-        var parent = this._subgraphMap[parentID];
-        if (!parent)
-            throw new Error("Vertex parent '" + parent + "' does not exist.");
-        item.parent(parent);
-        return this;
-    };
-    // Edges  ---
-    Graph2.prototype.edgeExists = function (id) {
-        return !!this._edgeMap[id];
-    };
-    Graph2.prototype.edge = function (id) {
-        return this._edgeMap[id]._;
-    };
-    Graph2.prototype.addEdge = function (e, parent) {
-        var e_id = this._idFunc(e);
-        var e_source = this._sourceFunc(e);
-        var e_target = this._targetFunc(e);
-        if (this._edgeMap[e_id])
-            throw new Error("Edge '" + e_id + "' already exists.");
-        if (!this.vertexExists(e_source))
-            throw new Error("Edge Source '" + e_source + "' does not exist.");
-        if (!this.vertexExists(e_target))
-            throw new Error("Edge Target '" + e_target + "' does not exist.");
-        var edge = new Edge(this, e, this._vertexMap[e_source], this._vertexMap[e_target]);
-        if (parent) {
-            var p_id = this._idFunc(parent);
-            if (!this.subgraphExists(p_id))
-                throw new Error("Subgraph '" + p_id + "' does not exist.");
-            edge.parent(this._subgraphMap[p_id]);
-        }
-        this._edgeMap[e_id] = edge;
-        this._vertexMap[e_source].addOutEdge(edge);
-        this._vertexMap[e_target].addInEdge(edge);
-        return this;
-    };
-    Graph2.prototype.mergeEdges = function (_edges) {
-        var _this = this;
-        var eDiff = compare2(this.allEdges(), _edges, function (e) { return _this._idFunc(e); }, this._updateFunc);
-        eDiff.exit.forEach(function (e) { return _this.removeEdge(_this._idFunc(e)); });
-        eDiff.enter.forEach(function (e) { return _this.addEdge(e); });
-        eDiff.update.forEach(function (e) { return _this.updateEdge(e); });
-        return this;
-    };
-    Graph2.prototype.updateEdge = function (e) {
-        var e_id = this._idFunc(e);
-        var edge = this._edgeMap[e_id];
-        if (!edge)
-            throw new Error("Edge '" + e_id + "' does not exist.");
-        edge._ = e;
-        return this;
-    };
-    Graph2.prototype.removeEdge = function (id) {
-        var e = this._edgeMap[id];
-        if (!e)
-            throw new Error("Edge '" + id + "' does not exist.");
-        var e_sourceID = this._idFunc(e._source._);
-        if (!this.vertexExists(e_sourceID))
-            throw new Error("Edge Source'" + e_sourceID + "' does not exist.");
-        this._vertexMap[e_sourceID].removeOutEdge(id);
-        var e_targetID = this._idFunc(e._target._);
-        if (!this.vertexExists(e_targetID))
-            throw new Error("Edge Target'" + e_targetID + "' does not exist.");
-        this._vertexMap[e_targetID].removeInEdge(id);
-        delete this._edgeMap[id];
-        return this;
-    };
-    Graph2.prototype._hwalk = function (item, formatter) {
-        var _this = this;
-        if (item instanceof Subgraph) {
-            return formatter("subgraph", item._, item.children().map(function (child) { return _this._hwalk(child, formatter); }));
-        }
-        else {
-            return formatter("vertex", item._);
-        }
-    };
-    Graph2.prototype.hierarchy = function (formatter) {
-        var retVal = [];
-        for (var id in this._subgraphMap) {
-            var sg = this._subgraphMap[id];
-            if (sg.parent() === undefined) {
-                retVal.push(this._hwalk(sg, formatter));
-            }
-        }
-        for (var id in this._vertexMap) {
-            var v = this._vertexMap[id];
-            if (v.parent() === undefined) {
-                retVal.push(this._hwalk(v, formatter));
-            }
-        }
-        return retVal;
-    };
-    Graph2.prototype.dijkstra = function (source, target) {
-        var edges = this.allEdges();
-        var Q = new Set();
-        var prev = {};
-        var dist = {};
-        var adj = {};
-        function vertex_with_min_dist(Q, dist) {
-            var min_distance = Infinity;
-            var u = null;
-            Q.forEach(function (v) {
-                if (dist[v] < min_distance) {
-                    min_distance = dist[v];
-                    u = v;
-                }
-            });
-            return u;
-        }
-        for (var i = 0; i < edges.length; i++) {
-            var v1 = this._sourceFunc(edges[i]);
-            var v2 = this._targetFunc(edges[i]);
-            var len_1 = 1;
-            Q.add(v1);
-            Q.add(v2);
-            dist[v1] = Infinity;
-            dist[v2] = Infinity;
-            if (adj[v1] === undefined)
-                adj[v1] = {};
-            if (adj[v2] === undefined)
-                adj[v2] = {};
-            adj[v1][v2] = len_1;
-            adj[v2][v1] = len_1;
-        }
-        dist[source] = 0;
-        while (Q.size) {
-            var u_1 = vertex_with_min_dist(Q, dist);
-            if (u_1 === null)
-                break;
-            var neighbors = Object.keys(adj[u_1]).filter(function (v) { return Q.has(v); }); // Neighbor still in Q
-            Q.delete(u_1);
-            if (u_1 === target)
-                break; // Break when the target has been found
-            for (var _i = 0, neighbors_1 = neighbors; _i < neighbors_1.length; _i++) {
-                var v = neighbors_1[_i];
-                var alt = dist[u_1] + adj[u_1][v];
-                if (alt < dist[v]) {
-                    dist[v] = alt;
-                    prev[v] = u_1;
-                }
-            }
-        }
-        var u = target;
-        var ids = [u];
-        var len = 0;
-        while (prev[u] !== undefined) {
-            ids.unshift(prev[u]);
-            len += adj[u][prev[u]];
-            u = prev[u];
-        }
-        return { ids: ids, len: len };
-    };
-    Graph2.prototype.sort = function (v_id) {
-        var retVal = [];
-        var visited = {};
-        var visit = function (vertex, ancestors) {
-            if (ancestors === void 0) { ancestors = []; }
-            var v_id = vertex.id();
-            if (visited[v_id])
-                return;
-            visited[v_id] = true;
-            ancestors.push(vertex);
-            vertex.outEdges().forEach(function (e) {
-                if (ancestors.indexOf(e._target) < 0) {
-                    visit(e._target, __spreadArray([], ancestors));
-                }
-            });
-            retVal.unshift(vertex._);
-        };
-        if (v_id) {
-            visit(this._vertexMap[v_id]);
-        }
-        else {
-            for (var key in this._vertexMap) {
-                visit(this._vertexMap[key]);
-            }
-        }
-        return retVal;
-    };
-    return Graph2;
-}());
-export { Graph2 };
-var Set = /** @class */ (function () {
-    function Set() {
-        this._content = [];
-    }
-    Object.defineProperty(Set.prototype, "size", {
-        get: function () {
-            return this._content.length;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Set.prototype.has = function (_) {
-        return this._content.indexOf(_) >= 0;
-    };
-    Set.prototype.add = function (_) {
-        if (!this.has(_)) {
-            this._content.push(_);
-        }
-    };
-    Set.prototype.delete = function (_) {
-        var idx = this._content.indexOf(_);
-        if (idx >= 0) {
-            this._content.splice(idx, 1);
-        }
-    };
-    Set.prototype.forEach = function (_) {
-        this._content.forEach(_);
-    };
-    return Set;
-}());
+import { __extends, __spreadArray } from "tslib";
+import { compare2 } from "./array";
+var GraphItem = /** @class */ (function () {
+    function GraphItem(g, _) {
+        this._graph = g;
+        this._ = _;
+    }
+    GraphItem.prototype.id = function () {
+        return this._graph.id(this._);
+    };
+    return GraphItem;
+}());
+var ChildGraphItem = /** @class */ (function (_super) {
+    __extends(ChildGraphItem, _super);
+    function ChildGraphItem(g, _) {
+        return _super.call(this, g, _) || this;
+    }
+    ChildGraphItem.prototype.clearParent = function () {
+        if (this._parent) {
+            this._parent.removeChild(this);
+            delete this._parent;
+        }
+        return this;
+    };
+    ChildGraphItem.prototype.parent = function (_) {
+        if (arguments.length === 0)
+            return this._parent;
+        if (this._parent !== _) {
+            if (this._parent) {
+                this._parent.removeChild(this);
+            }
+            this._parent = _;
+            if (this._parent) {
+                this._parent.addChild(this);
+            }
+        }
+        return this;
+    };
+    return ChildGraphItem;
+}(GraphItem));
+var Subgraph = /** @class */ (function (_super) {
+    __extends(Subgraph, _super);
+    function Subgraph(g, _) {
+        var _this = _super.call(this, g, _) || this;
+        _this._children = [];
+        return _this;
+    }
+    Subgraph.prototype.children = function () {
+        return this._children;
+    };
+    Subgraph.prototype.addChild = function (_) {
+        this._children.push(_);
+    };
+    Subgraph.prototype.removeChild = function (_) {
+        this._children = this._children.filter(function (row) { return row.id !== _.id; });
+    };
+    return Subgraph;
+}(ChildGraphItem));
+var Vertex = /** @class */ (function (_super) {
+    __extends(Vertex, _super);
+    function Vertex(g, _) {
+        var _this = _super.call(this, g, _) || this;
+        _this._inEdges = [];
+        _this._outEdges = [];
+        return _this;
+    }
+    Vertex.prototype.edges = function () {
+        return __spreadArray(__spreadArray([], this._inEdges, true), this._outEdges, true);
+    };
+    Vertex.prototype.edgeCount = function () {
+        return this._outEdges.length + this._inEdges.length;
+    };
+    Vertex.prototype.inEdges = function () {
+        return this._inEdges;
+    };
+    Vertex.prototype.addInEdge = function (e) {
+        this._inEdges.push(e);
+    };
+    Vertex.prototype.removeInEdge = function (id) {
+        this._inEdges = this._inEdges.filter(function (e) { return e._.id !== id; });
+    };
+    Vertex.prototype.outEdges = function () {
+        return this._outEdges;
+    };
+    Vertex.prototype.addOutEdge = function (e) {
+        this._outEdges.push(e);
+    };
+    Vertex.prototype.removeOutEdge = function (id) {
+        this._outEdges = this._outEdges.filter(function (e) { return e._.id !== id; });
+    };
+    return Vertex;
+}(ChildGraphItem));
+var Edge = /** @class */ (function (_super) {
+    __extends(Edge, _super);
+    function Edge(g, _, source, target) {
+        var _this = _super.call(this, g, _) || this;
+        _this._source = source;
+        _this._target = target;
+        return _this;
+    }
+    return Edge;
+}(ChildGraphItem));
+var Graph2 = /** @class */ (function () {
+    function Graph2(directed) {
+        if (directed === void 0) { directed = true; }
+        this._subgraphMap = {};
+        this._vertexMap = {};
+        this._edgeMap = {};
+        this._idFunc = function (_) { return typeof _.id === "function" ? _.id() : _.id; };
+        this._sourceFunc = function (_) { return typeof _.source === "function" ? _.source() : _.source; };
+        this._targetFunc = function (_) { return typeof _.target === "function" ? _.target() : _.target; };
+        this._updateFunc = function (before, after) { return after; };
+        this._directed = directed;
+    }
+    Graph2.prototype.clear = function () {
+        this._subgraphMap = {};
+        this._vertexMap = {};
+        this._edgeMap = {};
+        return this;
+    };
+    Graph2.prototype.clearParents = function () {
+        for (var key in this._subgraphMap) {
+            this._subgraphMap[key].clearParent();
+        }
+        for (var key in this._vertexMap) {
+            this._vertexMap[key].clearParent();
+        }
+        return this;
+    };
+    Graph2.prototype.isDirected = function () {
+        return this._directed;
+    };
+    Graph2.prototype.idFunc = function (_) {
+        this._idFunc = _;
+        return this;
+    };
+    Graph2.prototype.sourceFunc = function (_) {
+        this._sourceFunc = _;
+        return this;
+    };
+    Graph2.prototype.targetFunc = function (_) {
+        this._targetFunc = _;
+        return this;
+    };
+    Graph2.prototype.updateFunc = function (_) {
+        this._updateFunc = _;
+        return this;
+    };
+    Graph2.prototype.id = function (_) {
+        return this._idFunc(_);
+    };
+    Graph2.prototype.type = function (id) {
+        if (this.subgraphExists(id))
+            return "S";
+        if (this.vertexExists(id))
+            return "V";
+        if (this.edgeExists(id))
+            return "E";
+        return "";
+    };
+    Graph2.prototype.isSubgraph = function (_) {
+        return this.subgraphExists(this.id(_));
+    };
+    Graph2.prototype.isVertex = function (_) {
+        return this.vertexExists(this.id(_));
+    };
+    Graph2.prototype.isEdge = function (_) {
+        return this.edgeExists(this.id(_));
+    };
+    Graph2.prototype.allItems = function () {
+        return __spreadArray(__spreadArray(__spreadArray([], this.allSubgraphs(), true), this.allVertices(), true), this.allEdges(), true);
+    };
+    Graph2.prototype.item = function (id) {
+        if (this.subgraphExists(id))
+            return this.subgraph(id);
+        if (this.vertexExists(id))
+            return this.vertex(id);
+        if (this.edgeExists(id))
+            return this.edge(id);
+        return undefined;
+    };
+    Graph2.prototype.itemExists = function (id) {
+        return this.edgeExists(id) || this.vertexExists(id) || this.subgraphExists(id);
+    };
+    // Subgraphs  ---
+    Graph2.prototype.allSubgraphs = function () {
+        var retVal = [];
+        for (var key in this._subgraphMap) {
+            retVal.push(this._subgraphMap[key]._);
+        }
+        return retVal;
+    };
+    Graph2.prototype.subgraphs = function () {
+        var retVal = [];
+        for (var key in this._subgraphMap) {
+            if (this._subgraphMap[key].parent() === undefined) {
+                retVal.push(this._subgraphMap[key]._);
+            }
+        }
+        return retVal;
+    };
+    Graph2.prototype.subgraphExists = function (id) {
+        return !!this._subgraphMap[id];
+    };
+    Graph2.prototype.subgraph = function (id) {
+        return this._subgraphMap[id]._;
+    };
+    Graph2.prototype.subgraphSubgraphs = function (id) {
+        var _this = this;
+        return this._subgraphMap[id].children().filter(function (child) { return _this.isSubgraph(child._); }).map(function (child) { return child._; });
+    };
+    Graph2.prototype.subgraphVertices = function (id) {
+        var _this = this;
+        return this._subgraphMap[id].children().filter(function (child) { return _this.isVertex(child._); }).map(function (child) { return child._; });
+    };
+    Graph2.prototype.subgraphEdges = function (id) {
+        var _this = this;
+        return this._subgraphMap[id].children().filter(function (child) { return _this.isEdge(child._); }).map(function (child) { return child._; });
+    };
+    Graph2.prototype.addSubgraph = function (s, parent) {
+        var s_id = this._idFunc(s);
+        if (this._subgraphMap[s_id])
+            throw new Error("Subgraph '".concat(s_id, "' already exists."));
+        var subgraph = new Subgraph(this, s);
+        if (parent) {
+            var p_id = this._idFunc(parent);
+            if (!this._subgraphMap[p_id])
+                throw new Error("Subgraph '".concat(p_id, "' does not exist."));
+            subgraph.parent(this._subgraphMap[p_id]);
+        }
+        this._subgraphMap[s_id] = subgraph;
+        return this;
+    };
+    Graph2.prototype.mergeSubgraphs = function (_subgraphs) {
+        var _this = this;
+        if (_subgraphs === void 0) { _subgraphs = []; }
+        var sgDiff = compare2(this.allSubgraphs(), _subgraphs, function (sg) { return _this._idFunc(sg); }, this._updateFunc);
+        sgDiff.exit.forEach(function (sg) { return _this.removeSubgraph(_this._idFunc(sg)); });
+        sgDiff.enter.forEach(function (sg) { return _this.addSubgraph(sg); });
+        sgDiff.update.forEach(function (sg) { return _this.updateSubgraph(sg); });
+        return this;
+    };
+    Graph2.prototype.updateSubgraph = function (sg) {
+        var sg_id = this._idFunc(sg);
+        var subgraph = this._subgraphMap[sg_id];
+        if (!subgraph)
+            throw new Error("Subgraph '".concat(sg_id, "' does not exist."));
+        subgraph._ = sg;
+        return this;
+    };
+    Graph2.prototype.removeSubgraph = function (id, promoteChildren) {
+        var _this = this;
+        if (promoteChildren === void 0) { promoteChildren = true; }
+        var sg = this._subgraphMap[id];
+        if (!sg)
+            throw new Error("Subgraph '".concat(id, "' does not exist."));
+        sg.children().forEach(function (child) {
+            if (promoteChildren) {
+                child.parent(sg.parent());
+            }
+            else {
+                if (child instanceof Subgraph) {
+                    _this.removeSubgraph(child.id());
+                }
+                else {
+                    _this.removeVertex(child.id());
+                }
+            }
+        });
+        delete this._subgraphMap[id];
+        return this;
+    };
+    Graph2.prototype.subgraphParent = function (id, parentID) {
+        var item = this._subgraphMap[id];
+        if (!item)
+            throw new Error("Subgraph '".concat(id, "' does not exist."));
+        if (parentID === void 0) {
+            var parent_1 = item.parent();
+            return parent_1 ? parent_1._ : undefined;
+        }
+        var parent = this._subgraphMap[parentID];
+        if (!parent)
+            throw new Error("Vertex parent '".concat(parent, "' does not exist."));
+        item.parent(parent);
+        return this;
+    };
+    // Vertices  ---
+    Graph2.prototype.allVertices = function () {
+        var retVal = [];
+        for (var key in this._vertexMap) {
+            retVal.push(this._vertexMap[key]._);
+        }
+        return retVal;
+    };
+    Graph2.prototype.vertices = function () {
+        var retVal = [];
+        for (var key in this._vertexMap) {
+            if (this._vertexMap[key].parent() === undefined) {
+                retVal.push(this._vertexMap[key]._);
+            }
+        }
+        return retVal;
+    };
+    Graph2.prototype.vertexExists = function (id) {
+        return !!this._vertexMap[id];
+    };
+    Graph2.prototype.vertex = function (id) {
+        return this._vertexMap[id]._;
+    };
+    Graph2.prototype.allEdges = function () {
+        var retVal = [];
+        for (var key in this._edgeMap) {
+            retVal.push(this._edgeMap[key]._);
+        }
+        return retVal;
+    };
+    Graph2.prototype.edges = function () {
+        var retVal = [];
+        for (var key in this._edgeMap) {
+            if (this._edgeMap[key].parent() === undefined) {
+                retVal.push(this._edgeMap[key]._);
+            }
+        }
+        return retVal;
+    };
+    Graph2.prototype.vertexEdges = function (vertexID) {
+        return this._vertexMap[vertexID].edges().map(function (e) { return e._; });
+    };
+    Graph2.prototype.inEdges = function (vertexID) {
+        return this._vertexMap[vertexID].inEdges().map(function (e) { return e._; });
+    };
+    Graph2.prototype.outEdges = function (vertexID) {
+        return this._vertexMap[vertexID].outEdges().map(function (e) { return e._; });
+    };
+    Graph2.prototype._neighbors = function (id) {
+        return __spreadArray(__spreadArray([], this._vertexMap[id].outEdges().map(function (e) { return e._target; }), true), this._vertexMap[id].inEdges().map(function (e) { return e._source; }), true);
+    };
+    Graph2.prototype.neighbors = function (id) {
+        return this._neighbors(id).map(function (n) { return n._; });
+    };
+    Graph2.prototype.singleNeighbors = function (id) {
+        return this._neighbors(id).filter(function (n) { return n.edgeCount() === 1; }).map(function (n) { return n._; });
+    };
+    Graph2.prototype.addVertex = function (v, parent) {
+        var v_id = this._idFunc(v);
+        if (this._vertexMap[v_id])
+            throw new Error("Vertex '".concat(v_id, "' already exists."));
+        var vertex = new Vertex(this, v);
+        if (parent) {
+            var p_id = this._idFunc(parent);
+            if (!this.subgraphExists(p_id))
+                throw new Error("Subgraph '".concat(p_id, "' does not exist."));
+            vertex.parent(this._subgraphMap[p_id]);
+        }
+        this._vertexMap[v_id] = vertex;
+        return this;
+    };
+    Graph2.prototype.mergeVertices = function (_vertices) {
+        var _this = this;
+        var vDiff = compare2(this.allVertices(), _vertices, function (v) { return _this._idFunc(v); }, this._updateFunc);
+        vDiff.exit.forEach(function (v) { return _this.removeVertex(_this._idFunc(v)); });
+        vDiff.enter.forEach(function (v) { return _this.addVertex(v); });
+        vDiff.update.forEach(function (v) { return _this.updateVertex(v); });
+        return this;
+    };
+    Graph2.prototype.updateVertex = function (v) {
+        var v_id = this._idFunc(v);
+        var vertex = this._vertexMap[v_id];
+        if (!vertex)
+            throw new Error("Vertex '".concat(v_id, "' does not exist."));
+        vertex._ = v;
+        return this;
+    };
+    Graph2.prototype.removeVertex = function (id) {
+        var _this = this;
+        var v = this._vertexMap[id];
+        if (!v)
+            throw new Error("Vertex '".concat(id, "' does not exist."));
+        v.edges().forEach(function (e) {
+            _this.removeEdge(e.id());
+        });
+        delete this._vertexMap[id];
+        return this;
+    };
+    Graph2.prototype.vertexParent = function (id, parentID) {
+        var item = this._vertexMap[id];
+        if (!item)
+            throw new Error("Vertex '".concat(id, "' does not exist."));
+        if (parentID === void 0) {
+            var parent_2 = item.parent();
+            return parent_2 ? parent_2._ : undefined;
+        }
+        var parent = this._subgraphMap[parentID];
+        if (!parent)
+            throw new Error("Vertex parent '".concat(parent, "' does not exist."));
+        item.parent(parent);
+        return this;
+    };
+    // Edges  ---
+    Graph2.prototype.edgeExists = function (id) {
+        return !!this._edgeMap[id];
+    };
+    Graph2.prototype.edge = function (id) {
+        return this._edgeMap[id]._;
+    };
+    Graph2.prototype.addEdge = function (e, parent) {
+        var e_id = this._idFunc(e);
+        var e_source = this._sourceFunc(e);
+        var e_target = this._targetFunc(e);
+        if (this._edgeMap[e_id])
+            throw new Error("Edge '".concat(e_id, "' already exists."));
+        if (!this.vertexExists(e_source))
+            throw new Error("Edge Source '".concat(e_source, "' does not exist."));
+        if (!this.vertexExists(e_target))
+            throw new Error("Edge Target '".concat(e_target, "' does not exist."));
+        var edge = new Edge(this, e, this._vertexMap[e_source], this._vertexMap[e_target]);
+        if (parent) {
+            var p_id = this._idFunc(parent);
+            if (!this.subgraphExists(p_id))
+                throw new Error("Subgraph '".concat(p_id, "' does not exist."));
+            edge.parent(this._subgraphMap[p_id]);
+        }
+        this._edgeMap[e_id] = edge;
+        this._vertexMap[e_source].addOutEdge(edge);
+        this._vertexMap[e_target].addInEdge(edge);
+        return this;
+    };
+    Graph2.prototype.mergeEdges = function (_edges) {
+        var _this = this;
+        var eDiff = compare2(this.allEdges(), _edges, function (e) { return _this._idFunc(e); }, this._updateFunc);
+        eDiff.exit.forEach(function (e) { return _this.removeEdge(_this._idFunc(e)); });
+        eDiff.enter.forEach(function (e) { return _this.addEdge(e); });
+        eDiff.update.forEach(function (e) { return _this.updateEdge(e); });
+        return this;
+    };
+    Graph2.prototype.updateEdge = function (e) {
+        var e_id = this._idFunc(e);
+        var edge = this._edgeMap[e_id];
+        if (!edge)
+            throw new Error("Edge '".concat(e_id, "' does not exist."));
+        edge._ = e;
+        return this;
+    };
+    Graph2.prototype.removeEdge = function (id) {
+        var e = this._edgeMap[id];
+        if (!e)
+            throw new Error("Edge '".concat(id, "' does not exist."));
+        var e_sourceID = this._idFunc(e._source._);
+        if (!this.vertexExists(e_sourceID))
+            throw new Error("Edge Source'".concat(e_sourceID, "' does not exist."));
+        this._vertexMap[e_sourceID].removeOutEdge(id);
+        var e_targetID = this._idFunc(e._target._);
+        if (!this.vertexExists(e_targetID))
+            throw new Error("Edge Target'".concat(e_targetID, "' does not exist."));
+        this._vertexMap[e_targetID].removeInEdge(id);
+        delete this._edgeMap[id];
+        return this;
+    };
+    Graph2.prototype._hwalk = function (item, formatter) {
+        var _this = this;
+        if (item instanceof Subgraph) {
+            return formatter("subgraph", item._, item.children().map(function (child) { return _this._hwalk(child, formatter); }));
+        }
+        else {
+            return formatter("vertex", item._);
+        }
+    };
+    Graph2.prototype.hierarchy = function (formatter) {
+        var retVal = [];
+        for (var id in this._subgraphMap) {
+            var sg = this._subgraphMap[id];
+            if (sg.parent() === undefined) {
+                retVal.push(this._hwalk(sg, formatter));
+            }
+        }
+        for (var id in this._vertexMap) {
+            var v = this._vertexMap[id];
+            if (v.parent() === undefined) {
+                retVal.push(this._hwalk(v, formatter));
+            }
+        }
+        return retVal;
+    };
+    Graph2.prototype.dijkstra = function (source, target) {
+        var edges = this.allEdges();
+        var Q = new Set();
+        var prev = {};
+        var dist = {};
+        var adj = {};
+        function vertex_with_min_dist(Q, dist) {
+            var min_distance = Infinity;
+            var u = null;
+            Q.forEach(function (v) {
+                if (dist[v] < min_distance) {
+                    min_distance = dist[v];
+                    u = v;
+                }
+            });
+            return u;
+        }
+        for (var i = 0; i < edges.length; i++) {
+            var v1 = this._sourceFunc(edges[i]);
+            var v2 = this._targetFunc(edges[i]);
+            var len_1 = 1;
+            Q.add(v1);
+            Q.add(v2);
+            dist[v1] = Infinity;
+            dist[v2] = Infinity;
+            if (adj[v1] === undefined)
+                adj[v1] = {};
+            if (adj[v2] === undefined)
+                adj[v2] = {};
+            adj[v1][v2] = len_1;
+            adj[v2][v1] = len_1;
+        }
+        dist[source] = 0;
+        while (Q.size) {
+            var u_1 = vertex_with_min_dist(Q, dist);
+            if (u_1 === null)
+                break;
+            var neighbors = Object.keys(adj[u_1]).filter(function (v) { return Q.has(v); }); // Neighbor still in Q
+            Q.delete(u_1);
+            if (u_1 === target)
+                break; // Break when the target has been found
+            for (var _i = 0, neighbors_1 = neighbors; _i < neighbors_1.length; _i++) {
+                var v = neighbors_1[_i];
+                var alt = dist[u_1] + adj[u_1][v];
+                if (alt < dist[v]) {
+                    dist[v] = alt;
+                    prev[v] = u_1;
+                }
+            }
+        }
+        var u = target;
+        var ids = [u];
+        var len = 0;
+        while (prev[u] !== undefined) {
+            ids.unshift(prev[u]);
+            len += adj[u][prev[u]];
+            u = prev[u];
+        }
+        return { ids: ids, len: len };
+    };
+    Graph2.prototype.sort = function (v_id) {
+        var retVal = [];
+        var visited = {};
+        var visit = function (vertex, ancestors) {
+            if (ancestors === void 0) { ancestors = []; }
+            var v_id = vertex.id();
+            if (visited[v_id])
+                return;
+            visited[v_id] = true;
+            ancestors.push(vertex);
+            vertex.outEdges().forEach(function (e) {
+                if (ancestors.indexOf(e._target) < 0) {
+                    visit(e._target, __spreadArray([], ancestors, true));
+                }
+            });
+            retVal.unshift(vertex._);
+        };
+        if (v_id) {
+            visit(this._vertexMap[v_id]);
+        }
+        else {
+            for (var key in this._vertexMap) {
+                visit(this._vertexMap[key]);
+            }
+        }
+        return retVal;
+    };
+    return Graph2;
+}());
+export { Graph2 };
+var Set = /** @class */ (function () {
+    function Set() {
+        this._content = [];
+    }
+    Object.defineProperty(Set.prototype, "size", {
+        get: function () {
+            return this._content.length;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Set.prototype.has = function (_) {
+        return this._content.indexOf(_) >= 0;
+    };
+    Set.prototype.add = function (_) {
+        if (!this.has(_)) {
+            this._content.push(_);
+        }
+    };
+    Set.prototype.delete = function (_) {
+        var idx = this._content.indexOf(_);
+        if (idx >= 0) {
+            this._content.splice(idx, 1);
+        }
+    };
+    Set.prototype.forEach = function (_) {
+        this._content.forEach(_);
+    };
+    return Set;
+}());
 //# sourceMappingURL=graph2.js.map