@woosh/meep-engine 2.50.1 → 2.50.3

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/process/matcher/Matchers.js

@@ -25,7 +25,7 @@ export function isDefined(value) {
 
 /**
  * performs instanceof match
- * @param {class} type
+ * @param {function} type
  * @returns {function(*): boolean}
  */
 export function isInstanceOf(type) {

package/src/engine/asset/loaders/image/png/PNG.spec.js

@@ -0,0 +1,5 @@
+import { PNG } from "./PNG.js";
+
+test("constructor does not throw", () => {
+    expect(() => new PNG()).not.toThrow()
+});

package/src/engine/asset/loaders/image/png/PNGReader.spec.js

@@ -0,0 +1,5 @@
+import { PNGReader } from "./PNGReader.js";
+
+test("constructor does not throw", () => {
+    expect(() => new PNGReader(new ArrayBuffer(0))).not.toThrow();
+});

package/src/engine/asset/loaders/image/png/crc.spec.js

@@ -0,0 +1,15 @@
+import { crc } from "./crc.js";
+
+test("sanity", () => {
+
+    const empty = crc(new Uint8Array(0), 0, 0);
+
+    expect(typeof empty).toBe("number");
+    expect(Number.isInteger(empty)).toBe(true);
+
+    const one = crc(new Uint8Array([1]), 0, 1);
+
+    expect(typeof one).toBe("number");
+    expect(Number.isInteger(one)).toBe(true);
+
+});

package/src/engine/ecs/EntityBlueprint.js

@@ -56,6 +56,10 @@ function populateJsonTemplate(template, seed) {
     }
 }
 
+/**
+ * Template for instantiating entities
+ * @class
+ */
 export class EntityBlueprint {
     constructor() {
         /**

package/src/engine/ecs/EntityBuilder.js

@@ -15,59 +15,58 @@ const DEFAULT_FLAGS =
 
 /**
  * Representation of an entity, helps build entities and keep track of them without having to access {@link EntityComponentDataset} directly
+ * @class
  */
 class EntityBuilder {
+
+    /**
+     * @type {number}
+     */
+    entity = void 0;
+
+    /**
+     * Generation is a unique identifier coming from the dataset
+     * Generation of an existing entity must match for it to be considered "the same"
+     * @type {number}
+     */
+    generation = -1;
+
     /**
      *
-     * @constructor
+     * @type {Array}
      */
-    constructor() {
-        /**
-         * @type {number}
-         */
-        this.entity = void 0;
-
-        /**
-         * Generation is a unique identifier coming from the dataset
-         * Generation of an existing entity must match for it to be considered "the same"
-         * @type {number}
-         */
-        this.generation = -1;
-
-        /**
-         *
-         * @type {Array}
-         */
-        this.element = [];
-
-        /**
-         *
-         * @type {{name:string,listener:(function|Function), context:*}[]}
-         */
-        this.deferredListeners = [];
-
-        /**
-         *
-         * @type {EntityComponentDataset}
-         */
-        this.dataset = null;
-
-        /**
-         *
-         * @type {EntityBuilderFlags|number}
-         */
-        this.flags = DEFAULT_FLAGS;
-
-        /**
-         *
-         * @type {Object}
-         */
-        this.properties = {};
-
-        this.on = {
-            built: new Signal()
-        };
-    }
+    element = [];
+
+    /**
+     *
+     * @type {{name:string,listener:(function|Function), context:*}[]}
+     */
+    deferredListeners = [];
+
+    /**
+     *
+     * @type {EntityComponentDataset}
+     */
+    dataset = null;
+
+    /**
+     *
+     * @type {EntityBuilderFlags|number}
+     */
+    flags = DEFAULT_FLAGS;
+
+    /**
+     *
+     * @type {Object}
+     */
+    properties = {};
+
+    /**
+     * @readonly
+     */
+    on = {
+        built: new Signal()
+    };
 
     /**
      * Handles event when entity is removed without invoking {@link #destroy} method
@@ -200,7 +199,7 @@ class EntityBuilder {
 
     /**
      *
-     * @param {class} klass
+     * @param {function} klass
      * @returns {*|null}
      */
     removeComponent(klass) {

package/src/engine/ecs/EntityBuilderFlags.js

@@ -8,11 +8,11 @@ export const EntityBuilderFlags = {
      */
     Built: 1,
     /**
-     * If component type is not registered on the {@link EntityComponentDataset} when calling {@link #build} - will register the component first
+     * If component type is not registered on the {@link EntityComponentDataset} when calling {@link EntityBuilder#build} - will register the component first
      */
     RegisterComponents: 2,
     /**
-     * Entity builder will watch destruction of the entity (subscribe to event), this will make the EntityBuilder automatically
+     * Entity builder will watch destruction of the entity (subscribe to event), this will make the {@link EntityBuilder} automatically
      * recognize when the corresponding entity is destroyed outside the EntityBuilder API
      * NOTE: useful to turn off to save a bit of memory, as those event listeners take up a bit of space. Feel free to turn this flag off when you don't care to keep the reference to the EntityBuilder
      */

package/src/engine/ecs/guid/GUID.js

@@ -23,6 +23,7 @@ let _clockseq = ((randomUint8(random) << 8) | randomUint8(random)) & 0x3fff;
 
 /**
  * Globally unique identifier
+ * @class
  */
 export class GUID {
     #data = new Uint8Array(16);

package/src/engine/ecs/{Blueprint.js → storage/json/Blueprint.js}

@@ -4,7 +4,7 @@
 
 
 import EntityFactory from './EntityFactory.js';
-import { FunctionCompiler } from "../../core/function/FunctionCompiler.js";
+import { FunctionCompiler } from "../../../../core/function/FunctionCompiler.js";
 
 function Blueprint() {
     this.element = [];