Merge pull request #56 from TimMikeladze/master

Update build process + general updates

Author: curran

.github/workflows/main.yml

@@ -0,0 +1,32 @@
+name: Main CI workflow
+
+on: [push]
+
+jobs:
+  run-ci:
+    name: Run Type Check & Linters
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+
+      - name: Set up Node
+        uses: actions/setup-node@v3
+        with:
+          node-version: 18
+
+      - name: Install dependencies (with cache)
+        uses: bahmutov/npm-install@v1
+
+      - name: Check types
+        run: npm run type-check
+
+      - name: Test
+        run: npm run test
+
+      - name: Build
+        run: npm run build

.gitignore

@@ -1,3 +1,4 @@
 node_modules
 *.swp
 graph-data-structure.js
+dist

.npmrc

@@ -0,0 +1 @@
+save-exact = true

.prettierignore

@@ -0,0 +1 @@
+dist

README.md

@@ -1,18 +1,18 @@
-# graph-data-structure 
+# graph-data-structure
 
-A [graph data structure](https://en.wikipedia.org/wiki/Graph_(abstract_data_type)) with [topological sort](https://en.wikipedia.org/wiki/Topological_sorting).
+A [graph data structure](<https://en.wikipedia.org/wiki/Graph_(abstract_data_type)>) with [topological sort](https://en.wikipedia.org/wiki/Topological_sorting).
 
 This library provides a minimalist implementation of a directed graph data structure. Nodes are represented by unique strings. Internally, an [adjacency list](https://en.wikipedia.org/wiki/Adjacency_list) is used to represent nodes and edges.
 
 The primary use case for this library is in implementing [dataflow programming](https://en.wikipedia.org/wiki/Dataflow_programming) or [reactive programming](https://en.wikipedia.org/wiki/Reactive_programming). The key algorithm necessary for these is topological sorting, to get an ordering of nodes such that for each edge (**u** -> **v**), **u** comes before **v** in the sorted order. The topological sorting algorithm exposed here has modifications useful for computing the order in which functions in a data flow graph should be executed, namely specifying source nodes for propagation and specifying to exclude the source nodes themselves from the result.
 
 **Table of Contents**
 
- * [Installing](#installing)
- * [Examples](#examples)
-   * [ABC](#abc)
-   * [Getting Dressed](#getting-dressed)
- * [API Reference](#api-reference)
+- [Installing](#installing)
+- [Examples](#examples)
+  - [ABC](#abc)
+  - [Getting Dressed](#getting-dressed)
+- [API Reference](#api-reference)
 
 ## Installing
 
@@ -85,56 +85,56 @@ For more detailed example code that shows more methods, have a look at the [test
 
 ## API Reference
 
-* [Creating a Graph](#creating-a-graph)
-* [Adding and Removing Nodes](#adding-and-removing-nodes)
-* [Adding and Removing Edges](#adding-and-removing-edges)
-* [Querying the Graph](#querying-the-graph)
-* [Serialization](#serialization)
-* [Graph Algorithms](#graph-algorithms)
+- [Creating a Graph](#creating-a-graph)
+- [Adding and Removing Nodes](#adding-and-removing-nodes)
+- [Adding and Removing Edges](#adding-and-removing-edges)
+- [Querying the Graph](#querying-the-graph)
+- [Serialization](#serialization)
+- [Graph Algorithms](#graph-algorithms)
 
 ### Creating a Graph
 
 <a name="graph" href="#graph">#</a> <b>Graph</b>([<i>serialized</i>])
 
 Constructs an instance of the graph data structure.
 
-The optional argument *serialized* is a serialized graph that may have been generated by **[serialize](#serialize)**. If *serialized* is present, it is deserialized by invoking **[deserialize](#deserialize)**.
+The optional argument _serialized_ is a serialized graph that may have been generated by **[serialize](#serialize)**. If _serialized_ is present, it is deserialized by invoking **[deserialize](#deserialize)**.
 
 ### Adding and Removing Nodes
 
 <a name="add-node" href="#add-node">#</a> <i>graph</i>.<b>addNode</b>(<i>node</i>)
 
-Adds a node to the graph. Returns *graph* to support method chaining. The argument *node* is a string identifier that uniquely identifies the node within this graph instance. If a node with the same identifier was already added to the graph, this function does nothing.
+Adds a node to the graph. Returns _graph_ to support method chaining. The argument _node_ is a string identifier that uniquely identifies the node within this graph instance. If a node with the same identifier was already added to the graph, this function does nothing.
 
 <a name="remove-node" href="#remove-node">#</a> <i>graph</i>.<b>removeNode</b>(<i>node</i>)
 
-Removes the specified node. Returns *graph* to support method chaining. The argument *node* is a string identifier for the node to remove. This function also removes all edges connected to the specified node, both incoming and outgoing.
+Removes the specified node. Returns _graph_ to support method chaining. The argument _node_ is a string identifier for the node to remove. This function also removes all edges connected to the specified node, both incoming and outgoing.
 
 ### Adding and Removing Edges
 
 <a name="add-edge" href="#add-edge">#</a> <i>graph</i>.<b>addEdge</b>(<i>u</i>, <i>v</i>[,<i>weight</i>])
 
-Adds an edge from node *u* to node *v*. Returns *graph* to support method chaining. The arguments *u* and *v* are string identifiers for nodes. This function also adds *u* and *v* as nodes if they were not already added.
+Adds an edge from node _u_ to node _v_. Returns _graph_ to support method chaining. The arguments _u_ and _v_ are string identifiers for nodes. This function also adds _u_ and _v_ as nodes if they were not already added.
 
-The last argument *weight* (optional) specifies the weight of this edge.
+The last argument _weight_ (optional) specifies the weight of this edge.
 
 <a name="remove-edge" href="#remove-edge">#</a> <i>graph</i>.<b>removeEdge</b>(<i>u</i>, <i>v</i>)
 
-Removes the edge from node *u* to node *v*. Returns *graph* to support method chaining. The arguments *u* and *v* are string identifiers for nodes. This function does not remove the nodes *u* and *v*. Does nothing if the edge does not exist.
+Removes the edge from node _u_ to node _v_. Returns _graph_ to support method chaining. The arguments _u_ and _v_ are string identifiers for nodes. This function does not remove the nodes _u_ and _v_. Does nothing if the edge does not exist.
 
 <a name="has-edge" href="#has-edge">#</a> <i>graph</i>.<b>hasEdge</b>(<i>u</i>, <i>v</i>)
 
-Returns `true` if there exists an edge from node *u* to node *v*. Returns `false` otherwise.
+Returns `true` if there exists an edge from node _u_ to node _v_. Returns `false` otherwise.
 
 ### Working with Edge Weights
 
 <a name="set-edge-weight" href="#set-edge-weight">#</a> <i>graph</i>.<b>setEdgeWeight</b>(<i>u</i>, <i>v</i>, <i>weight</i>)
 
-Sets the *weight* (a number) of the edge from node *u* to node *v*.
+Sets the _weight_ (a number) of the edge from node _u_ to node _v_.
 
 <a name="get-edge-weight" href="#get-edge-weight">#</a> <i>graph</i>.<b>getEdgeWeight</b>(<i>u</i>, <i>v</i>, <i>weight</i>)
 
-Gets the *weight* of the edge from node *u* to node *v*. If no weight was previously set on this edge, then the value 1 is returned.
+Gets the _weight_ of the edge from node _u_ to node _v_. If no weight was previously set on this edge, then the value 1 is returned.
 
 ### Querying the Graph
 
@@ -144,29 +144,29 @@ List all nodes in the graph. Returns an array of node identifier strings.
 
 <a name="adjacent" href="#adjacent">#</a> <i>graph</i>.<b>adjacent</b>(<i>node</i>)
 
-Gets the adjacent node list for the specified node. The argument *node* is a string identifier for a node. Returns an array of node identifier strings.
+Gets the adjacent node list for the specified node. The argument _node_ is a string identifier for a node. Returns an array of node identifier strings.
 
-The "adjacent node list" is the Array of nodes for which there is an incoming edge from the given node. In other words, for all edges (**u** -> **v**) where **u** is the specified node, all values for **v** are in the adjacent node list. 
+The "adjacent node list" is the Array of nodes for which there is an incoming edge from the given node. In other words, for all edges (**u** -> **v**) where **u** is the specified node, all values for **v** are in the adjacent node list.
 
 <a name="indegree" href="#indegree">#</a> <i>graph</i>.<b>indegree</b>(<i>node</i>)
 
-Computes the [indegree](https://en.wikipedia.org/wiki/Directed_graph#Indegree_and_outdegree) (number of incoming edges) for the specified *node*.
+Computes the [indegree](https://en.wikipedia.org/wiki/Directed_graph#Indegree_and_outdegree) (number of incoming edges) for the specified _node_.
 
 <a name="outdegree" href="#outdegree">#</a> <i>graph</i>.<b>outdegree</b>(<i>node</i>)
 
-Computes the [outdegree](https://en.wikipedia.org/wiki/Directed_graph#Indegree_and_outdegree) (number of outgoing edges) for the specified *node*.
+Computes the [outdegree](https://en.wikipedia.org/wiki/Directed_graph#Indegree_and_outdegree) (number of outgoing edges) for the specified _node_.
 
 ### Serialization
 
 <a name="serialize" href="#serialize">#</a> <i>graph</i>.<b>serialize</b>()
 
 Serializes the graph. Returns an object with the following properties.
 
- * `nodes` An array of objects, each with an `id` property whose value is a node identifier string.
- * `links` An array of objects representing edges, each with the following properties.
-   * `source` The node identifier string of the source node (**u**).
-   * `target` The node identifier string of the target node (**v**).
-   * `weight` The weight of the edge between the source and target nodes.
+- `nodes` An array of objects, each with an `id` property whose value is a node identifier string.
+- `links` An array of objects representing edges, each with the following properties.
+  - `source` The node identifier string of the source node (**u**).
+  - `target` The node identifier string of the target node (**v**).
+  - `weight` The weight of the edge between the source and target nodes.
 
 Here's example code for serializing a graph.
 
@@ -181,11 +181,7 @@ The following will be the value of `serialized`.
 
 ```json
 {
-  "nodes": [
-    { "id": "a" },
-    { "id": "b" },
-    { "id": "c" }
-  ],
+  "nodes": [{ "id": "a" }, { "id": "b" }, { "id": "c" }],
   "links": [
     { "source": "a", "target": "b", "weight": 1 },
     { "source": "b", "target": "c", "weight": 1 }
@@ -197,20 +193,19 @@ This representation conforms to the convention of graph representation when work
 
 <a name="deserialize" href="#deserialize">#</a> <i>graph</i>.<b>deserialize</b>(<i>serialized</i>)
 
-Deserializes the given serialized graph. Returns *graph* to support method chaining. The argument *serialized* is a graph representation with the structure described in **[serialize](#serialize)**. This function iterates over the serialized graph and adds the nodes and links it represents by invoking **[addNode](#add-node)** and **[addEdge](#add-edge)**. The output from **[serialize](#serialize)** can be used as the input to **deserialize**.
+Deserializes the given serialized graph. Returns _graph_ to support method chaining. The argument _serialized_ is a graph representation with the structure described in **[serialize](#serialize)**. This function iterates over the serialized graph and adds the nodes and links it represents by invoking **[addNode](#add-node)** and **[addEdge](#add-edge)**. The output from **[serialize](#serialize)** can be used as the input to **deserialize**.
 
 ### Graph Algorithms
 
-<a name="dfs" href="#dfs">#</a> <i>graph</i>.<b>depthFirstSearch</b>([<i>sourceNodes</i>][, <i>includeSourceNodes</i>][, <i>errorOnCycle</i>])
+<a name="dfs" href="#dfs">#</a> <i>graph</i>.<b>depthFirstSearch</b>([<i>sourceNodes</i>][, <i>includesourcenodes</i>][, <i>errorOnCycle</i>])
 
 Performs [Depth-first Search](https://en.wikipedia.org/wiki/Depth-first_search). Returns an array of node identifier strings. The returned array includes nodes visited by the algorithm in the order in which they were visited. Implementation inspired by pseudocode from Cormen et al. "Introduction to Algorithms" 3rd Ed. p. 604.
 
 Arguments:
 
- * *sourceNodes* (optional) - An array of node identifier strings. This specifies the subset of nodes to use as the sources of the depth-first search. If *sourceNodes* is not specified, all **[nodes](#nodes)** in the graph are used as source nodes.
- * *includeSourceNodes* (optional) - A boolean specifying whether or not to include the source nodes in the returned array. If *includeSourceNodes* is not specified, it is treated as `true` (all source nodes are included in the returned array).
- * *errorOnCycle* (optional) - A boolean indicating that a `CycleError` should be thrown whenever a cycle is first encountered. Defaults to `false`.
-
+- _sourceNodes_ (optional) - An array of node identifier strings. This specifies the subset of nodes to use as the sources of the depth-first search. If _sourceNodes_ is not specified, all **[nodes](#nodes)** in the graph are used as source nodes.
+- _includeSourceNodes_ (optional) - A boolean specifying whether or not to include the source nodes in the returned array. If _includeSourceNodes_ is not specified, it is treated as `true` (all source nodes are included in the returned array).
+- _errorOnCycle_ (optional) - A boolean indicating that a `CycleError` should be thrown whenever a cycle is first encountered. Defaults to `false`.
 
 <a name="has-cycle" href="#has-cycle">#</a> <i>graph</i>.<b>hasCycle</b>()
 
@@ -222,14 +217,14 @@ Performs search of [Lowest common ancestors](https://en.wikipedia.org/wiki/Lowes
 
 Arguments:
 
- * *node1* (required) - First node.
- * *node2* (required) - Second node.
+- _node1_ (required) - First node.
+- _node2_ (required) - Second node.
 
-<a name="topological-sort" href="#topological-sort">#</a> <i>graph</i>.<b>topologicalSort</b>([<i>sourceNodes</i>][, <i>includeSourceNodes</i>])
+<a name="topological-sort" href="#topological-sort">#</a> <i>graph</i>.<b>topologicalSort</b>([<i>sourceNodes</i>][, <i>includesourcenodes</i>])
 
 Performs [Topological Sort](https://en.wikipedia.org/wiki/Topological_sorting). Returns an array of node identifier strings. The returned array includes nodes in topologically sorted order. This means that for each visited edge (**u** -> **v**), **u** comes before **v** in the topologically sorted order. Amazingly, this comes from simply reversing the result from depth first search. Inspired by by Cormen et al. "Introduction to Algorithms" 3rd Ed. p. 613.
 
-See **[depthFirstSearch](#dfs)** for documentation of the arguments *sourceNodes* and *includeSourceNodes*.
+See **[depthFirstSearch](#dfs)** for documentation of the arguments _sourceNodes_ and _includeSourceNodes_.
 
 Note: this function raises a `CycleError` when the input is not a DAG.