@woosh/meep-engine 2.77.0 → 2.78.1

package/build/meep.module.js

@@ -70583,10 +70583,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())
+            ;
     }
 
     /**
@@ -70634,16 +70643,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[]}
@@ -70652,15 +70651,6 @@ class Edge {
         return [this.first, this.second];
     }
 
-
-    /**
-     * @deprecated
-     * @returns {number}
-     */
-    get length() {
-
-        return this.first.distanceTo(this.second);
-    }
 }
 
 /**
@@ -70691,10 +70681,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}
@@ -70712,7 +70711,7 @@ class NodeContainer {
     }
 
     /**
-     *
+     * NOTE: this method allocates memory internally
      * @returns {N[]}
      */
     get inNodes() {
@@ -70720,7 +70719,7 @@ class NodeContainer {
     }
 
     /**
-     *
+     * NOTE: this method allocates memory internally
      * @returns {N[]}
      */
     get outNodes() {
@@ -70728,6 +70727,10 @@ class NodeContainer {
     }
 
 
+    /**
+     * NOTE: this method allocates memory internally
+     * @returns {Edge<N>[]}
+     */
     get outEdges() {
         /**
          *
@@ -70740,6 +70743,10 @@ class NodeContainer {
         return result;
     }
 
+    /**
+     * NOTE: this method allocates memory internally
+     * @returns {Edge<N>[]}
+     */
     get inEdges() {
         /**
          *
@@ -71068,6 +71075,7 @@ class Graph {
     /**
      *
      * @param {N} node
+     * @returns {boolean}
      */
     removeNode(node) {
 
@@ -71141,7 +71149,7 @@ class Graph {
     }
 
     /**
-     *
+     * Node degree is the number of attached edges
      * @param {N} node
      * @return {number}
      */
@@ -71155,6 +71163,14 @@ class Graph {
         return container.getEdgeCount();
     }
 
+    /**
+     *
+     * @returns {N[]}
+     */
+    get nodes() {
+        return Array.from(this.getNodes());
+    }
+
     /**
      * Do not modify this set directly
      * @return {Iterable<N>}
@@ -71175,13 +71191,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);
 
@@ -71189,9 +71210,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)) {
@@ -71360,6 +71382,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
@@ -71378,10 +71415,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);
@@ -71421,6 +71458,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)) {
@@ -71449,6 +71487,9 @@ class Graph {
         return null;
     }
 
+    /**
+     * Remove all data from the graph, resetting it to empty state
+     */
     clear() {
         this.__nodes.clear();
         this.__edges.clear();

package/package.json

@@ -5,7 +5,7 @@
   "description": "Fully featured ECS game engine written in JavaScript",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "2.77.0",
+  "version": "2.78.1",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {

package/src/core/{graph → geom/3d/topology}/build_face_graph_from_mesh.js

@@ -1,8 +1,8 @@
-import { Graph } from "./v2/Graph.js";
-import { MultiNode } from "./MultiNode.js";
-import { compute_face_connection_weight } from "../geom/3d/topology/util/compute_face_connection_weight.js";
-import { WeightedEdge } from "./WeightedEdge.js";
-import { graph_compute_disconnected_clusters } from "./graph_compute_disconnected_clusters.js";
+import { graph_compute_disconnected_clusters } from "../../../graph/graph_compute_disconnected_clusters.js";
+import { MultiNode } from "../../../graph/MultiNode.js";
+import { Graph } from "../../../graph/v2/Graph.js";
+import { WeightedEdge } from "../../../graph/WeightedEdge.js";
+import { compute_face_connection_weight } from "./util/compute_face_connection_weight.js";
 
 
 /**

package/src/core/graph/Edge.js

@@ -55,10 +55,19 @@ export 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())
+            ;
     }
 
     /**
@@ -106,17 +115,6 @@ export class Edge {
             || (this.second === node && this.direction === EdgeDirectionType.Backward)
     }
 
-    /**
-     * @deprecated
-     * @returns {number}
-     */
-    angle() {
-        console.error('method is deprecated, do not use');
-
-        const delta = this.second.clone().sub(this.first);
-        return Math.atan2(delta.y, delta.x);
-    }
-
     /**
      *
      * @returns {N[]}
@@ -125,16 +123,6 @@ export class Edge {
         return [this.first, this.second];
     }
 
-
-    /**
-     * @deprecated
-     * @returns {number}
-     */
-    get length() {
-        console.error('method is deprecated, do not use');
-
-        return this.first.distanceTo(this.second);
-    }
 }
 
 /**

package/src/core/graph/Edge.spec.js

@@ -48,3 +48,38 @@ test('other', () => {
     expect(edge.other(3)).toBe(7);
     expect(edge.other(7)).toBe(3);
 });
+
+
+test("isDirectedTowards", () => {
+    const e = new Edge(1, 3);
+
+    e.direction = EdgeDirectionType.Forward;
+
+    expect(e.isDirectedTowards(3)).toBe(true);
+    expect(e.isDirectedTowards(1)).toBe(false);
+
+    e.direction = EdgeDirectionType.Backward;
+
+    expect(e.isDirectedTowards(3)).toBe(false);
+    expect(e.isDirectedTowards(1)).toBe(true);
+});
+
+test("isDirectedAwayFrom", () => {
+    const e = new Edge(1, 3);
+
+    e.direction = EdgeDirectionType.Forward;
+
+    expect(e.isDirectedAwayFrom(3)).toBe(false);
+    expect(e.isDirectedAwayFrom(1)).toBe(true);
+
+    e.direction = EdgeDirectionType.Backward;
+
+    expect(e.isDirectedAwayFrom(3)).toBe(true);
+    expect(e.isDirectedAwayFrom(1)).toBe(false);
+});
+
+test("nodes accessor", () => {
+    const e = new Edge(1, 3);
+
+    expect(e.nodes).toEqual([1, 3]);
+});

package/src/core/graph/MultiNode.js

@@ -1,14 +1,13 @@
 /**
+ * A grouping node, intended mainly for meta-graphs, or hierarchical graphs
  * @template T
  */
 export class MultiNode {
-    constructor() {
-        /**
-         *
-         * @type {T[]}
-         */
-        this.source_nodes = [];
-    }
+    /**
+     *
+     * @type {T[]}
+     */
+    source_nodes = [];
 
     /**
      *

package/src/core/graph/coloring/colorizeGraphGreedy.spec.js

@@ -1,4 +1,4 @@
-import Graph from "../Graph.js";
+import { Graph } from "../v2/Graph.js";
 import { colorizeGraphGreedy } from "./colorizeGraphGreedy.js";
 
 test('empty graph', () => {

package/src/core/graph/layout/CircleLayout.js

@@ -1,21 +1,16 @@
-/**
- *
- * @param {Array.<Circle>} input
- * @param {Graph} graph
- */
 import { assert } from "../../assert.js";
-import Circle from "../../geom/2d/circle/Circle.js";
 import AABB2 from "../../geom/2d/aabb/AABB2.js";
+import Circle from "../../geom/2d/circle/Circle.js";
+import {
+    line_segment_line_segment_intersection_exists_2d
+} from "../../geom/2d/line/line_segment_line_segment_intersection_exists_2d.js";
 import Vector2, { v2_distance } from "../../geom/Vector2.js";
 import { max2 } from "../../math/max2.js";
 import { min2 } from "../../math/min2.js";
+import { applyCentralGravityAABB2 } from "./box/applyCentralGravityAABB2.js";
+import { resolveAABB2Overlap } from "./box/resolveAABB2Overlap.js";
 import { computeDisconnectedSubGraphs } from "./computeDisconnectedSubGraphs.js";
 import { Connection } from "./Connection.js";
-import { resolveAABB2Overlap } from "./box/resolveAABB2Overlap.js";
-import { applyCentralGravityAABB2 } from "./box/applyCentralGravityAABB2.js";
-import {
-    line_segment_line_segment_intersection_exists_2d
-} from "../../geom/2d/line/line_segment_line_segment_intersection_exists_2d.js";
 
 
 /**

package/src/core/graph/v2/Graph.js

@@ -92,6 +92,7 @@ export class Graph {
     /**
      *
      * @param {N} node
+     * @returns {boolean}
      */
     removeNode(node) {
 
@@ -165,7 +166,7 @@ export class Graph {
     }
 
     /**
-     *
+     * Node degree is the number of attached edges
      * @param {N} node
      * @return {number}
      */
@@ -179,6 +180,14 @@ export class Graph {
         return container.getEdgeCount();
     }
 
+    /**
+     *
+     * @returns {N[]}
+     */
+    get nodes() {
+        return Array.from(this.getNodes());
+    }
+
     /**
      * Do not modify this set directly
      * @return {Iterable<N>}
@@ -199,13 +208,19 @@ export 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
+    ) {
+        assert.enum(direction, EdgeDirectionType, 'direction');
+
         const edge = new Edge(source, target);
 
-        edge.direction = type;
+        edge.direction = direction;
 
         this.addEdge(edge);
 
@@ -213,9 +228,10 @@ export 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)) {
@@ -390,6 +406,21 @@ export 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
@@ -408,10 +439,10 @@ export 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);
@@ -451,6 +482,7 @@ export 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)) {
@@ -479,6 +511,9 @@ export class Graph {
         return null;
     }
 
+    /**
+     * Remove all data from the graph, resetting it to empty state
+     */
     clear() {
         this.__nodes.clear();
         this.__edges.clear();

package/src/core/graph/v2/NodeContainer.js

@@ -22,10 +22,19 @@ export 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}
@@ -43,7 +52,7 @@ export class NodeContainer {
     }
 
     /**
-     *
+     * NOTE: this method allocates memory internally
      * @returns {N[]}
      */
     get inNodes() {
@@ -51,7 +60,7 @@ export class NodeContainer {
     }
 
     /**
-     *
+     * NOTE: this method allocates memory internally
      * @returns {N[]}
      */
     get outNodes() {
@@ -59,6 +68,10 @@ export class NodeContainer {
     }
 
 
+    /**
+     * NOTE: this method allocates memory internally
+     * @returns {Edge<N>[]}
+     */
     get outEdges() {
         /**
          *
@@ -71,6 +84,10 @@ export class NodeContainer {
         return result;
     }
 
+    /**
+     * NOTE: this method allocates memory internally
+     * @returns {Edge<N>[]}
+     */
     get inEdges() {
         /**
          *

package/src/core/graph/EdgeDirection.js

@@ -1,11 +0,0 @@
-/**
- *
- * @enum {number}
- */
-const EdgeDirection = {
-    Out: 0,
-    In: 1
-};
-
-
-export default EdgeDirection;