data-structure-typed 0.8.18 → 0.9.16

package/dist/data-structures/graph/directed-graph.d.ts

@@ -1,4 +1,5 @@
-import { AbstractEdge, AbstractGraph, AbstractVertex, VertexId } from './abstract-graph';
+import { AbstractEdge, AbstractGraph, AbstractVertex } from './abstract-graph';
+import type { IDirectedGraph, VertexId } from '../types';
 export declare class DirectedVertex extends AbstractVertex {
     constructor(id: VertexId);
 }
@@ -11,16 +12,7 @@ export declare class DirectedEdge extends AbstractEdge {
     get dest(): VertexId;
     set dest(v: VertexId);
 }
-export interface I_DirectedGraph<V, E> {
-    incomingEdgesOf(vertex: V): E[];
-    outgoingEdgesOf(vertex: V): E[];
-    inDegreeOf(vertexOrId: V | VertexId): number;
-    outDegreeOf(vertexOrId: V | VertexId): number;
-    getEdgeSrc(e: E): V | null;
-    getEdgeDest(e: E): V | null;
-}
-export type TopologicalStatus = 0 | 1 | 2;
-export declare class DirectedGraph<V extends DirectedVertex, E extends DirectedEdge> extends AbstractGraph<V, E> implements I_DirectedGraph<V, E> {
+export declare class DirectedGraph<V extends DirectedVertex, E extends DirectedEdge> extends AbstractGraph<V, E> implements IDirectedGraph<V, E> {
     protected _outEdgeMap: Map<V, E[]>;
     protected _inEdgeMap: Map<V, E[]>;
     constructor();
@@ -37,13 +29,13 @@ export declare class DirectedGraph<V extends DirectedVertex, E extends DirectedE
     edgesOf(vertexOrId: VertexId | V): E[];
     getEdgeSrc(e: E): V | null;
     getEdgeDest(e: E): V | null;
-    getDestinations(vertex: V | null): V[];
+    getDestinations(vertex: V | VertexId | null): V[];
     /**--- start find cycles --- */
     /**
      * when stored with adjacency list time: O(V+E)
      * when stored with adjacency matrix time: O(V^2)
      */
-    topologicalSort(): V[] | null;
+    topologicalSort(): (V | VertexId)[] | null;
     /**--- end find cycles --- */
     edgeSet(): E[];
     getNeighbors(vertexOrId: V | VertexId): V[];

package/dist/data-structures/graph/directed-graph.js

@@ -1,71 +1,137 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DirectedGraph = exports.DirectedEdge = exports.DirectedVertex = void 0;
-const utils_1 = require("../../utils");
-const abstract_graph_1 = require("./abstract-graph");
-class DirectedVertex extends abstract_graph_1.AbstractVertex {
-    constructor(id) {
-        super(id);
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
     }
-}
-exports.DirectedVertex = DirectedVertex;
-class DirectedEdge extends abstract_graph_1.AbstractEdge {
-    constructor(src, dest, weight) {
-        super(weight);
-        this._src = src;
-        this._dest = dest;
-    }
-    get src() {
-        return this._src;
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
     }
-    set src(v) {
-        this._src = v;
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
     }
-    get dest() {
-        return this._dest;
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DirectedGraph = exports.DirectedEdge = exports.DirectedVertex = void 0;
+var utils_1 = require("../../utils");
+var abstract_graph_1 = require("./abstract-graph");
+var DirectedVertex = /** @class */ (function (_super) {
+    __extends(DirectedVertex, _super);
+    function DirectedVertex(id) {
+        return _super.call(this, id) || this;
     }
-    set dest(v) {
-        this._dest = v;
+    return DirectedVertex;
+}(abstract_graph_1.AbstractVertex));
+exports.DirectedVertex = DirectedVertex;
+var DirectedEdge = /** @class */ (function (_super) {
+    __extends(DirectedEdge, _super);
+    function DirectedEdge(src, dest, weight) {
+        var _this = _super.call(this, weight) || this;
+        _this._src = src;
+        _this._dest = dest;
+        return _this;
     }
-}
+    Object.defineProperty(DirectedEdge.prototype, "src", {
+        get: function () {
+            return this._src;
+        },
+        set: function (v) {
+            this._src = v;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DirectedEdge.prototype, "dest", {
+        get: function () {
+            return this._dest;
+        },
+        set: function (v) {
+            this._dest = v;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return DirectedEdge;
+}(abstract_graph_1.AbstractEdge));
 exports.DirectedEdge = DirectedEdge;
 // Strongly connected, One direction connected, Weakly connected
-class DirectedGraph extends abstract_graph_1.AbstractGraph {
-    constructor() {
-        super();
-        this._outEdgeMap = new Map();
-        this._inEdgeMap = new Map();
+var DirectedGraph = /** @class */ (function (_super) {
+    __extends(DirectedGraph, _super);
+    function DirectedGraph() {
+        var _this = _super.call(this) || this;
+        _this._outEdgeMap = new Map();
+        _this._inEdgeMap = new Map();
+        return _this;
     }
-    getEdge(srcOrId, destOrId) {
-        let edges = [];
+    DirectedGraph.prototype.getEdge = function (srcOrId, destOrId) {
+        var edges = [];
         if (srcOrId !== null && destOrId !== null) {
-            const src = this.getVertex(srcOrId);
-            const dest = this.getVertex(destOrId);
-            if (src && dest) {
-                const srcOutEdges = this._outEdgeMap.get(src);
+            var src = this.getVertex(srcOrId);
+            var dest_1 = this.getVertex(destOrId);
+            if (src && dest_1) {
+                var srcOutEdges = this._outEdgeMap.get(src);
                 if (srcOutEdges) {
-                    edges = srcOutEdges.filter(edge => edge.dest === dest.id);
+                    edges = srcOutEdges.filter(function (edge) { return edge.dest === dest_1.id; });
                 }
             }
         }
         return edges[0] || null;
-    }
-    addEdge(edge) {
+    };
+    DirectedGraph.prototype.addEdge = function (edge) {
         if (!(this.containsVertex(edge.src) && this.containsVertex(edge.dest))) {
             return false;
         }
-        const srcVertex = this.getVertex(edge.src);
-        const destVertex = this.getVertex(edge.dest);
+        var srcVertex = this.getVertex(edge.src);
+        var destVertex = this.getVertex(edge.dest);
         // TODO after no-non-null-assertion not ensure the logic
         if (srcVertex && destVertex) {
-            const srcOutEdges = this._outEdgeMap.get(srcVertex);
+            var srcOutEdges = this._outEdgeMap.get(srcVertex);
             if (srcOutEdges) {
                 srcOutEdges.push(edge);
             }
             else {
                 this._outEdgeMap.set(srcVertex, [edge]);
             }
-            const destInEdges = this._inEdgeMap.get(destVertex);
+            var destInEdges = this._inEdgeMap.get(destVertex);
             if (destInEdges) {
                 destInEdges.push(edge);
             }
@@ -77,95 +143,108 @@ class DirectedGraph extends abstract_graph_1.AbstractGraph {
         else {
             return false;
         }
-    }
-    removeEdgeBetween(srcOrId, destOrId) {
-        const src = this.getVertex(srcOrId);
-        const dest = this.getVertex(destOrId);
-        let removed = null;
+    };
+    DirectedGraph.prototype.removeEdgeBetween = function (srcOrId, destOrId) {
+        var src = this.getVertex(srcOrId);
+        var dest = this.getVertex(destOrId);
+        var removed = null;
         if (!src || !dest) {
             return null;
         }
-        const srcOutEdges = this._outEdgeMap.get(src);
+        var srcOutEdges = this._outEdgeMap.get(src);
         if (srcOutEdges) {
-            (0, utils_1.arrayRemove)(srcOutEdges, edge => edge.dest === dest.id);
+            (0, utils_1.arrayRemove)(srcOutEdges, function (edge) { return edge.dest === dest.id; });
         }
-        const destInEdges = this._inEdgeMap.get(dest);
+        var destInEdges = this._inEdgeMap.get(dest);
         if (destInEdges) {
-            removed = (0, utils_1.arrayRemove)(destInEdges, edge => edge.src === src.id)[0] || null;
+            removed = (0, utils_1.arrayRemove)(destInEdges, function (edge) { return edge.src === src.id; })[0] || null;
         }
         return removed;
-    }
-    removeEdge(edge) {
-        let removed = null;
-        const src = this.getVertex(edge.src);
-        const dest = this.getVertex(edge.dest);
+    };
+    DirectedGraph.prototype.removeEdge = function (edge) {
+        var removed = null;
+        var src = this.getVertex(edge.src);
+        var dest = this.getVertex(edge.dest);
         if (src && dest) {
-            const srcOutEdges = this._outEdgeMap.get(src);
+            var srcOutEdges = this._outEdgeMap.get(src);
             if (srcOutEdges && srcOutEdges.length > 0) {
-                (0, utils_1.arrayRemove)(srcOutEdges, edge => edge.src === src.id);
+                (0, utils_1.arrayRemove)(srcOutEdges, function (edge) { return edge.src === src.id; });
             }
-            const destInEdges = this._inEdgeMap.get(dest);
+            var destInEdges = this._inEdgeMap.get(dest);
             if (destInEdges && destInEdges.length > 0) {
-                removed = (0, utils_1.arrayRemove)(destInEdges, edge => edge.dest === dest.id)[0];
+                removed = (0, utils_1.arrayRemove)(destInEdges, function (edge) { return edge.dest === dest.id; })[0];
             }
         }
         return removed;
-    }
-    removeAllEdges(src, dest) {
+    };
+    DirectedGraph.prototype.removeAllEdges = function (src, dest) {
         return [];
-    }
-    incomingEdgesOf(vertexOrId) {
-        const target = this.getVertex(vertexOrId);
+    };
+    DirectedGraph.prototype.incomingEdgesOf = function (vertexOrId) {
+        var target = this.getVertex(vertexOrId);
         if (target) {
             return this._inEdgeMap.get(target) || [];
         }
         return [];
-    }
-    outgoingEdgesOf(vertexOrId) {
-        const target = this.getVertex(vertexOrId);
+    };
+    DirectedGraph.prototype.outgoingEdgesOf = function (vertexOrId) {
+        var target = this.getVertex(vertexOrId);
         if (target) {
             return this._outEdgeMap.get(target) || [];
         }
         return [];
-    }
-    degreeOf(vertexOrId) {
+    };
+    DirectedGraph.prototype.degreeOf = function (vertexOrId) {
         return this.outDegreeOf(vertexOrId) + this.inDegreeOf(vertexOrId);
-    }
-    inDegreeOf(vertexOrId) {
+    };
+    DirectedGraph.prototype.inDegreeOf = function (vertexOrId) {
         return this.incomingEdgesOf(vertexOrId).length;
-    }
-    outDegreeOf(vertexOrId) {
+    };
+    DirectedGraph.prototype.outDegreeOf = function (vertexOrId) {
         return this.outgoingEdgesOf(vertexOrId).length;
-    }
-    edgesOf(vertexOrId) {
-        return [...this.outgoingEdgesOf(vertexOrId), ...this.incomingEdgesOf(vertexOrId)];
-    }
-    getEdgeSrc(e) {
+    };
+    DirectedGraph.prototype.edgesOf = function (vertexOrId) {
+        return __spreadArray(__spreadArray([], __read(this.outgoingEdgesOf(vertexOrId)), false), __read(this.incomingEdgesOf(vertexOrId)), false);
+    };
+    DirectedGraph.prototype.getEdgeSrc = function (e) {
         return this.getVertex(e.src);
-    }
-    getEdgeDest(e) {
+    };
+    DirectedGraph.prototype.getEdgeDest = function (e) {
         return this.getVertex(e.dest);
-    }
-    getDestinations(vertex) {
+    };
+    DirectedGraph.prototype.getDestinations = function (vertex) {
+        var e_1, _a;
         if (vertex === null) {
             return [];
         }
-        const destinations = [];
-        const outgoingEdges = this.outgoingEdgesOf(vertex);
-        for (const outEdge of outgoingEdges) {
-            const child = this.getEdgeDest(outEdge);
-            if (child) {
-                destinations.push(child);
+        var destinations = [];
+        var outgoingEdges = this.outgoingEdgesOf(vertex);
+        try {
+            for (var outgoingEdges_1 = __values(outgoingEdges), outgoingEdges_1_1 = outgoingEdges_1.next(); !outgoingEdges_1_1.done; outgoingEdges_1_1 = outgoingEdges_1.next()) {
+                var outEdge = outgoingEdges_1_1.value;
+                var child = this.getEdgeDest(outEdge);
+                if (child) {
+                    destinations.push(child);
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (outgoingEdges_1_1 && !outgoingEdges_1_1.done && (_a = outgoingEdges_1.return)) _a.call(outgoingEdges_1);
             }
+            finally { if (e_1) throw e_1.error; }
         }
         return destinations;
-    }
+    };
     /**--- start find cycles --- */
     /**
      * when stored with adjacency list time: O(V+E)
      * when stored with adjacency matrix time: O(V^2)
      */
-    topologicalSort() {
+    DirectedGraph.prototype.topologicalSort = function () {
+        var e_2, _a, e_3, _b;
+        var _this = this;
         // vector<vector<int>> g;
         // vector<int> color;
         // int last;
@@ -197,72 +276,115 @@ class DirectedGraph extends abstract_graph_1.AbstractGraph {
         // }
         // When judging whether there is a cycle in the undirected graph, all nodes with degree of **<= 1** are enqueued
         // When judging whether there is a cycle in the directed graph, all nodes with **in degree = 0** are enqueued
-        const statusMap = new Map();
-        for (const entry of this._vertices) {
-            statusMap.set(entry[1], 0);
+        var statusMap = new Map();
+        try {
+            for (var _c = __values(this._vertices), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var entry = _d.value;
+                statusMap.set(entry[1], 0);
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+            }
+            finally { if (e_2) throw e_2.error; }
         }
-        const sorted = [];
-        let hasCycle = false;
-        const dfs = (cur) => {
+        var sorted = [];
+        var hasCycle = false;
+        var dfs = function (cur) {
+            var e_4, _a;
             statusMap.set(cur, 1);
-            const children = this.getDestinations(cur);
-            for (const child of children) {
-                const childStatus = statusMap.get(child);
-                if (childStatus === 0) {
-                    dfs(child);
+            var children = _this.getDestinations(cur);
+            try {
+                for (var children_1 = __values(children), children_1_1 = children_1.next(); !children_1_1.done; children_1_1 = children_1.next()) {
+                    var child = children_1_1.value;
+                    var childStatus = statusMap.get(child);
+                    if (childStatus === 0) {
+                        dfs(child);
+                    }
+                    else if (childStatus === 1) {
+                        hasCycle = true;
+                    }
                 }
-                else if (childStatus === 1) {
-                    hasCycle = true;
+            }
+            catch (e_4_1) { e_4 = { error: e_4_1 }; }
+            finally {
+                try {
+                    if (children_1_1 && !children_1_1.done && (_a = children_1.return)) _a.call(children_1);
                 }
+                finally { if (e_4) throw e_4.error; }
             }
             statusMap.set(cur, 2);
             sorted.push(cur);
         };
-        for (const entry of this._vertices) {
-            if (statusMap.get(entry[1]) === 0) {
-                dfs(entry[1]);
+        try {
+            for (var _e = __values(this._vertices), _f = _e.next(); !_f.done; _f = _e.next()) {
+                var entry = _f.value;
+                if (statusMap.get(entry[1]) === 0) {
+                    dfs(entry[1]);
+                }
             }
         }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
         if (hasCycle) {
             return null;
         }
         return sorted.reverse();
-    }
+    };
     /**--- end find cycles --- */
-    edgeSet() {
-        let edges = [];
-        this._outEdgeMap.forEach(outEdges => {
-            edges = [...edges, ...outEdges];
+    DirectedGraph.prototype.edgeSet = function () {
+        var edges = [];
+        this._outEdgeMap.forEach(function (outEdges) {
+            edges = __spreadArray(__spreadArray([], __read(edges), false), __read(outEdges), false);
         });
         return edges;
-    }
-    getNeighbors(vertexOrId) {
-        const neighbors = [];
-        const vertex = this.getVertex(vertexOrId);
+    };
+    DirectedGraph.prototype.getNeighbors = function (vertexOrId) {
+        var e_5, _a;
+        var neighbors = [];
+        var vertex = this.getVertex(vertexOrId);
         if (vertex) {
-            const outEdges = this.outgoingEdgesOf(vertex);
-            for (const outEdge of outEdges) {
-                const neighbor = this.getVertex(outEdge.dest);
-                // TODO after no-non-null-assertion not ensure the logic
-                if (neighbor) {
-                    neighbors.push(neighbor);
+            var outEdges = this.outgoingEdgesOf(vertex);
+            try {
+                for (var outEdges_1 = __values(outEdges), outEdges_1_1 = outEdges_1.next(); !outEdges_1_1.done; outEdges_1_1 = outEdges_1.next()) {
+                    var outEdge = outEdges_1_1.value;
+                    var neighbor = this.getVertex(outEdge.dest);
+                    // TODO after no-non-null-assertion not ensure the logic
+                    if (neighbor) {
+                        neighbors.push(neighbor);
+                    }
+                }
+            }
+            catch (e_5_1) { e_5 = { error: e_5_1 }; }
+            finally {
+                try {
+                    if (outEdges_1_1 && !outEdges_1_1.done && (_a = outEdges_1.return)) _a.call(outEdges_1);
                 }
+                finally { if (e_5) throw e_5.error; }
             }
         }
         return neighbors;
-    }
-    getEndsOfEdge(edge) {
+    };
+    DirectedGraph.prototype.getEndsOfEdge = function (edge) {
         if (!this.containsEdge(edge.src, edge.dest)) {
             return null;
         }
-        const v1 = this.getVertex(edge.src);
-        const v2 = this.getVertex(edge.dest);
+        var v1 = this.getVertex(edge.src);
+        var v2 = this.getVertex(edge.dest);
         if (v1 && v2) {
             return [v1, v2];
         }
         else {
             return null;
         }
-    }
-}
+    };
+    return DirectedGraph;
+}(abstract_graph_1.AbstractGraph));
 exports.DirectedGraph = DirectedGraph;

package/dist/data-structures/graph/undirected-graph.d.ts

@@ -1,16 +1,17 @@
-import { AbstractEdge, AbstractGraph, AbstractVertex, VertexId } from './abstract-graph';
+import { AbstractEdge, AbstractGraph, AbstractVertex } from './abstract-graph';
+import type { VertexId } from '../types';
 export declare class UndirectedVertex extends AbstractVertex {
     constructor(id: VertexId);
 }
 export declare class UndirectedEdge extends AbstractEdge {
+    constructor(v1: VertexId, v2: VertexId, weight?: number);
     private _vertices;
     get vertices(): [VertexId, VertexId];
     set vertices(v: [VertexId, VertexId]);
-    constructor(v1: VertexId, v2: VertexId, weight?: number);
 }
 export declare class UndirectedGraph<V extends UndirectedVertex, E extends UndirectedEdge> extends AbstractGraph<V, E> {
-    constructor();
     protected _edges: Map<V, E[]>;
+    constructor();
     getEdge(v1: V | null | VertexId, v2: V | null | VertexId): E | null;
     addEdge(edge: E): boolean;
     removeEdgeBetween(v1: V | VertexId, v2: V | VertexId): E | null;