@woosh/meep-engine 2.109.24 → 2.109.26

package/build/meep.module.js

@@ -71547,6 +71547,23 @@ class EntityObserver {
     }
 }
 
+/**
+ * Given an object and a value, find the first property with matching value and returns name of that property
+ * Useful for working with ENUM-like objects
+ * @param {Object<T>} object
+ * @param {T} value
+ * @returns {string|undefined} name of the property, or undefined if property not found
+ */
+function objectKeyByValue(object, value) {
+    for (let i in object) {
+        if (object[i] === value) {
+            return i;
+        }
+    }
+
+    return undefined;
+}
+
 /**
  *
  * @enum {number}
@@ -71663,6 +71680,10 @@ class Edge {
         return [this.first, this.second];
     }
 
+    toString() {
+        return `Edge:{ first=${this.first}, second=${this.second}, direction=${objectKeyByValue(EdgeDirectionType, this.direction)} }`
+    }
+
 }
 
 /**
@@ -78580,23 +78601,6 @@ class ShadedGeometrySystem extends System {
     }
 }
 
-/**
- * Given an object and a value, find the first property with matching value and returns name of that property
- * Useful for working with ENUM-like objects
- * @param {Object<T>} object
- * @param {T} value
- * @returns {string|undefined} name of the property, or undefined if property not found
- */
-function objectKeyByValue(object, value) {
-    for (let i in object) {
-        if (object[i] === value) {
-            return i;
-        }
-    }
-
-    return undefined;
-}
-
 /**
  *
  * @enum {string}
@@ -84588,10 +84592,23 @@ class ViewStack extends View {
 }
 
 /**
- * Min-Heap implementation with a score function. The data structure is a binary heap where elements are removed in order defined by scoring function
+ * Min-Heap implementation with a score function.
+ * The data structure is a binary heap where elements are removed in order defined by scoring function
  * @template T
  */
 class BinaryHeap {
+    /**
+     * @private
+     * @type {T[]}
+     */
+    data = [];
+
+    /**
+     * @private
+     * @type {number}
+     */
+    length = 0;
+
     /**
      * @template T
      * @param {function(el:T):number} scoreFunction
@@ -84605,17 +84622,6 @@ class BinaryHeap {
          */
         this.scoreFunction = scoreFunction;
 
-        /**
-         *
-         * @type {T[]}
-         */
-        this.data = [];
-
-        /**
-         * @private
-         * @type {number}
-         */
-        this.length = 0;
     }
 
     /**
@@ -84685,19 +84691,19 @@ class BinaryHeap {
             if (right >= length) {
                 //right node doesn't exist
 
-
                 if (scoreLeft >= scoreMin) {
                     break;
                 } else {
                     minIndex = left;
                     dataMin = dataLeft;
                 }
+
             } else {
+
                 //both left and right nodes exist
                 const dataRight = data[right];
                 const scoreRight = this.scoreFunction(dataRight);
 
-                //
                 if (scoreLeft <= scoreRight) {
                     if (scoreLeft >= scoreMin) {
                         break;
@@ -84713,6 +84719,7 @@ class BinaryHeap {
                         dataMin = dataRight;
                     }
                 }
+
             }
 
             //swap positions
@@ -84730,7 +84737,6 @@ class BinaryHeap {
      */
     pop() {
 
-
         this.length--;
 
         const new_length = this.length;
@@ -84739,19 +84745,20 @@ class BinaryHeap {
 
         if (new_length === 0) {
 
+            // this was the last element in the heap
+
             return last;
 
-        } else {
+        }
 
-            const ret = this.data[0];
+        const ret = this.data[0];
 
-            this.data[0] = last;
+        this.data[0] = last;
 
-            this.bubbleDown(0);
+        this.bubbleDown(0);
 
-            return ret;
+        return ret;
 
-        }
     }
 
     /**
@@ -84853,7 +84860,14 @@ class BinaryHeap {
 
         this.bubbleUp(position);
     }
-}
+}
+
+/**
+ * Useful for type checks
+ * @readonly
+ * @type {boolean}
+ */
+BinaryHeap.prototype.isBinaryHeap = true;
 
 /**
  * Decorator that wraps another map and lets you observe mutations
@@ -91137,6 +91151,59 @@ class InputDeviceSwitch {
      * @type {boolean}
      */
     is_down = false
+
+    press() {
+        if (this.is_down) {
+            return;
+        }
+
+        this.is_down = true;
+        this.down.send0();
+    }
+
+    release() {
+        if (!this.is_down) {
+            return;
+        }
+
+        this.is_down = false;
+        this.up.send0();
+    }
+}
+
+/**
+ *
+ * @param thing
+ * @param klass
+ * @returns {boolean}
+ */
+function isInstanceOf$1(thing, klass) {
+    if (klass === undefined) {
+        return false;
+    }
+    if (klass === null) {
+        return false;
+    }
+
+    if (typeof klass !== "object") {
+        return false;
+    }
+
+
+    return thing instanceof klass;
+}
+
+/**
+ * Based on the article about focusable events: https://stackoverflow.com/questions/1599660/which-html-elements-can-receive-focus
+ * @param {Element} el
+ */
+function isHTMLElementFocusable(el) {
+    return isInstanceOf$1(el, HTMLInputElement)
+        || isInstanceOf$1(el, HTMLSelectElement)
+        || isInstanceOf$1(el, HTMLTextAreaElement)
+        || isInstanceOf$1(el, HTMLAnchorElement)
+        || isInstanceOf$1(el, HTMLButtonElement)
+        || isInstanceOf$1(el, HTMLAreaElement)
 }
 
 /**
@@ -91246,41 +91313,6 @@ const KeyCodes = {
     'back_quote': 223
 };
 
-/**
- *
- * @param thing
- * @param klass
- * @returns {boolean}
- */
-function isInstanceOf$1(thing, klass) {
-    if (klass === undefined) {
-        return false;
-    }
-    if (klass === null) {
-        return false;
-    }
-
-    if (typeof klass !== "object") {
-        return false;
-    }
-
-
-    return thing instanceof klass;
-}
-
-/**
- * Based on the article about focusable events: https://stackoverflow.com/questions/1599660/which-html-elements-can-receive-focus
- * @param {Element} el
- */
-function isFocusable(el) {
-    return isInstanceOf$1(el, HTMLInputElement)
-        || isInstanceOf$1(el, HTMLSelectElement)
-        || isInstanceOf$1(el, HTMLTextAreaElement)
-        || isInstanceOf$1(el, HTMLAnchorElement)
-        || isInstanceOf$1(el, HTMLButtonElement)
-        || isInstanceOf$1(el, HTMLAreaElement)
-}
-
 /**
  * @readonly
  * @type {string[]}
@@ -91313,7 +91345,7 @@ class KeyboardDevice {
         Only element in focus receives keyboard events, so the element supplied here must be focusable in order to be able to receive events
          */
         if (
-            !isFocusable(domElement)
+            !isHTMLElementFocusable(domElement)
             && domElement.getAttribute('tabindex') === null
         ) ;
 
@@ -91357,9 +91389,7 @@ class KeyboardDevice {
         if (keyName !== undefined) {
             const button = this.keys[keyName];
 
-            button.is_down = true;
-            button.down.send1(event);
-
+            button.press();
         }
     }
 
@@ -91379,8 +91409,7 @@ class KeyboardDevice {
         if (keyName !== undefined) {
             const button = this.keys[keyName];
 
-            button.is_down = false;
-            button.up.send1(event);
+            button.release();
         }
     }
 
@@ -91395,6 +91424,43 @@ class KeyboardDevice {
     }
 }
 
+/**
+ *
+ * @param {TouchEvent|MouseEvent} event
+ * @returns {number}
+ */
+function eventToSourceIdentifier(event) {
+    let device_id = 0;
+    let source_id = 0;
+
+    if (event instanceof MouseEvent) {
+
+        // mouse
+
+        device_id = 1;
+        source_id = event.button;
+
+    } else if (event instanceof TouchEvent) {
+
+        // touch
+
+        device_id = 2;
+        const touches = event.changedTouches;
+        const num_changes = touches.length;
+
+        if (num_changes > 0) {
+            const touch = touches.item(0);
+
+            source_id = touch.identifier;
+        }
+
+    }
+
+    return ((device_id & 0b11) << 29)
+        | (source_id & 0b11111111111111111111111111111)
+        ;
+}
+
 /**
  * Event names for DOM {@link EventTarget} related to mouse.
  * useful for .addEventListener and .removeEventListener
@@ -91427,6 +91493,23 @@ const TouchEvents = {
     Cancel: "touchcancel",
 };
 
+class LocationalInteractionMetadata {
+    timestamp = performance.now()
+    position = new Vector2()
+
+    /**
+     *
+     * @param {Vector2} p
+     */
+    static from(p) {
+        const r = new LocationalInteractionMetadata();
+
+        r.position.copy(p);
+
+        return r;
+    }
+}
+
 /**
  * @see https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/buttons
  * @see https://w3c.github.io/uievents/#widl-MouseEvent-buttons
@@ -91504,6 +91587,7 @@ function getTouchCenter(touchList, result) {
 
 }
 
+
 /**
  *
  * @param {Signal} up
@@ -91512,13 +91596,49 @@ function getTouchCenter(touchList, result) {
  * @param {number} maxDistance
  * @param {Signal} signal
  */
-function observeTap(up, down, move, maxDistance, signal) {
+function observeTap(
+    up,
+    down,
+    move,
+    maxDistance,
+    signal
+) {
 
-    const origin = new Vector2();
+    /**
+     *
+     * @type {Map<number, LocationalInteractionMetadata>}
+     */
+    const active = new Map();
+
+    /**
+     *
+     * @param {number} id
+     */
+    function reset(id) {
 
+        if (active.delete(id)) {
+            up.remove(handleUp);
+            move.remove(handleMove);
+        }
+    }
+
+    /**
+     *
+     * @param {Vector2} position
+     * @param {MouseEvent|TouchEvent} event
+     */
     function handleUp(position, event) {
-        up.remove(handleUp);
-        move.remove(handleMove);
+        const id = eventToSourceIdentifier(event);
+
+        const meta = active.get(id);
+
+        if (meta === undefined) {
+            // this should not happen
+            return;
+        }
+
+        reset(id);
+
         signal.send2(position, event);
     }
 
@@ -91528,20 +91648,42 @@ function observeTap(up, down, move, maxDistance, signal) {
      * @param {MouseEvent|TouchEvent} event
      */
     function handleMove(position, event) {
-        if (origin.distanceTo(position) > maxDistance) {
-            //we moved too far, abort tap
-            move.remove(handleMove);
+        const id = eventToSourceIdentifier(event);
 
-            up.remove(handleUp);
+        const meta = active.get(id);
+
+        if (meta === undefined) {
+            // this should not happen
+
+            reset(id);
+
+            return;
         }
+
+        if (meta.position.distanceTo(position) > maxDistance) {
+            //we moved too far, abort tap
+            reset(id);
+        }
+
     }
 
-    function handleDown(position) {
+    /**
+     *
+     * @param {Vector2} position
+     * @param {TouchEvent|MouseEvent} event
+     */
+    function handleDown(position, event) {
+        const id = eventToSourceIdentifier(event);
+
+        // make sure to cancel previous pending resolution
+        reset(id);
+
+        active.set(id, LocationalInteractionMetadata.from(position));
+
         up.addOne(handleUp);
+
         //track move
         move.add(handleMove);
-
-        origin.copy(position);
     }
 
     down.add(handleDown);
@@ -91852,17 +91994,11 @@ class PointerDevice {
         this.#domElement = domElement;
 
 
-        this.#touchStart.add((param0, param1, param2) => {
-            this.on.down.send3(param0, param1, param2);
-        });
+        this.#touchStart.add(this.on.down.send3, this.on.down);
 
-        this.#touchEnd.add((param0, param1, param2) => {
-            this.on.up.send3(param0, param1, param2);
-        });
-        this.#touchMove.add((param0, param1, param2) => {
-            this.on.move.send3(param0, param1, param2);
-        });
+        this.#touchEnd.add(this.on.up.send3, this.on.up);
 
+        this.#touchMove.add(this.on.move.send3, this.on.move);
 
         //constructed events
         observeTap(this.on.up, this.on.down, this.on.move, 10, this.on.tap);
@@ -91878,6 +92014,16 @@ class PointerDevice {
         });
     }
 
+
+    /**
+     *
+     * @param {TouchEvent} event
+     */
+    #eventHandlerGlobalTouchEnd = (event) => {
+        getTouchCenter(event.touches, this.position);
+        this.#globalUp.send2(this.position, event);
+    }
+
     /**
      *
      * @param {MouseEvent} event
@@ -91891,19 +92037,7 @@ class PointerDevice {
 
         const button = this.buttons[button_index];
 
-        if (button !== undefined) {
-            button.is_down = true;
-            button.down.send0();
-        }
-    }
-
-    /**
-     *
-     * @param {TouchEvent} event
-     */
-    #eventHandlerGlobalTouchEnd = (event) => {
-        getTouchCenter(event.touches, this.position);
-        this.#globalUp.send2(this.position, event);
+        button?.press();
     }
 
     /**
@@ -91928,10 +92062,7 @@ class PointerDevice {
 
         const button = this.buttons[button_index];
 
-        if (button !== undefined) {
-            button.is_down = false;
-            button.up.send0();
-        }
+        button?.release();
     }
 
     /**

package/package.json

@@ -5,7 +5,7 @@
   "description": "Fully featured ECS game engine written in JavaScript",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "2.109.24",
+  "version": "2.109.26",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {

package/src/core/collection/heap/{FastBinaryHeap.d.ts → BinaryHeap.d.ts}

@@ -1,6 +1,7 @@
 export default BinaryHeap;
 /**
- * Min-Heap implementation with a score function. The data structure is a binary heap where elements are removed in order defined by scoring function
+ * Min-Heap implementation with a score function.
+ * The data structure is a binary heap where elements are removed in order defined by scoring function
  * @template T
  */
 declare class BinaryHeap<T> {
@@ -11,20 +12,20 @@ declare class BinaryHeap<T> {
      */
     constructor(scoreFunction: any);
     /**
-     *
-     * @type {function(T): number}
-     */
-    scoreFunction: (arg0: T_1) => number;
-    /**
-     *
+     * @private
      * @type {T[]}
      */
-    data: T_1[];
+    private data;
     /**
      * @private
      * @type {number}
      */
     private length;
+    /**
+     *
+     * @type {function(T): number}
+     */
+    scoreFunction: (arg0: T_1) => number;
     /**
      * @private
      * @param {number} pos
@@ -87,5 +88,11 @@ declare class BinaryHeap<T> {
      * @param {T} el
      */
     push(el: T): void;
+    /**
+     * Useful for type checks
+     * @readonly
+     * @type {boolean}
+     */
+    readonly isBinaryHeap: boolean;
 }
-//# sourceMappingURL=FastBinaryHeap.d.ts.map
+//# sourceMappingURL=BinaryHeap.d.ts.map

package/src/core/collection/heap/BinaryHeap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BinaryHeap.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/heap/BinaryHeap.js"],"names":[],"mappings":";AAEA;;;;GAIG;AACH;IAaI;;;;OAIG;IACH,gCAQC;IAzBD;;;OAGG;IACH,aAAU;IAEV;;;OAGG;IACH,eAAW;IASP;;;OAGG;IACH,8BAFuB,MAAM,CAEK;IAItC;;;OAGG;IACH,iBA8BC;IAED;;;OAGG;IACH,mBAmEC;IAED;;;OAGG;IACH,OAFY,CAAC,CA0BZ;IAED;;;OAGG;IACH,QAFa,CAAC,GAAC,SAAS,CAIvB;IAED;;;;OAIG;IACH,aAHW,CAAC,GACC,OAAO,CAYnB;IAED;;;OAGG;IACH,iBAFW,MAAM,QAOhB;IAED;;OAEG;IACH,cAGC;IAED;;;;OAIG;IACH,eAHW,CAAC,GACC,OAAO,CAKnB;IAED;;;OAGG;IACH,WAFa,OAAO,CAInB;IAED;;;OAGG;IACH,QAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,yBAHW,CAAC,GACC,OAAO,CAWnB;IAED;;;OAGG;IACH,SAFW,CAAC,QAUX;IAGL;;;;OAIG;IACH,uBAFU,OAAO,CAEgB;CAPhC"}