@woosh/meep-engine 2.84.6 → 2.84.9

package/build/meep.module.js

@@ -2638,35 +2638,32 @@ let Vector3$1 = class Vector3 {
 
     /**
      *
-     * @param {ArrayList<number>|number[]|Float32Array} m4
+     * @param {ArrayLike<number>|number[]|Float32Array} m4
      */
     applyMatrix4(m4) {
         const x = this.x;
         const y = this.y;
         const z = this.z;
 
-        const _x = m4[0] * x + m4[4] * y + m4[8] * z + m4[12];
-        const _y = m4[1] * x + m4[5] * y + m4[9] * z + m4[13];
-        const _z = m4[2] * x + m4[6] * y + m4[10] * z + m4[14];
+        const w = 1 / (m4[3] * x + m4[7] * y + m4[11] * z + m4[15]);
+
+        const _x = (m4[0] * x + m4[4] * y + m4[8] * z + m4[12])* w;
+        const _y = (m4[1] * x + m4[5] * y + m4[9] * z + m4[13])* w;
+        const _z = (m4[2] * x + m4[6] * y + m4[10] * z + m4[14])* w;
 
         this.set(_x, _y, _z);
     }
 
     /**
      * Assume current vector holds a direction, transform using a matrix to produce a new directional unit vector
-     * @param {THREE.Matrix4} m
+     * @param {ArrayLike<number>|number[]|Float32Array} m4
      */
-    transformDirection_three(m) {
-
-        // input: THREE.Matrix4 affine matrix
-        // vector interpreted as a direction
-
+    applyDirectionMatrix4(m4){
         const x = this.x, y = this.y, z = this.z;
-        const e = m.elements;
 
-        const _x = e[0] * x + e[4] * y + e[8] * z;
-        const _y = e[1] * x + e[5] * y + e[9] * z;
-        const _z = e[2] * x + e[6] * y + e[10] * z;
+        const _x = m4[0] * x + m4[4] * y + m4[8] * z;
+        const _y = m4[1] * x + m4[5] * y + m4[9] * z;
+        const _z = m4[2] * x + m4[6] * y + m4[10] * z;
 
         // normalize the result
         const _l = 1 / v3_length(_x, _y, _z);
@@ -2678,6 +2675,20 @@ let Vector3$1 = class Vector3 {
         );
     }
 
+    /**
+     * @deprecated use non-three.js version instead
+     * @param {THREE.Matrix4} m
+     */
+    transformDirection_three(m) {
+
+        // input: THREE.Matrix4 affine matrix
+        // vector interpreted as a direction
+
+        const e = m.elements;
+
+        this.applyDirectionMatrix4(e);
+    }
+
     /**
      *
      * @param {THREE.Matrix3} m
@@ -4741,7 +4752,7 @@ class Transform {
     get forward() {
         const result = Vector3$1.forward.clone();
 
-        result.applyMatrix4(this.matrix);
+        result.applyDirectionMatrix4(this.matrix);
 
         return result;
     }
@@ -47189,44 +47200,8 @@ class SurfacePoint3 {
      */
     applyMatrix4(m) {
 
-        // transform position
-        const p = this.position;
-
-        const p_x = p.x;
-        const p_y = p.y;
-        const p_z = p.z;
-
-        // compute perspective projection
-        const w = 1 / (m[3] * p_x + m[7] * p_y + m[11] * p_z + m[15]);
-
-        const result_p_x = (m[0] * p_x + m[4] * p_y + m[8] * p_z + m[12]) * w;
-        const result_p_y = (m[1] * p_x + m[5] * p_y + m[9] * p_z + m[13]) * w;
-        const result_p_z = (m[2] * p_x + m[6] * p_y + m[10] * p_z + m[14]) * w;
-
-        p.set(
-            result_p_x,
-            result_p_y,
-            result_p_z
-        );
-
-        // transform normal
-        const n = this.normal;
-
-        const n_x = n.x;
-        const n_y = n.y;
-        const n_z = n.z;
-
-        const result_n_x = m[0] * n_x + m[4] * n_y + m[8] * n_z;
-        const result_n_y = m[1] * n_x + m[5] * n_y + m[9] * n_z;
-        const result_n_z = m[2] * n_x + m[6] * n_y + m[10] * n_z;
-
-        const normal_multiplier = 1 / v3_length(result_n_x, result_n_y, result_n_z);
-
-        n.set(
-            result_n_x * normal_multiplier,
-            result_n_y * normal_multiplier,
-            result_n_z * normal_multiplier,
-        );
+        this.position.applyMatrix4(m);
+        this.normal.applyDirectionMatrix4(m);
     }
 
     /**
@@ -61116,6 +61091,7 @@ function objectsEqual(a, b) {
 }
 
 /**
+ * Works similarly to `Array.prototype.indexOf`, but instead of strict equality - uses provided equality method
  * @template T
  * @param {T[]} array
  * @param {T} element
@@ -61219,7 +61195,7 @@ class List {
         this.data = array !== undefined ? array.slice() : [];
 
         /**
-         *
+         * Number of elements in the list
          * @type {number}
          */
         this.length = this.data.length;
@@ -61788,30 +61764,30 @@ class List {
     }
 
     /**
-     *
+     * @deprecated use `#reset` directly in combination with `this.on.removed` signal
      * @param {function(element:T,index:number)} callback
      * @param {*} [thisArg]
      */
     resetViaCallback(callback, thisArg) {
+
         const length = this.length;
-        if (length > 0) {
 
-            const removed = this.on.removed;
+        const removed = this.on.removed;
 
-            const oldElements = this.data;
+        const data = this.data;
 
-            //only signal if there are listeners attached
-            for (let i = length - 1; i >= 0; i--) {
-                const element = oldElements[i];
-                // decrement data length gradually to allow handlers access to the rest of the elements
-                this.data.length = i;
-                this.length = i;
-                removed.send2(element, i);
+        for (let i = length - 1; i >= 0; i--) {
+            const element = data[i];
 
-                callback.call(thisArg, element, i);
-            }
+            // decrement data length gradually to allow handlers access to the rest of the elements
+            data.length = i;
+            this.length = i;
 
+            removed.send2(element, i);
+
+            callback.call(thisArg, element, i);
         }
+
     }
 
     reset() {
@@ -62031,11 +62007,19 @@ class List {
     }
 
     /**
-     *
+     * First element in the list
+     * @returns {T|undefined}
+     */
+    first() {
+        return this.get(0);
+    }
+
+    /**
+     * Last element in the list
      * @return {T|undefined}
      */
     last() {
-        return this.data[this.length - 1];
+        return this.get(this.length - 1);
     }
 
     /**
@@ -63119,10 +63103,11 @@ class WorkerProxy {
     }
 
     /**
+     * Invoke a given method on the worker, as defined by the `WorkerBuilder`
      * @template T
-     * @param {number} name
+     * @param {number} name Method's name
      * @param {Array} args
-     * @return {Promise<T>}
+     * @return {Promise<T>} eventual result of the invoked method
      */
     $submitRequest(name, args) {
         const pending = this.__pending[name];
@@ -63345,6 +63330,10 @@ class WorkerBuilder {
     functions = [];
     preamble = new LineBuilder();
 
+    /**
+     *
+     * @param {string} code
+     */
     addCode(code) {
         this.preamble.add(code);
     }
@@ -79747,28 +79736,19 @@ function m3_cm_compose_transform(
 }
 
 /**
- * @author Alex Goldring, 2018
- * @copyright Alex Goldring 2018
+ * Smallest safe increment for a Float32
+ * @see https://www.cplusplus.com/reference/cfloat/
+ * @see https://bitbashing.io/comparing-floats.html
+ * @type {number}
  */
-
-
-
-const scratch_m3_0 = new Float32Array(9);
-
+const FLT_EPSILON_32 = 1.192092896E-7;
+
 /**
- * @see https://dev.opera.com/articles/understanding-the-css-transforms-matrix/
- * @param domElement
- * @param {Vector2} position
- * @param {Vector2} scale
- * @param {number} rotation angle in radians
+ *
+ * @param {Float32Array} m3
+ * @param {HTMLElement} domElement
  */
-function setElementTransform(domElement, position, scale, rotation) {
-
-    const m3 = scratch_m3_0;
-
-    m3_cm_compose_transform(m3, position.x, position.y, scale.x, scale.y, 0, 0, rotation);
-
-
+function writeCssTransformMatrix(m3, domElement) {
     /*
      * CSS matrix is:
      *      a c e
@@ -79788,7 +79768,13 @@ function setElementTransform(domElement, position, scale, rotation) {
     const style = domElement.style;
 
     style.transform = transform;
-}
+}
+
+/**
+ * @author Alex Goldring, 2018
+ * @copyright Alex Goldring 2018
+ */
+
 
 /**
  *
@@ -79827,6 +79813,9 @@ const INITIAL_FLAGS = ViewFlags.Visible;
  * @class
  */
 class View {
+    #transform_written = new Float32Array(9);
+    #transform_current = new Float32Array(9);
+
     /**
      * @constructor
      */
@@ -79851,31 +79840,32 @@ class View {
         this.flags = INITIAL_FLAGS;
 
         /**
-         *
+         * @readonly
          * @type {Vector2}
          */
         const position = this.position = new Vector2(0, 0);
 
         /**
-         *
+         * @readonly
          * @type {Vector1}
          */
         const rotation = this.rotation = new Vector1(0);
 
         /**
-         *
+         * @readonly
          * @type {Vector2}
          */
         const scale = this.scale = new Vector2(1, 1);
 
         /**
-         *
+         * @readonly
          * @type {Vector2}
          */
         const size = this.size = new Vector2(0, 0);
 
         /**
          * Origin from which rotation and scaling is applied
+         * @readonly
          * @type {Vector2}
          */
         this.transformOrigin = new Vector2(0.5, 0.5);
@@ -80013,7 +80003,41 @@ class View {
      * @private
      */
     __updateTransform() {
-        setElementTransform(this.el, this.position, this.scale, this.rotation.getValue());
+        const position = this.position;
+        const scale = this.scale;
+        const rotation = this.rotation.getValue();
+
+        m3_cm_compose_transform(this.#transform_current, position.x, position.y, scale.x, scale.y, 0, 0, rotation);
+
+        this.#tryWriteTransform();
+    }
+
+    #tryWriteTransform() {
+
+        const current = this.#transform_current;
+        const written = this.#transform_written;
+
+        for (let i = 0; i < 9; i++) {
+            const a = current[i];
+            const b = written[i];
+
+            if (epsilonEquals(a, b, FLT_EPSILON_32)) {
+                // common path
+                continue;
+            }
+
+            this.#writeTransform();
+            return true;
+
+        }
+
+        return false;
+    }
+
+    #writeTransform() {
+        writeCssTransformMatrix(this.#transform_current, this.el);
+
+        this.#transform_written.set(this.#transform_current);
     }
 
     /**
@@ -93077,10 +93101,10 @@ class EntityComponentDataset {
 
     /**
      *
-     * @param {number} entityIndex
+     * @param {number} entity_id
      */
-    removeEntity(entityIndex) {
-        if (!this.entityExists(entityIndex)) {
+    removeEntity(entity_id) {
+        if (!this.entityExists(entity_id)) {
             // entity doesn't exist
             return;
         }
@@ -93088,26 +93112,31 @@ class EntityComponentDataset {
         const componentOccupancy = this.componentOccupancy;
         const typeCount = this.componentTypeCount;
 
-        const occupancyStart = entityIndex * typeCount;
+        const occupancyStart = entity_id * typeCount;
         const occupancyEnd = occupancyStart + typeCount;
 
-        for (let i = componentOccupancy.nextSetBit(occupancyStart); i < occupancyEnd && i !== -1; i = componentOccupancy.nextSetBit(i + 1)) {
+        // remove all components from the entity
+        for (
+            let i = componentOccupancy.nextSetBit(occupancyStart);
+            i < occupancyEnd && i !== -1;
+            i = componentOccupancy.nextSetBit(i + 1)
+        ) {
             const componentIndex = i % typeCount;
-            this.removeComponentFromEntityByIndex_Unchecked(entityIndex, componentIndex, i);
+            this.removeComponentFromEntityByIndex_Unchecked(entity_id, componentIndex, i);
         }
 
         //dispatch event
-        this.sendEvent(entityIndex, EventType.EntityRemoved, entityIndex);
+        this.sendEvent(entity_id, EventType.EntityRemoved, entity_id);
 
         //purge all event listeners
-        delete this.__entityEventListeners[entityIndex];
-        delete this.__entityAnyEventListeners[entityIndex];
+        delete this.__entityEventListeners[entity_id];
+        delete this.__entityAnyEventListeners[entity_id];
 
-        this.entityOccupancy.set(entityIndex, false);
+        this.entityOccupancy.set(entity_id, false);
 
         this.entityCount--;
 
-        this.onEntityRemoved.send1(entityIndex);
+        this.onEntityRemoved.send1(entity_id);
     }
 
     /**
@@ -93157,6 +93186,7 @@ class EntityComponentDataset {
     }
 
     /**
+     * This method doesn't perform any checks, make sure you understand what you are doing when using it
      * @private
      * @param {number} entityIndex
      * @param {number} componentIndex

package/package.json

@@ -5,7 +5,7 @@
   "description": "Fully featured ECS game engine written in JavaScript",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "2.84.6",
+  "version": "2.84.9",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {
@@ -18,6 +18,7 @@
     "./*.md": "./*"
   },
   "scripts": {
+    "test:ci": "jest --config ./jest.conf.json --collectCoverage --coverageDirectory=\"./coverage\" --ci --reporters=default --reporters=jest-junit --watchAll=false",
     "build-module": "rollup -c rollup.config.js",
     "publish-npm": "npm publish"
   },
@@ -34,6 +35,9 @@
     "package.json",
     "README.md"
   ],
+  "optionalDependencies": {
+    "three": "0.136.0"
+  },
   "dependencies": {
     "fastest-levenshtein": "1.0.16",
     "gl-matrix": "3.4.3",
@@ -46,16 +50,17 @@
     "three": ">=0.135.0"
   },
   "devDependencies": {
-    "@babel/core": "7.22.9",
-    "@babel/preset-env": "7.22.9",
+    "@babel/core": "7.22.15",
+    "@babel/preset-env": "7.22.15",
     "@rollup/plugin-commonjs": "25.0.2",
     "@rollup/plugin-node-resolve": "15.1.0",
     "@rollup/plugin-terser": "0.4.3",
     "@rollup/plugin-strip": "3.0.2",
     "@types/three": "^0.135.0",
     "babel-jest": "29.5.0",
-    "jest": "29.5.0",
-    "jest-environment-jsdom": "29.5.0",
+    "jest": "29.6.4",
+    "jest-environment-jsdom": "29.6.4",
+    "jest-junit": "16.0.0",
     "rollup": "3.26.2"
   },
   "keywords": [

package/src/core/cache/LoadingCache.js

@@ -99,9 +99,10 @@ export class LoadingCache {
     /**
      *
      * @param {K} key
+     * @returns {boolean}
      */
     invalidate(key) {
-        this.#internal.remove(key);
+        return this.#internal.remove(key);
     }
 
     /**

package/src/core/cache/LoadingCache.spec.js

@@ -1,5 +1,5 @@
-import { LoadingCache } from "./LoadingCache.js";
 import { delay } from "../process/delay.js";
+import { LoadingCache } from "./LoadingCache.js";
 
 test("successful load", async () => {
     const cache = new LoadingCache({
@@ -11,6 +11,18 @@ test("successful load", async () => {
     expect(await cache.get(1)).toEqual(17);
 });
 
+test("when loader throws an exception, we should get a failed promise", async () => {
+    const cache = new LoadingCache({
+        load(key) {
+            throw 1;
+        }
+    });
+
+    const promise = cache.get("a");
+
+    await expect(promise).rejects.toEqual(1);
+});
+
 test("record reuse", async () => {
     const load = jest.fn(async () => 17);
 

package/src/core/collection/array/arrayIndexByEquality.js

@@ -1,4 +1,5 @@
 /**
+ * Works similarly to `Array.prototype.indexOf`, but instead of strict equality - uses provided equality method
  * @template T
  * @param {T[]} array
  * @param {T} element

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

@@ -43,7 +43,7 @@ class List {
         this.data = array !== undefined ? array.slice() : [];
 
         /**
-         *
+         * Number of elements in the list
          * @type {number}
          */
         this.length = this.data.length;
@@ -628,30 +628,30 @@ class List {
     }
 
     /**
-     *
+     * @deprecated use `#reset` directly in combination with `this.on.removed` signal
      * @param {function(element:T,index:number)} callback
      * @param {*} [thisArg]
      */
     resetViaCallback(callback, thisArg) {
+
         const length = this.length;
-        if (length > 0) {
 
-            const removed = this.on.removed;
+        const removed = this.on.removed;
 
-            const oldElements = this.data;
+        const data = this.data;
 
-            //only signal if there are listeners attached
-            for (let i = length - 1; i >= 0; i--) {
-                const element = oldElements[i];
-                // decrement data length gradually to allow handlers access to the rest of the elements
-                this.data.length = i;
-                this.length = i;
-                removed.send2(element, i);
-
-                callback.call(thisArg, element, i);
-            }
+        for (let i = length - 1; i >= 0; i--) {
+            const element = data[i];
+
+            // decrement data length gradually to allow handlers access to the rest of the elements
+            data.length = i;
+            this.length = i;
 
+            removed.send2(element, i);
+
+            callback.call(thisArg, element, i);
         }
+
     }
 
     reset() {
@@ -875,11 +875,19 @@ class List {
     }
 
     /**
-     *
+     * First element in the list
+     * @returns {T|undefined}
+     */
+    first() {
+        return this.get(0);
+    }
+
+    /**
+     * Last element in the list
      * @return {T|undefined}
      */
     last() {
-        return this.data[this.length - 1];
+        return this.get(this.length - 1);
     }
 
     /**

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

@@ -9,6 +9,18 @@ class DummyNumber {
     equals(o) {
         return o.v === this.v;
     }
+
+    copy(other) {
+        this.v = other.v;
+    }
+
+    clone() {
+        const r = new DummyNumber();
+
+        r.copy(this);
+
+        return r;
+    }
 }
 
 test("constructor doesn't throw", () => {
@@ -254,4 +266,65 @@ test("patch", () => {
 
     expect(list.asArray()).toEqual([3, 1, 2]);
     expect(list.length).toBe(3);
+});
+
+test("equals", () => {
+
+    expect(
+        new List().equals(new List())
+    ).toBe(true);
+
+    expect(
+        new List(["a"]).equals(new List(["a"]))
+    ).toBe(true);
+
+    expect(
+        new List(["a"]).equals(new List(["b"]))
+    ).toBe(false);
+
+    expect(
+        new List(["a", "b"]).equals(new List(["a"]))
+    ).toBe(false);
+
+    expect(
+        new List(["a", "b"]).equals(new List(["b"]))
+    ).toBe(false);
+
+    expect(
+        new List(["a", "b"]).equals(new List(["a", "b"]))
+    ).toBe(true);
+
+});
+
+test("fist", () => {
+
+    expect(new List([1]).first()).toBe(1);
+    expect(new List([1, 2]).first()).toBe(1);
+
+});
+test("last", () => {
+
+    expect(new List([1]).last()).toBe(1);
+    expect(new List([1, 2]).last()).toBe(2);
+
+});
+
+test("deepCopy", () => {
+
+    const a = new List();
+    const b = new List();
+
+    b.deepCopy(a);
+
+    expect(b.isEmpty()).toBe(true);
+
+    const v = new DummyNumber(7);
+    b.addAll([v]);
+
+    a.deepCopy(b);
+
+    expect(a.length).toBe(1);
+    expect(a.first()).toBeDefined();
+    expect(a.first().v).toBe(7);
+    expect(a.first()).not.toBe(v);
 });