@woosh/meep-engine 2.50.2 → 2.51.0

package/src/core/collection/list/List.spec.js

@@ -107,3 +107,96 @@ test("add increases length", () => {
 
     expect(list.length).toBe(2);
 });
+
+
+test("removeIf", () => {
+    const list = new List([1, 3, 1]);
+
+    list.removeIf(a => a === 1);
+
+    expect(list.length).toEqual(1);
+    expect(list.get(0)).toBe(3);
+});
+
+test("removeOneIf", () => {
+    const list = new List([1, 3, 1]);
+
+    list.removeOneIf(a => a === 1);
+
+    expect(list.length).toEqual(2);
+    expect(list.get(0)).toBe(3);
+    expect(list.get(1)).toBe(1);
+});
+
+test("find", () => {
+    const list = new List([1, 3, 1]);
+
+    const a = list.find(a => a === 3);
+
+    expect(a).toEqual(3);
+
+    const b = list.find(a => a === 5);
+
+    expect(b).toBeUndefined();
+});
+
+test("reset", () => {
+    const list = new List([1, 3, 1]);
+
+    list.reset();
+
+    expect(list.length).toEqual(0);
+
+    list.reset(); // test idempotence
+
+    expect(list.length).toEqual(0);
+
+    // check event handlers
+    const remove_callback = jest.fn();
+
+    list.on.removed.add(remove_callback);
+
+    list.add(3);
+
+    list.reset();
+
+    expect(list.length).toEqual(0);
+
+    expect(remove_callback).toHaveBeenCalledTimes(1);
+    expect(remove_callback).toHaveBeenLastCalledWith(3, 0);
+});
+
+test("insert", () => {
+
+    const list = new List();
+
+    const add_callback = jest.fn();
+    list.on.added.add(add_callback);
+
+    list.insert(0, "x");
+
+    expect(list.length).toEqual(1);
+    expect(list.get(0)).toBe("x");
+    expect(add_callback).toHaveBeenLastCalledWith("x", 0);
+
+    list.insert(0, 'y');
+
+    expect(list.length).toEqual(2);
+    expect(list.get(0)).toBe("y");
+    expect(list.get(1)).toBe("x");
+    expect(add_callback).toHaveBeenLastCalledWith("y", 0);
+
+    list.insert(2, "z");
+
+    expect(list.length).toEqual(3);
+    expect(list.get(0)).toBe("y");
+    expect(list.get(1)).toBe("x");
+    expect(list.get(2)).toBe("z");
+    expect(add_callback).toHaveBeenLastCalledWith("z", 2);
+});
+
+test("map", () => {
+    const list = new List([1, 2, 3]);
+
+    expect(list.map(a => a * 7)).toEqual([7, 14, 21]);
+});

package/src/core/collection/map/AsyncLoadingCache.js

@@ -2,6 +2,7 @@ import { AbstractAsyncMap } from "./AbstractAsyncMap.js";
 
 /**
  * Cache wrapper that loads data when it's not found in the cache
+ * @deprecated prefer to use {@link LoadingCache} instead
  */
 export class AsyncLoadingCache extends AbstractAsyncMap {
     /**

package/src/core/fsm/simple/SimpleStateMachine.js

@@ -4,6 +4,28 @@ import { noop } from "../../function/Functions.js";
 import { SimpleStateMachineDescription } from "./SimpleStateMachineDescription.js";
 
 export class SimpleStateMachine {
+
+    /**
+     *
+     * @type {number}
+     * @private
+     */
+    __state = -1;
+
+    /**
+     *
+     * @type {Array}
+     * @private
+     */
+    __eventHandlersStateEntry = [];
+
+    /**
+     *
+     * @type {Array}
+     * @private
+     */
+    __eventHandlersStateExit = [];
+
     /**
      *
      * @param {SimpleStateMachineDescription} description
@@ -16,27 +38,6 @@ export class SimpleStateMachine {
          * @type {SimpleStateMachineDescription}
          */
         this.description = description;
-
-        /**
-         *
-         * @type {number}
-         * @private
-         */
-        this.__state = -1;
-
-        /**
-         *
-         * @type {Array}
-         * @private
-         */
-        this.__eventHandlersStateEntry = [];
-
-        /**
-         *
-         * @type {Array}
-         * @private
-         */
-        this.__eventHandlersStateExit = [];
     }
 
     /**
@@ -212,7 +213,7 @@ export class SimpleStateMachine {
             const targetNodes = description.getOutgoingStates(this.__state);
 
             if (targetNodes.length !== 1) {
-                //no selector, and number of targets is ambiguous
+                //no selector and number of targets is ambiguous
                 return false;
             }
 

package/src/core/function/extractFunctionBody.spec.js

@@ -0,0 +1,15 @@
+import { extractFunctionBody } from "./extractFunctionBody.js";
+
+test("sanity", () => {
+
+    const a = function x(a, b, c) {
+    };
+
+    expect(extractFunctionBody(a)).toBe("");
+
+    const b = function x(a, b, c) {
+        return a + b + c;
+    };
+
+    expect(extractFunctionBody(b)).toBe("return a + b + c;");
+});

package/src/core/geom/2d/convex-hull/convex_hull_monotone_2d.js

@@ -1,82 +1,118 @@
-import { orientation3_v2 } from "./orientation3_v2.js";
+import { assert } from "../../../assert.js";
+import { orientation3_array } from "./orientation3_array.js";
 
 /**
  * Ported from https://github.com/mikolalysenko/monotone-convex-hull-2d
- * @param {number[][]} points
- * @returns {number}
+ * @param {number[]|Float32Array|Float64Array} points
+ * @param {number} [point_count]
+ * @returns {number[]}
  */
-export function convex_hull_monotone_2d(points) {
-    var n = points.length
+export function convex_hull_monotone_2d(points, point_count = points.length * 0.5) {
+    assert.isNumber(point_count, 'point_count');
+    assert.isNonNegativeInteger(point_count, 'point_count');
 
-    if (n < 3) {
-        var result = new Array(n)
-        for (var i = 0; i < n; ++i) {
-            result[i] = i
-        }
+    if (point_count < 3) {
+
+        if (
+            point_count === 2
+            && points[0] === points[2]
+            && points[1] === points[3]
+        ) {
 
-        if (n === 2 &&
-            points[0][0] === points[1][0] &&
-            points[0][1] === points[1][1]) {
             return [0]
+
+        }
+
+        const result = new Array(point_count)
+
+        for (let i = 0; i < point_count; ++i) {
+            result[i] = i
         }
 
         return result
     }
 
     //Sort point indices along x-axis
-    var sorted = new Array(n)
-    for (var i = 0; i < n; ++i) {
+    const sorted = new Array(point_count)
+
+    for (let i = 0; i < point_count; ++i) {
         sorted[i] = i
     }
+
     sorted.sort(function (a, b) {
-        var d = points[a][0] - points[b][0]
+        const a2 = a * 2;
+        const b2 = b * 2;
+
+        var d = points[a2] - points[b2]
+
         if (d) {
             return d
         }
-        return points[a][1] - points[b][1]
+
+        return points[a2 + 1] - points[b2 + 1]
     })
 
     //Construct upper and lower hulls
-    var lower = [sorted[0], sorted[1]]
-    var upper = [sorted[0], sorted[1]]
+    const lower = [sorted[0], sorted[1]]
+    const upper = [sorted[0], sorted[1]]
 
-    for (var i = 2; i < n; ++i) {
-        var idx = sorted[i]
-        var p = points[idx]
+    for (let i = 2; i < point_count; ++i) {
+        const idx = sorted[i]
 
         //Insert into lower list
-        var m = lower.length
-        while (m > 1 && orientation3_v2(
-            points[lower[m - 2]],
-            points[lower[m - 1]],
-            p) <= 0) {
+        let m = lower.length
+
+        while (
+            m > 1
+            && orientation3_array(
+                points,
+                lower[m - 2],
+                lower[m - 1],
+                idx) <= 0
+            ) {
+
             m -= 1
             lower.pop()
+
         }
+
         lower.push(idx)
 
         //Insert into upper list
         m = upper.length
-        while (m > 1 && orientation3_v2(
-            points[upper[m - 2]],
-            points[upper[m - 1]],
-            p) >= 0) {
+
+        while (
+            m > 1
+            && orientation3_array(
+                points,
+                upper[m - 2],
+                upper[m - 1],
+                idx) >= 0
+            ) {
+
             m -= 1
             upper.pop()
+
         }
+
         upper.push(idx)
+
     }
 
     //Merge lists together
-    var result = new Array(upper.length + lower.length - 2)
-    var ptr = 0
+    const result = new Array(upper.length + lower.length - 2)
+
+    let ptr = 0
+
     for (var i = 0, nl = lower.length; i < nl; ++i) {
         result[ptr++] = lower[i]
     }
+
     for (var j = upper.length - 2; j > 0; --j) {
         result[ptr++] = upper[j]
     }
 
+
     //Return result
     return result
 }

package/src/core/geom/2d/convex-hull/convex_hull_monotone_2d.spec.js

@@ -0,0 +1,33 @@
+import { convex_hull_monotone_2d } from "./convex_hull_monotone_2d.js";
+
+test("box with extra points", () => {
+    const hull = convex_hull_monotone_2d([
+        0, 1,
+        -1, 0,
+        1, 0,
+        0, -1,
+        // extra points inside
+        0.3, 0.3,
+        -0.3, -0.3,
+        0.3, -0.3,
+        -0.3, 0.3
+    ]);
+
+    expect(hull.length).toBe(4);
+
+    expect(hull).toContain(0);
+    expect(hull).toContain(1);
+    expect(hull).toContain(2);
+    expect(hull).toContain(3);
+});
+
+
+test("exact triangle", () => {
+    const hull = convex_hull_monotone_2d([
+        0, 0,
+        1, 0,
+        1, 1,
+    ]);
+
+    expect(hull.length).toBe(3);
+});

package/src/core/geom/2d/convex-hull/orientation3.js

@@ -4,6 +4,12 @@ const sum = linearExpansionSum;
 const prod = robustProduct;
 const sub = robustSubtract;
 
+/**
+ *
+ * @param {number[]} e
+ * @param {number[]} f
+ * @return {number[]}
+ */
 function robustSubtract(e, f) {
     var ne = e.length;
     var nf = f.length;
@@ -141,14 +147,24 @@ function robustSubtract(e, f) {
     return g
 }
 
+/**
+ *
+ * @param {number[]} a
+ * @param {number[]} b
+ * @return {number[]}
+ */
 function robustProduct(a, b) {
     let r = [0]
-    if (a.length < b.length) {
-        for (var i = 0; i < a.length; ++i) {
+
+    const a_count = a.length;
+    const b_count = b.length;
+
+    if (a_count < b_count) {
+        for (let i = 0; i < a_count; ++i) {
             r = linearExpansionSum(r, scaleLinearExpansion(b, a[i]))
         }
     } else {
-        for (var i = 0; i < b.length; ++i) {
+        for (let i = 0; i < b_count; ++i) {
             r = linearExpansionSum(r, scaleLinearExpansion(a, b[i]))
         }
     }
@@ -157,6 +173,13 @@ function robustProduct(a, b) {
 
 var SPLITTER = +(Math.pow(2, 27) + 1.0)
 
+/**
+ *
+ * @param {number} a
+ * @param {number} b
+ * @param {number[]} [result]
+ * @return {number[]}
+ */
 function twoProduct(a, b, result) {
     var x = a * b
 
@@ -185,6 +208,13 @@ function twoProduct(a, b, result) {
     return [y, x]
 }
 
+/**
+ *
+ * @param {number[]} a
+ * @param {number[]} b
+ * @param {number[]} result
+ * @return {number[]}
+ */
 function twoSum(a, b, result) {
     var x = a + b
     var bv = x - a
@@ -199,6 +229,12 @@ function twoSum(a, b, result) {
     return [ar + br, x]
 }
 
+/**
+ *
+ * @param {number[]} e
+ * @param {number} scale
+ * @return {number[]}
+ */
 function scaleLinearExpansion(e, scale) {
     var n = e.length
     if (n === 1) {
@@ -388,16 +424,25 @@ function linearExpansionSum(e, f) {
 
 /**
  *
- * @param {number[]} m0
- * @param {number[]} m1
- * @param {number[]} m2
+ * @param {number[][]} m0
+ * @param {number[][]} m1
+ * @param {number[][]} m2
  * @returns {number}
  */
 function orientation3Exact(m0, m1, m2) {
-    const p = sum(sum(prod(m1[1], m2[0]), prod(-m2[1], m1[0])), sum(prod(m0[1], m1[0]), prod(-m1[1], m0[0])))
-    const n = sum(prod(m0[1], m2[0]), prod(-m2[1], m0[0]))
-    const d = sub(p, n)
-    return d[d.length - 1]
+    const p = sum(
+        sum(prod(m1[1], m2[0]), prod(-m2[1], m1[0])),
+        sum(prod(m0[1], m1[0]), prod(-m1[1], m0[0]))
+    );
+
+    const n = sum(
+        prod(m0[1], m2[0]),
+        prod(-m2[1], m0[0])
+    );
+
+    const d = sub(p, n);
+
+    return d[d.length - 1];
 }
 
 /**

package/src/core/geom/2d/quad-tree/PointQuadTree.js

@@ -170,7 +170,17 @@ class PointQuadTree {
         this.br = undefined;
     }
 
+    /**
+     *
+     * @param {T} p
+     * @param {number} x
+     * @param {number} y
+     * @return {Element}
+     */
     insert(p, x, y) {
+        assert.isNumber(x, 'x');
+        assert.isNumber(y, 'y');
+
         const element = new Element(p, x, y);
 
         this.resizeToFit(x, y); //adjust size if needed

package/src/core/geom/3d/aabb/aabb3_array_combine.js

@@ -5,9 +5,9 @@ import { max2 } from "../../../math/max2.js";
 
 /**
  * Merge bounds of two axis-aligned bounding boxes, the result is a box that tightly bounds inputs
- * @param {ArrayLike<number>|number[]} result where resulting value is written to
- * @param {ArrayLike<number>|number[]} a
- * @param {ArrayLike<number>|number[]} b
+ * @param {ArrayLike<number>|number[]|Float32Array} result where resulting value is written to
+ * @param {ArrayLike<number>|number[]|Float32Array} a
+ * @param {ArrayLike<number>|number[]|Float32Array} b
  */
 export function aabb3_array_combine(result, a, b) {
     result[0] = min2(a[0], b[0]);

package/src/core/graph/{convertGraphToDotString.js → convert_graph_to_dot_string.js}

@@ -13,7 +13,7 @@ function defaultNodeToDot(node){
  * @param {function(Node):string} nodeToDot
  * @returns {string}
  */
-export function convertGraphToDotString({
+export function convert_graph_to_dot_string({
                                             graph,
                                             nodeToDot=defaultNodeToDot
 }) {

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

@@ -0,0 +1,28 @@
+import { convert_graph_to_dot_string } from "./convert_graph_to_dot_string.js";
+import { Graph } from "./v2/Graph.js";
+import { EdgeDirectionType } from "./Edge.js";
+
+test("empty graph should produce valid string", () => {
+    const dot = convert_graph_to_dot_string({
+        graph: new Graph()
+    });
+
+    expect(typeof dot).toEqual("string");
+    expect(dot.trim().length).toBeGreaterThan(0);
+});
+
+test("graph with 2 nodes and an edge should produce valid string", () => {
+    const graph = new Graph();
+
+    graph.addNode(1);
+    graph.addNode(2);
+
+    graph.createEdge(1, 2, EdgeDirectionType.Forward);
+
+    const dot = convert_graph_to_dot_string({
+        graph: graph
+    });
+
+    expect(typeof dot).toEqual("string");
+    expect(dot.trim().length).toBeGreaterThan(0);
+});

package/src/core/math/noise/sdnoise.js

@@ -195,7 +195,7 @@ function grad4(result, hash) {
  * @param {number[]} derivatives
  * @returns {number}
  */
-function sdnoise1(derivatives, x) {
+export function sdnoise1(derivatives, x) {
     const i0 = x | 0;
     const i1 = i0 + 1;
 
@@ -207,8 +207,7 @@ function sdnoise1(derivatives, x) {
     let t1, t20, t40, t21, t41, x21;
 
     const x20 = x0 * x0;
-    const t0 = 1.0
-    f - x20;
+    const t0 = 1.0 - x20;
 //  if(t0 < 0.0f) t0 = 0.0f; // Never happens for 1D: x0<=1 always
     t20 = t0 * t0;
     t40 = t20 * t20;
@@ -218,8 +217,7 @@ function sdnoise1(derivatives, x) {
     n0 = t40 * gx0 * x0;
 
     x21 = x1 * x1;
-    t1 = 1.0
-    f - x21;
+    t1 = 1.0 - x21;
 //  if(t1 < 0.0f) t1 = 0.0f; // Never happens for 1D: |x1|<=1 always
     t21 = t1 * t1;
     t41 = t21 * t21;
@@ -265,7 +263,7 @@ const G2 = 0.21132486540518713;
  * @param {number[]} derivatives
  * @returns {number}
  */
-function sdnoise2(derivatives, x, y) {
+export function sdnoise2(derivatives, x, y) {
     let n0, n1, n2; /* Noise contributions from the three simplex corners */
     let gx0, gy0, gx1, gy1, gx2, gy2; /* Gradients at simplex corners */
     let t0, t1, t2, x1, x2, y1, y2;
@@ -280,7 +278,7 @@ function sdnoise2(derivatives, x, y) {
     let ii, i = xs | 0;
     let jj, j = ys | 0;
 
-    const t = (float)(i + j) * G2;
+    const t = (i + j) * G2;
     const X0 = i - t; /* Unskew the cell origin back to (x,y) space */
     const Y0 = j - t;
     const x0 = x - X0; /* The x,y distances from the cell origin */

package/src/core/math/noise/sdnoise.spec.js

@@ -0,0 +1,87 @@
+import { sdnoise1, sdnoise2, sdnoise3, sdnoise4 } from "./sdnoise.js";
+
+describe("sdnoise1", () => {
+    test("sanity", () => {
+        const derivatives = [];
+
+        const value = sdnoise1(derivatives, 0);
+
+        expect(typeof value).toBe("number");
+        expect(value).not.toBeNaN();
+
+        expect(derivatives.length).toEqual(1);
+
+        expect(typeof derivatives[0]).toBe("number");
+        expect(derivatives[0]).not.toBeNaN();
+
+    });
+});
+
+describe("sdnoise2", () => {
+    test("sanity", () => {
+        const derivatives = [];
+
+        const value = sdnoise2(derivatives, 0, 0);
+
+        expect(typeof value).toBe("number");
+        expect(value).not.toBeNaN();
+
+        expect(derivatives.length).toEqual(2);
+
+        expect(typeof derivatives[0]).toBe("number");
+        expect(derivatives[0]).not.toBeNaN();
+
+        expect(typeof derivatives[1]).toBe("number");
+        expect(derivatives[1]).not.toBeNaN();
+
+    });
+});
+
+describe("sdnoise3", () => {
+    test("sanity", () => {
+        const derivatives = [];
+
+        const value = sdnoise3(derivatives, 0, 0, 0);
+
+        expect(typeof value).toBe("number");
+        expect(value).not.toBeNaN();
+
+        expect(derivatives.length).toEqual(3);
+
+        expect(typeof derivatives[0]).toBe("number");
+        expect(derivatives[0]).not.toBeNaN();
+
+        expect(typeof derivatives[1]).toBe("number");
+        expect(derivatives[1]).not.toBeNaN();
+
+        expect(typeof derivatives[2]).toBe("number");
+        expect(derivatives[2]).not.toBeNaN();
+
+    });
+});
+
+describe("sdnoise4", () => {
+    test("sanity", () => {
+        const derivatives = [];
+
+        const value = sdnoise4(derivatives, 0, 0, 0, 0);
+
+        expect(typeof value).toBe("number");
+        expect(value).not.toBeNaN();
+
+        expect(derivatives.length).toEqual(4);
+
+        expect(typeof derivatives[0]).toBe("number");
+        expect(derivatives[0]).not.toBeNaN();
+
+        expect(typeof derivatives[1]).toBe("number");
+        expect(derivatives[1]).not.toBeNaN();
+
+        expect(typeof derivatives[2]).toBe("number");
+        expect(derivatives[2]).not.toBeNaN();
+
+        expect(typeof derivatives[3]).toBe("number");
+        expect(derivatives[3]).not.toBeNaN();
+
+    });
+});