@woosh/meep-engine 2.77.0 → 2.78.1

package/build/meep.cjs

@@ -70585,10 +70585,19 @@ class Edge {
         return this.first === node || this.second === node;
     }
 
+    /**
+     *
+     * @param {N} source
+     * @param {N} target
+     * @returns {boolean} True  iff the edge contains both source and target and allows transition from source to target
+     */
     validateTransition(source, target) {
         const a = this.first;
         const b = this.second;
-        return (a === source && b === target && this.traversableForward()) || (b === source && a === target && this.traversableBackward());
+
+        return (a === source && b === target && this.traversableForward())
+            || (b === source && a === target && this.traversableBackward())
+            ;
     }
 
     /**
@@ -70636,16 +70645,6 @@ class Edge {
             || (this.second === node && this.direction === EdgeDirectionType.Backward)
     }
 
-    /**
-     * @deprecated
-     * @returns {number}
-     */
-    angle() {
-
-        const delta = this.second.clone().sub(this.first);
-        return Math.atan2(delta.y, delta.x);
-    }
-
     /**
      *
      * @returns {N[]}
@@ -70654,15 +70653,6 @@ class Edge {
         return [this.first, this.second];
     }
 
-
-    /**
-     * @deprecated
-     * @returns {number}
-     */
-    get length() {
-
-        return this.first.distanceTo(this.second);
-    }
 }
 
 /**
@@ -70693,10 +70683,19 @@ class NodeContainer {
     /**
      *
      * @type {Map<N,number>}
+     * Maps neighbour node to number of edges to that node from this one
      * @private
      */
     __neighbors = new Map();
 
+    /**
+     * NOTE: this method allocates memory internally
+     * @returns {N[]}
+     */
+    get neighbours() {
+        return Array.from(this.__neighbors.keys());
+    }
+
     /**
      *
      * @return {number}
@@ -70714,7 +70713,7 @@ class NodeContainer {
     }
 
     /**
-     *
+     * NOTE: this method allocates memory internally
      * @returns {N[]}
      */
     get inNodes() {
@@ -70722,7 +70721,7 @@ class NodeContainer {
     }
 
     /**
-     *
+     * NOTE: this method allocates memory internally
      * @returns {N[]}
      */
     get outNodes() {
@@ -70730,6 +70729,10 @@ class NodeContainer {
     }
 
 
+    /**
+     * NOTE: this method allocates memory internally
+     * @returns {Edge<N>[]}
+     */
     get outEdges() {
         /**
          *
@@ -70742,6 +70745,10 @@ class NodeContainer {
         return result;
     }
 
+    /**
+     * NOTE: this method allocates memory internally
+     * @returns {Edge<N>[]}
+     */
     get inEdges() {
         /**
          *
@@ -71070,6 +71077,7 @@ class Graph {
     /**
      *
      * @param {N} node
+     * @returns {boolean}
      */
     removeNode(node) {
 
@@ -71143,7 +71151,7 @@ class Graph {
     }
 
     /**
-     *
+     * Node degree is the number of attached edges
      * @param {N} node
      * @return {number}
      */
@@ -71157,6 +71165,14 @@ class Graph {
         return container.getEdgeCount();
     }
 
+    /**
+     *
+     * @returns {N[]}
+     */
+    get nodes() {
+        return Array.from(this.getNodes());
+    }
+
     /**
      * Do not modify this set directly
      * @return {Iterable<N>}
@@ -71177,13 +71193,18 @@ class Graph {
      *
      * @param {N} source
      * @param {N} target
-     * @param {EdgeDirectionType} [type] Undirected by default
+     * @param {EdgeDirectionType} [direction] Undirected by default
      * @returns {Edge<N>}
      */
-    createEdge(source, target, type = EdgeDirectionType.Undirected) {
+    createEdge(
+        source,
+        target,
+        direction = EdgeDirectionType.Undirected
+    ) {
+
         const edge = new Edge(source, target);
 
-        edge.direction = type;
+        edge.direction = direction;
 
         this.addEdge(edge);
 
@@ -71191,9 +71212,10 @@ class Graph {
     }
 
     /**
-     *
+     * Both nodes that the edge is attached to must be present
      * @param {Edge<N>} edge
-     * @returns {boolean}
+     * @returns {boolean} true if edge was added, false if edge was already present
+     * @throws if one or both nodes are not contained in the graph
      */
     addEdge(edge) {
         if (this.hasEdge(edge)) {
@@ -71362,6 +71384,21 @@ class Graph {
         return edge_count;
     }
 
+    /**
+     *
+     * @param {N} node
+     * @returns {N[]}
+     */
+    getNeighbours(node) {
+        const container = this.__nodes.get(node);
+
+        if (container === undefined) {
+            return [];
+        }
+
+        return container.neighbours;
+    }
+
     /**
      *
      * @param {N} node
@@ -71380,10 +71417,10 @@ class Graph {
     }
 
     /**
-     *
+     * Find a path through the graph
      * @param {N} start
      * @param {N} goal
-     * @returns {null|N[]}
+     * @returns {null|N[]} null if no path exists
      */
     findPath(start, goal) {
         const start_node_container = this.__nodes.get(start);
@@ -71423,6 +71460,7 @@ class Graph {
                 const b = edge.second;
 
                 let other = null;
+
                 if (a === current_node && (edge.direction === EdgeDirectionType.Forward || edge.direction === EdgeDirectionType.Undirected)) {
                     other = b;
                 } else if (b === current_node && (edge.direction === EdgeDirectionType.Backward || edge.direction === EdgeDirectionType.Undirected)) {
@@ -71451,6 +71489,9 @@ class Graph {
         return null;
     }
 
+    /**
+     * Remove all data from the graph, resetting it to empty state
+     */
     clear() {
         this.__nodes.clear();
         this.__edges.clear();