@woosh/meep-engine 2.48.17 → 2.48.19

package/src/core/geom/Vector3.js

@@ -38,7 +38,7 @@ class Vector3 {
      * @param {number[]} array
      * @param {number} offset
      */
-    readFromArray(array, offset=0) {
+    readFromArray(array, offset = 0) {
         this.set(
             array[offset],
             array[offset + 1],
@@ -51,16 +51,16 @@ class Vector3 {
      * @param {number[]} array
      * @param {number} offset
      */
-    writeToArray(array, offset=0) {
+    writeToArray(array, offset = 0) {
         array[offset] = this.x;
         array[offset + 1] = this.y;
         array[offset + 2] = this.z;
     }
 
-    asArray(){
+    asArray() {
         const r = [];
 
-        this.writeToArray(r,0);
+        this.writeToArray(r, 0);
 
         return r;
     }
@@ -171,12 +171,12 @@ class Vector3 {
      * @param {Vector3} a
      * @param {Vector3} b
      */
-    addVectors(a,b){
+    addVectors(a, b) {
         const x = a.x + b.x;
         const y = a.y + b.y;
         const z = a.z + b.z;
 
-        this.set(x,y,z);
+        this.set(x, y, z);
     }
 
     /**
@@ -378,7 +378,7 @@ class Vector3 {
      * @returns {number}
      */
     length() {
-        return v3Length(this);
+        return v3_length(this.x, this.y, this.z);
     }
 
     /**
@@ -532,7 +532,7 @@ class Vector3 {
      * @param {number} fraction
      */
     lerpVectors(a, b, fraction) {
-        v3Lerp(this, a, b, fraction);
+        v3_lerp(this, a.x, a.y, a.z, b.x, b.y, b.z, fraction);
     }
 
     /**
@@ -806,7 +806,7 @@ class Vector3 {
     }
 
     toString() {
-        return `[x:${this.x}, y:${this.y}, z:${this.z}]`;
+        return `{ x:${this.x}, y:${this.y}, z:${this.z} }`;
     }
 
     /**
@@ -1095,7 +1095,6 @@ Vector3.back = Object.freeze(new Vector3(0, 0, -1));
 
 Vector3.typeName = "Vector3";
 
-
 /**
  *
  * @param {number} x0
@@ -1109,25 +1108,4 @@ Vector3.typeName = "Vector3";
 Vector3._dot = v3_dot;
 
 
-/**
- *
- * @param {{x:number, y:number, z:number}} v
- * @return {number}
- */
-function v3Length(v) {
-    return v3_length(v.x, v.y, v.z);
-}
-
-
-/**
- *
- * @param {Vector3} result
- * @param {Vector3} a
- * @param {Vector3} b
- * @param {number} fraction
- */
-function v3Lerp(result, a, b, fraction) {
-    v3_lerp(result, a.x, a.y, a.z, b.x, b.y, b.z, fraction);
-}
-
 export default Vector3;

package/src/core/graph/Edge.js

@@ -26,8 +26,8 @@ export class Edge {
      * @constructor
      */
     constructor(a, b) {
-        assert.notEqual(a, undefined, 'a is undefined');
-        assert.notEqual(b, undefined, 'b is undefined');
+        assert.defined(a, 'a');
+        assert.defined(b, 'b');
 
         /**
          *
@@ -46,6 +46,11 @@ export class Edge {
         this.direction = EdgeDirectionType.Undirected;
     }
 
+    /**
+     *
+     * @param {N} node
+     * @return {boolean}
+     */
     contains(node) {
         return this.first === node || this.second === node;
     }
@@ -86,6 +91,8 @@ export class Edge {
      * @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);
     }
@@ -104,6 +111,8 @@ export class Edge {
      * @returns {number}
      */
     get length() {
+        console.error('method is deprecated, do not use');
+
         return this.first.distanceTo(this.second);
     }
 }

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

@@ -26,29 +26,31 @@ function construct_path(goal_node_container, cameFrom) {
 export class Graph {
 
     /**
-     * @template N
+     *
+     * @type {Map<N, NodeContainer<N>>}
+     * @private
+     */
+    __nodes = new Map();
+    /**
+     *
+     * @type {Set<Edge<N>>}
+     * @private
      */
-    constructor() {
+    __edges = new Set();
+
+    on = {
         /**
-         *
-         * @type {Map<N, NodeContainer<N>>}
-         * @private
+         * @type {Signal<N,this>}
          */
-        this.__nodes = new Map();
+        nodeAdded: new Signal(),
         /**
-         *
-         * @type {Set<Edge<N>>}
-         * @private
+         * @type {Signal<N,this>}
          */
-        this.__edges = new Set();
-
-        this.on = {
-            nodeAdded: new Signal(),
-            nodeRemoved: new Signal(),
-            edgeAdded: new Signal(),
-            edgeRemoved: new Signal()
-        };
-    }
+        nodeRemoved: new Signal(),
+        edgeAdded: new Signal(),
+        edgeRemoved: new Signal()
+    };
+
 
     /**
      *
@@ -115,6 +117,14 @@ export class Graph {
         return this.__nodes.size;
     }
 
+    /**
+     *
+     * @returns {number}
+     */
+    getNodeCount() {
+        return this.__nodes.size;
+    }
+
     /**
      *
      * @param {function(N):boolean} filter
@@ -169,14 +179,6 @@ export class Graph {
         return this.__nodes.keys();
     }
 
-    /**
-     *
-     * @returns {number}
-     */
-    getNodeCount() {
-        return this.__nodes.size;
-    }
-
     /**
      * Do not modify this set directly
      * @return {Set<Edge<N>>}
@@ -217,8 +219,10 @@ export class Graph {
         const context_0 = this.__nodes.get(edge.first);
         const context_1 = this.__nodes.get(edge.second);
 
-        if (context_0 === undefined || context_1 === undefined) {
-            throw new Error('One or more of the edge nodes are not part of the graph');
+        if (context_0 === undefined) {
+            throw new Error(`First node(=${edge.first}) of the edge is not part of the graph`);
+        } else if (context_1 === undefined) {
+            throw new Error(`Second node(=${edge.second}) of the edge is not part of the graph`);
         }
 
         context_0.addEdge(edge);
@@ -246,6 +250,7 @@ export class Graph {
         const context_1 = this.__nodes.get(edge.second);
 
         if (context_0 === undefined || context_1 === undefined) {
+            // this is a critical error, it should never happen as long as the API is used correctly
             throw new Error('One or both nodes of the edge are not present on the graph. This is a critical error');
         }
 
@@ -316,7 +321,7 @@ export class Graph {
         const context_a = this.__nodes.get(a);
 
         if (context_a === undefined) {
-            // a is not in the graph
+            // A is not in the graph
             return undefined;
         }
 
@@ -334,10 +339,10 @@ export class Graph {
      * @param {N} to
      * @returns {Edge<N>|undefined}
      */
-    getAnyDirectedEdge(from, to){
+    getAnyDirectedEdge(from, to) {
         const ctx_a = this.__nodes.get(from);
 
-        if(ctx_a === undefined){
+        if (ctx_a === undefined) {
             return undefined;
         }
 

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

@@ -1,10 +1,89 @@
-import { Edge } from "../Edge.js";
+import { Edge, EdgeDirectionType } from "../Edge.js";
 import { Graph } from "./Graph.js";
+import { jest } from "@jest/globals";
 
 test("constructor doesn't throw", () => {
     expect(() => new Graph()).not.toThrow();
 });
 
+test("adding same node twice", () => {
+
+    const graph = new Graph();
+
+    expect(graph.addNode(1)).toBe(true);
+    expect(graph.addNode(1)).toBe(false); // node already added
+
+});
+
+test("adding node triggers nodeAdded signal", () => {
+
+    const graph = new Graph();
+
+    const callback = jest.fn();
+
+    graph.on.nodeAdded.add(callback);
+
+    graph.addNode(7);
+
+    expect(callback).toHaveBeenCalledTimes(1);
+    expect(callback).toHaveBeenCalledWith(7, graph);
+
+});
+
+test("removing node triggers nodeRemoved signal", () => {
+
+    const graph = new Graph();
+
+    const callback = jest.fn();
+
+    graph.on.nodeRemoved.add(callback);
+
+    graph.addNode(7);
+
+    expect(callback).not.toHaveBeenCalled();
+
+    graph.removeNode(1); // trying to remove non-existent node
+
+    expect(callback).not.toHaveBeenCalled();
+
+    graph.removeNode(7);
+
+    expect(callback).toHaveBeenCalledTimes(1);
+    expect(callback).toHaveBeenCalledWith(7, graph);
+
+    graph.removeNode(7); //node was already removed, so we expect nothing to happen
+
+    expect(callback).toHaveBeenCalledTimes(1);
+});
+
+test("check node existence", () => {
+
+    const graph = new Graph();
+
+    expect(graph.hasNode(1)).toBe(false);
+
+    graph.addNode(1);
+
+    expect(graph.hasNode(1)).toBe(true);
+
+});
+
+test("removing node that does not exist", () => {
+    const graph = new Graph();
+
+    expect(graph.removeNode(1)).toBe(false);
+
+});
+
+test("removing same node twice", () => {
+    const graph = new Graph();
+
+    graph.addNode(1);
+
+    expect(graph.removeNode(1)).toBe(true);
+    expect(graph.removeNode(1)).toBe(false);
+});
+
 test("nodeCount", () => {
     const g = new Graph();
 
@@ -19,6 +98,122 @@ test("nodeCount", () => {
     expect(g.nodeCount).toBe(0);
 });
 
+test("findNode on empty graph", () => {
+    const graph = new Graph();
+
+    expect(graph.findNode(n => n === 1)).toBe(undefined);
+});
+
+test("findNode that doesn't exist on graph with 1 node", () => {
+    const graph = new Graph();
+
+    graph.addNode(3);
+
+    expect(graph.findNode(n => n === 1)).toBe(undefined);
+});
+
+test("findNode amongst two", () => {
+    const graph = new Graph();
+
+    graph.addNode(1);
+    graph.addNode(3);
+
+    expect(graph.findNode(n => n === 3)).toBe(3);
+});
+
+test("getNodeDegree", () => {
+
+    const graph = new Graph();
+
+    expect(graph.getNodeDegree(1)).toBe(0);
+
+    graph.addNode(1);
+
+    expect(graph.getNodeDegree(1)).toBe(0);
+
+    graph.addNode(3);
+
+    expect(graph.getNodeDegree(1)).toBe(0);
+    expect(graph.getNodeDegree(3)).toBe(0);
+
+    graph.createEdge(1, 3, EdgeDirectionType.Forward);
+
+    expect(graph.getNodeDegree(1)).toBe(1);
+    expect(graph.getNodeDegree(3)).toBe(1);
+});
+
+test("createEdge", () => {
+    const graph = new Graph();
+
+    graph.addNode(1);
+    graph.addNode(2);
+
+    graph.createEdge(1, 2, EdgeDirectionType.Forward);
+
+    expect(graph.edgeCount).toBe(1);
+
+    expect(graph.edgeExistsBetween(1, 2)).toBe(true);
+});
+
+test("adding edge where one of the nodes is not part of the graph should throw and exception", () => {
+    const graph = new Graph();
+
+    expect(() => graph.addEdge(new Edge(1, 2))).toThrow();
+
+    graph.addNode(1);
+
+    expect(() => graph.addEdge(new Edge(1, 2))).toThrow();
+
+    graph.removeNode(1);
+    graph.addNode(2);
+
+    expect(() => graph.addEdge(new Edge(1, 2))).toThrow();
+});
+
+test("add one valid edge", () => {
+
+    const graph = new Graph();
+
+    graph.addNode(1);
+    graph.addNode(2);
+
+    const edge = new Edge(1, 2);
+    expect(graph.addEdge(edge)).toBe(true);
+
+    expect(graph.hasEdge(edge)).toBe(true);
+
+    expect(graph.edgeCount).toBe(1);
+});
+
+test("add same edge twice", () => {
+
+    const graph = new Graph();
+
+    graph.addNode(1);
+    graph.addNode(2);
+
+    const edge = new Edge(1, 2);
+
+    expect(graph.addEdge(edge)).toBe(true);
+    expect(graph.addEdge(edge)).toBe(false); //already exists
+
+    expect(graph.hasEdge(edge)).toBe(true);
+
+    expect(graph.edgeCount).toBe(1);
+});
+
+test("remove non-existing edge", () => {
+
+    const graph = new Graph();
+
+    graph.addNode(1);
+    graph.addNode(2);
+
+    const edge = new Edge(1, 2);
+
+    expect(graph.removeEdge(edge)).toBe(false);
+});
+
 test("edgeCount", () => {
     const g = new Graph();
 
@@ -54,3 +249,116 @@ test("after removing an edge, neighborhood is properly updated", () => {
     expect(g.getAttachedEdges(t, 1)).toBe(0);
     expect(g.getAttachedEdges(t, 2)).toBe(0);
 });
+
+test("edgeExistsBetween", () => {
+    const graph = new Graph();
+
+    expect(graph.edgeExistsBetween(1, 2)).toBe(false);
+    expect(graph.edgeExistsBetween(2, 1)).toBe(false);
+
+    graph.addNode(1);
+
+    expect(graph.edgeExistsBetween(1, 2)).toBe(false);
+    expect(graph.edgeExistsBetween(2, 1)).toBe(false);
+
+    graph.addNode(2);
+
+    expect(graph.edgeExistsBetween(1, 2)).toBe(false);
+    expect(graph.edgeExistsBetween(2, 1)).toBe(false);
+
+    graph.createEdge(1, 2, EdgeDirectionType.Forward);
+
+    expect(graph.edgeExistsBetween(1, 2)).toBe(true);
+    expect(graph.edgeExistsBetween(2, 1)).toBe(true);
+
+});
+
+test("nodeHasEdges", () => {
+    const graph = new Graph();
+
+    expect(graph.nodeHasEdges(1)).toBe(false);
+
+    graph.addNode(1);
+
+    expect(graph.nodeHasEdges(1)).toBe(false);
+
+    graph.addNode(2);
+
+    expect(graph.nodeHasEdges(1)).toBe(false);
+
+    graph.createEdge(1, 2, EdgeDirectionType.Forward);
+
+    expect(graph.nodeHasEdges(1)).toBe(true);
+    expect(graph.nodeHasEdges(2)).toBe(true);
+});
+
+test("getAnyEdgeBetween", () => {
+
+    const graph = new Graph();
+
+    expect(graph.getAnyEdgeBetween(1, 2)).toBe(undefined);
+    expect(graph.getAnyEdgeBetween(2, 1)).toBe(undefined);
+
+    graph.addNode(1);
+
+    expect(graph.getAnyEdgeBetween(1, 2)).toBe(undefined);
+    expect(graph.getAnyEdgeBetween(2, 1)).toBe(undefined);
+
+    graph.addNode(2);
+
+    expect(graph.getAnyEdgeBetween(1, 2)).toBe(undefined);
+    expect(graph.getAnyEdgeBetween(2, 1)).toBe(undefined);
+
+    const edge = graph.createEdge(1, 2, EdgeDirectionType.Forward);
+
+    expect(graph.getAnyEdgeBetween(1, 2)).toBe(edge);
+    expect(graph.getAnyEdgeBetween(2, 1)).toBe(edge);
+});
+
+test("find path from node to itself", () => {
+    const graph = new Graph();
+
+    graph.addNode(1);
+
+    const path = graph.findPath(1, 1);
+
+    expect(path).toEqual([1]);
+});
+
+test("find path with 2 hops", () => {
+    const graph = new Graph();
+
+    graph.addNode(1);
+    graph.addNode(2);
+    graph.addNode(3);
+
+    graph.createEdge(1, 2, EdgeDirectionType.Forward);
+    graph.createEdge(2, 3, EdgeDirectionType.Forward);
+
+    const path = graph.findPath(1, 3);
+
+    expect(path).toEqual([1, 2, 3]);
+});
+
+test("clear method removes all nodes", () => {
+    const graph = new Graph();
+
+    graph.addNode(1);
+
+    graph.clear();
+
+    expect(graph.nodeCount).toBe(0);
+});
+
+test("clear method removes all edges", () => {
+    const graph = new Graph();
+
+    graph.addNode(1);
+    graph.addNode(2);
+
+    graph.createEdge(1, 2, EdgeDirectionType.Forward);
+
+    graph.clear();
+
+    expect(graph.edgeCount).toBe(0);
+});

package/src/core/math/fract.spec.js

@@ -0,0 +1,11 @@
+import { fract } from "./fract.js";
+
+test("correctness", () => {
+
+    expect(fract(0)).toBeCloseTo(0);
+    expect(fract(0.1)).toBeCloseTo(0.1);
+    expect(fract(-0.1)).toBeCloseTo(-0.1);
+    expect(fract(1.1)).toBeCloseTo(0.1);
+    expect(fract(-1.1)).toBeCloseTo(-0.1);
+
+});

package/src/core/math/isPowerOfTwo.spec.js

@@ -0,0 +1,9 @@
+import { isPowerOfTwo } from "./isPowerOrTwo.js";
+
+test("correctness", () => {
+    expect(isPowerOfTwo(1)).toBe(true);
+    expect(isPowerOfTwo(2)).toBe(true);
+    expect(isPowerOfTwo(3)).toBe(false);
+    expect(isPowerOfTwo(4)).toBe(true);
+    expect(isPowerOfTwo(5)).toBe(false);
+});

package/src/core/math/isPowerOrTwo.js

@@ -1,10 +1,15 @@
+import { assert } from "../assert.js";
+
 /**
  * Is the number a power of two?
  * e.g. 2,4,8,16 etc.
+ * NOTE: only valid for non-negative integers
  * @param {number} value
  * @returns {boolean}
  */
 export function isPowerOfTwo(value) {
+    assert.isNonNegativeInteger(value, 'value');
+
 
     return (value & (value - 1)) === 0 && value !== 0;
 

package/src/core/math/newton_solver_1d.js

@@ -2,7 +2,7 @@
  * Newtonian solver, works by moving along the curve in the direction of gradient
  * @template T
  * @param {function(T):number} f
- * @param {T} xStart
+ * @param {number} xStart
  * @param {number} [max_steps]
  * @param {number} [eps]
  * @returns {number}

package/src/core/math/newton_solver_1d.spec.js

@@ -0,0 +1,9 @@
+import { newton_solver_1d } from "./newton_solver_1d.js";
+
+test("solve for line", () => {
+    expect(newton_solver_1d((x) => x * 2 + 5, 1))
+        .toBeCloseTo(-2.5);
+
+    expect(newton_solver_1d((x) => -x * 7 - 3, 1))
+        .toBeCloseTo(-0.429);
+});

package/src/core/math/pingpong.spec.js

@@ -0,0 +1,11 @@
+import { pingpong } from "./pingpong.js";
+
+test("correctness", () => {
+
+    expect(pingpong(0, 1)).toBe(0);
+    expect(pingpong(0.1, 1)).toBeCloseTo(0.1);
+    expect(pingpong(1, 1)).toBe(1);
+    expect(pingpong(1.1, 1)).toBeCloseTo(0.9);
+    expect(pingpong(2.1, 1)).toBeCloseTo(0.1);
+
+});

package/src/core/math/random/randomBytes.js

@@ -0,0 +1,16 @@
+import { randomUint8 } from "./randomUint8.js";
+
+/**
+ *
+ * @param {Uint8Array} result
+ * @param {number} result_offset
+ * @param {function():number} random
+ * @param {number} count
+ */
+export function randomBytes(result, result_offset, random, count) {
+    for (let i = 0; i < count; i++) {
+
+        result[result_offset + i] = randomUint8(random);
+
+    }
+}

package/src/core/math/random/randomFloatBetween.spec.js

@@ -0,0 +1,8 @@
+import { returnOne, returnZero } from "../../function/Functions.js";
+import { randomFloatBetween } from "./randomFloatBetween.js";
+
+test("limits", () => {
+
+    expect(randomFloatBetween(returnZero, -3.11, 7.23)).toEqual(-3.11);
+    expect(randomFloatBetween(returnOne, -3.11, 7.23)).toEqual(7.23);
+})

package/src/core/math/random/randomFromArray.js

@@ -1,5 +1,5 @@
 import { assert } from "../../assert.js";
-import { min2 } from "../min2.js";
+import { randomIntegerBetween } from "./randomIntegerBetween.js";
 
 /**
  * @template T
@@ -13,7 +13,7 @@ export function randomFromArray(random, array) {
 
     const length = array.length;
 
-    const i = min2(length - 1, Math.floor(random() * length));
+    const index = randomIntegerBetween(random, 0, length - 1);
 
-    return array[i];
+    return array[index];
 }