@woosh/meep-engine 2.84.5 → 2.84.8

package/build/meep.cjs

@@ -61118,6 +61118,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
@@ -61221,7 +61222,7 @@ class List {
         this.data = array !== undefined ? array.slice() : [];
 
         /**
-         *
+         * Number of elements in the list
          * @type {number}
          */
         this.length = this.data.length;
@@ -61271,7 +61272,7 @@ class List {
         this.data.push(el);
         const oldLength = this.length;
 
-        this.length++;
+        this.length = oldLength + 1;
 
         this.on.added.send2(el, oldLength);
         return this;
@@ -61790,30 +61791,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 data = this.data;
 
-            const oldElements = this.data;
+        for (let i = length - 1; i >= 0; i--) {
+            const element = data[i];
 
-            //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);
+            // decrement data length gradually to allow handlers access to the rest of the elements
+            data.length = i;
+            this.length = i;
 
-                callback.call(thisArg, element, i);
-            }
+            removed.send2(element, i);
 
+            callback.call(thisArg, element, i);
         }
+
     }
 
     reset() {
@@ -62033,11 +62034,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);
     }
 
     /**
@@ -63121,10 +63130,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];
@@ -63347,6 +63357,10 @@ class WorkerBuilder {
     functions = [];
     preamble = new LineBuilder();
 
+    /**
+     *
+     * @param {string} code
+     */
     addCode(code) {
         this.preamble.add(code);
     }
@@ -79749,28 +79763,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
@@ -79790,7 +79795,13 @@ function setElementTransform(domElement, position, scale, rotation) {
     const style = domElement.style;
 
     style.transform = transform;
-}
+}
+
+/**
+ * @author Alex Goldring, 2018
+ * @copyright Alex Goldring 2018
+ */
+
 
 /**
  *
@@ -79829,6 +79840,9 @@ const INITIAL_FLAGS = ViewFlags.Visible;
  * @class
  */
 class View {
+    #transform_written = new Float32Array(9);
+    #transform_current = new Float32Array(9);
+
     /**
      * @constructor
      */
@@ -79853,31 +79867,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);
@@ -80015,7 +80030,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);
     }
 
     /**
@@ -93079,10 +93128,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;
         }
@@ -93090,26 +93139,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);
     }
 
     /**
@@ -93159,6 +93213,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
@@ -96086,40 +96141,38 @@ LinearValue.prototype.fromJSON = function (json) {
 
 /**
  *
- * @param {number} x
- * @param {string} [separator=',']
+ * @param {string} string
+ * @param {string} trailing_sequence
  * @returns {string}
  */
-function number_format_by_thousands(x, separator = ',') {
+function string_strip_trailing(string, trailing_sequence) {
+    const trailing_sequence_length = trailing_sequence.length;
 
-    return x.toString().replace(/\B(?=(\d{3})+(?!\d))/g, separator);
+    if (trailing_sequence_length <= 0) {
+        // special case to avoid infinite looping
+        return string;
+    }
+
+    let end_index = string.length;
+
+    while (string.substring(end_index - trailing_sequence_length, end_index) === trailing_sequence) {
+        end_index -= trailing_sequence_length;
+    }
+
+    return string.substring(0, end_index);
 }
 
 /**
  *
- * @param {string} value
- * @returns {number}
+ * @param {number} x
+ * @param {string} [separator=',']
+ * @returns {string}
  */
-function countDecimals(value) {
-    if (value % 1 === 0) {
-        //whole number
-        return 0;
-    }
-    const s = value.toString();
-    const index = s.indexOf('.');
-
-    if (index === -1) {
-        return 0;
-    }
-
-    //find last 0
-    let endIndex = s.length - 1;
-    for (; endIndex > index && s.charAt(endIndex) === "0"; endIndex--) {
-
-    }
-    return endIndex - index;
-}
+function number_format_by_thousands(x, separator = ',') {
 
+    return x.toString().replace(/\B(?=(\d{3})+(?!\d))/g, separator);
+}
+
 /**
  *
  * @param {number} value
@@ -96130,10 +96183,12 @@ function number_pretty_print(value) {
     const MAX_DECIMALS = 2;
 
     const fraction = value % 1;
-    if (fraction !== 0 && Math.abs(value) < 100) {
-        const decimals = countDecimals(value.toFixed(MAX_DECIMALS));
-        const decimalsToPrint = Math.min(decimals, MAX_DECIMALS);
-        return value.toFixed(decimalsToPrint);
+
+    const would_produce_decimals = fraction * Math.pow(10, MAX_DECIMALS) > 0;
+
+    if (would_produce_decimals && Math.abs(value) < 100) {
+        const truncated = value.toFixed(MAX_DECIMALS);
+        return string_strip_trailing(truncated, "0");
     } else {
         //no fraction
         return number_format_by_thousands(value - fraction, ",");