@woosh/meep-engine 2.109.24 → 2.109.25

package/build/meep.cjs

@@ -84590,10 +84590,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 {
+class FastBinaryHeap {
+    /**
+     * @private
+     * @type {T[]}
+     */
+    data = [];
+
+    /**
+     * @private
+     * @type {number}
+     */
+    length = 0;
+
     /**
      * @template T
      * @param {function(el:T):number} scoreFunction
@@ -84607,17 +84620,6 @@ class BinaryHeap {
          */
         this.scoreFunction = scoreFunction;
 
-        /**
-         *
-         * @type {T[]}
-         */
-        this.data = [];
-
-        /**
-         * @private
-         * @type {number}
-         */
-        this.length = 0;
     }
 
     /**
@@ -84687,19 +84689,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;
@@ -84715,6 +84717,7 @@ class BinaryHeap {
                         dataMin = dataRight;
                     }
                 }
+
             }
 
             //swap positions
@@ -84732,7 +84735,6 @@ class BinaryHeap {
      */
     pop() {
 
-
         this.length--;
 
         const new_length = this.length;
@@ -84741,19 +84743,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;
 
-        }
     }
 
     /**
@@ -84855,7 +84858,14 @@ class BinaryHeap {
 
         this.bubbleUp(position);
     }
-}
+}
+
+/**
+ * Useful for type checks
+ * @readonly
+ * @type {boolean}
+ */
+FastBinaryHeap.prototype.isFastBinaryHeap = true;
 
 /**
  * Decorator that wraps another map and lets you observe mutations
@@ -86045,7 +86055,7 @@ let Response$1 = class Response {
 };
 
 /**
- * Used by the priority queue, so the priority is inverted as the BinaryHeap returns elements in ascending score order (from lowest)
+ * Used by the priority queue, so the priority is inverted as the FastBinaryHeap returns elements in ascending score order (from lowest)
  * @param {PendingAsset} pending_asset
  * @returns {number}
  */
@@ -86080,7 +86090,7 @@ class AssetManager {
      * @type {BinaryHeap<PendingAsset>}
      * @private
      */
-    #pending_asset_wait_queue = new BinaryHeap(get_pending_asset_priority_score);
+    #pending_asset_wait_queue = new FastBinaryHeap(get_pending_asset_priority_score);
     /**
      * Assets currently being processed by #loaders
      * @type {Set<PendingAsset>}
@@ -91139,6 +91149,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)
 }
 
 /**
@@ -91248,41 +91311,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[]}
@@ -91315,7 +91343,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
         ) ;
 
@@ -91359,9 +91387,7 @@ class KeyboardDevice {
         if (keyName !== undefined) {
             const button = this.keys[keyName];
 
-            button.is_down = true;
-            button.down.send1(event);
-
+            button.press();
         }
     }
 
@@ -91381,8 +91407,7 @@ class KeyboardDevice {
         if (keyName !== undefined) {
             const button = this.keys[keyName];
 
-            button.is_down = false;
-            button.up.send1(event);
+            button.release();
         }
     }
 
@@ -91429,6 +91454,60 @@ const TouchEvents = {
     Cancel: "touchcancel",
 };
 
+/**
+ *
+ * @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)
+        ;
+}
+
+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
@@ -91506,6 +91585,7 @@ function getTouchCenter(touchList, result) {
 
 }
 
+
 /**
  *
  * @param {Signal} up
@@ -91514,13 +91594,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);
     }
 
@@ -91530,20 +91646,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);
@@ -91854,17 +91992,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);
@@ -91880,6 +92012,16 @@ class PointerDevice {
         });
     }
 
+
+    /**
+     *
+     * @param {TouchEvent} event
+     */
+    #eventHandlerGlobalTouchEnd = (event) => {
+        getTouchCenter(event.touches, this.position);
+        this.#globalUp.send2(this.position, event);
+    }
+
     /**
      *
      * @param {MouseEvent} event
@@ -91893,19 +92035,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();
     }
 
     /**
@@ -91930,10 +92060,7 @@ class PointerDevice {
 
         const button = this.buttons[button_index];
 
-        if (button !== undefined) {
-            button.is_down = false;
-            button.up.send0();
-        }
+        button?.release();
     }
 
     /**
@@ -108037,7 +108164,7 @@ class MaxRectanglesPacker {
             return -Math.min(box.getWidth(), box.getHeight());
         }
 
-        const heap = new BinaryHeap(scoreBoxByMinSide);
+        const heap = new FastBinaryHeap(scoreBoxByMinSide);
 
         for (let i = 0; i < numBoxes; i++) {
             heap.push(i);