@woosh/meep-engine 2.43.1 → 2.43.3

package/engine/network/PriorityFetch.js

@@ -0,0 +1,192 @@
+import FastBinaryHeap from "../../core/collection/heap/FastBinaryHeap.js";
+import { noop } from "../../core/function/Functions.js";
+import { assert } from "../../core/assert.js";
+
+/**
+ * @readonly
+ * @type {{high: number, auto: number, low: number}}
+ */
+const priority_value_map = {
+    "high": 10,
+    "low": -1,
+    "auto": 0
+};
+
+/**
+ *
+ * @param {string|undefined} p
+ * @return {number}
+ */
+function extract_priority_from_resource(p) {
+
+    let v = 0;
+
+    if (typeof p === "string") {
+        v = priority_value_map[p];
+
+        if (v === undefined) {
+            console.warn(`Unsupported request priority value '${p}', defaulting to 'auto'`);
+        }
+
+        v = priority_value_map['auto'];
+    }
+
+    return v;
+
+}
+
+class FetchRequest {
+    /**
+     *
+     * @param {Request|string} resource
+     * @param {{}} options
+     */
+    constructor(resource, options) {
+        let priority = 0;
+
+        this.__resource = resource;
+        this.__options = options;
+
+        if (typeof this.__resource === "object" && typeof this.__resource.priority !== "undefined") {
+            priority = extract_priority_from_resource(this.__resource.priority);
+        }
+
+        this.__priority = priority;
+
+        this.fulfillment = {
+            resolve: null, reject: null
+        };
+
+        this.promise = new Promise((resolve, reject) => {
+            this.fulfillment.resolve = resolve;
+            this.fulfillment.reject = reject;
+        });
+    }
+}
+
+/**
+ *
+ * @param {FetchRequest} request
+ * @returns {number}
+ */
+function get_priority_score(request) {
+    return -request.__priority;
+}
+
+/**
+ * @readonly
+ * @type {number}
+ */
+const DEFAULT_CONCURRENCY = Infinity;
+
+/**
+ * Wraps {@link fetch} api and adds concurrency management to it by queueing requests,
+ * as well as prioritization in that queue
+ */
+export class PriorityFetch {
+    constructor({
+                    adapter = noop,
+                    concurrency = DEFAULT_CONCURRENCY
+                }) {
+        /**
+         *
+         * @type {number}
+         * @private
+         */
+        this.__concurrency = concurrency;
+
+        /**
+         *
+         * @type {BinaryHeap<FetchRequest>}
+         * @private
+         */
+        this.__queue = new FastBinaryHeap(get_priority_score);
+
+        /**
+         *
+         * @type {Set<FetchRequest>}
+         * @private
+         */
+        this.__pending_set = new Set();
+
+        /**
+         *
+         * @type {null}
+         * @private
+         */
+        this.__adapter = adapter;
+    }
+
+    /**
+     *
+     * @param {function} v
+     */
+    set adapter(v) {
+        this.__adapter = v;
+    }
+
+    /**
+     *
+     * @param {number} v
+     */
+    set concurrency(v) {
+        assert.isNumber(v, 'v');
+        assert.notNaN(v, 'v');
+        assert.greaterThan(v, 0, 'concurrency must be greater than 0');
+
+        this.__concurrency = v;
+    }
+
+    /**
+     *
+     * @return {number}
+     */
+    get concurrency() {
+        return this.__concurrency;
+    }
+
+    /**
+     *
+     * @param {FetchRequest} req
+     * @private
+     */
+    __dispatch(req) {
+        const promise = this.__adapter(req.__resource, req.__options);
+
+        promise.finally(() => {
+            this.__pending_set.delete(req);
+
+            this.__prod();
+        });
+
+        promise
+            .then(
+                (v) => {
+                    req.fulfillment.resolve(v);
+                },
+                (reason) => {
+                    req.fulfillment.reject(reason);
+                }
+            );
+    }
+
+    __prod() {
+        if (this.__pending_set.size < this.__concurrency && !this.__queue.isEmpty()) {
+            const req = this.__queue.pop();
+
+            this.__dispatch(req);
+        }
+    }
+
+    fetch(resource, options) {
+        const req = new FetchRequest(resource, options);
+
+        if (this.__pending_set.size < this.__concurrency) {
+            this.__dispatch(req);
+        } else {
+            this.__queue.push(req);
+        }
+
+        return req.promise;
+    }
+}

package/engine/simulation/DormandPrince.js

@@ -166,7 +166,7 @@ function computeStepSize(fxy, x, y, suggestedStepSize, tolerance, maxIterations,
  * @param {number} hmax max step size
  * @param {number} hmin min step size
  * @param {number} max_iteration maximum number of iterations
- * @returns {*[]}
+ * @returns {Array.<number>}
  */
 function odedopri(fxy, x0, y0, x1, tol, hmax, hmin, max_iteration) {
 

package/engine/ui/DraggableAspect.js

@@ -34,7 +34,6 @@ export class DraggableAspect {
         const pointerGlobal = this.pointerGlobal = new PointerDevice(window);
 
         const dragOriginalPosition = new Vector2();
-        const delta = new Vector2();
         const pointer_position_last = new Vector2();
 
         if (stopPropagation) {

package/generation/grid/generation/road/GridTaskGenerateRoads.js

@@ -11,7 +11,6 @@ import { buildPathFromDistanceMap } from "../util/buildPathFromDistanceMap.js";
 import { GridCellActionPlaceTags } from "../../../placement/action/GridCellActionPlaceTags.js";
 import { GridTags } from "../../../GridTags.js";
 import { CellMatcher } from "../../../rules/CellMatcher.js";
-import { groupArrayBy } from "../../../../core/collection/ArrayUtils.js";
 import { collectIteratorValueToArray } from "../../../../core/collection/IteratorUtils.js";
 import { QuadTreeNode } from "../../../../core/geom/2d/quad-tree/QuadTreeNode.js";
 import AABB2 from "../../../../core/geom/AABB2.js";
@@ -24,6 +23,7 @@ import { RoadConnectionNetwork } from "./RoadConnectionNetwork.js";
 import { MirGridLayers } from "../../../example/grid/MirGridLayers.js";
 import { actionTask } from "../../../../core/process/task/util/actionTask.js";
 import { countTask } from "../../../../core/process/task/util/countTask.js";
+import { groupArrayBy } from "../../../../core/collection/array/groupArrayBy.js";
 
 const NODE_TYPE_ROAD_CONNECTOR = 'Road Connector';
 

package/package.json

@@ -5,7 +5,7 @@
   "productName": "Meep",
   "description": "production-ready JavaScript game engine based on Entity Component System Architecture",
   "author": "Alexander Goldring",
-  "version": "2.43.1",
+  "version": "2.43.3",
   "dependencies": {
     "gl-matrix": "3.4.3",
     "fast-levenshtein": "2.0.6",

package/view/elements/CanvasView.js

@@ -1,6 +1,8 @@
 import View from "../View.js";
 
-
+/**
+ * Wrapper around {@link HTMLCanvasElement}, exposes {@link CanvasRenderingContext2D}
+ */
 export class CanvasView extends View {
     constructor() {
         super();
@@ -8,6 +10,10 @@ export class CanvasView extends View {
         const canvas = document.createElement('canvas');
         this.el = canvas;
 
+        /**
+         *
+         * @type {CanvasRenderingContext2D}
+         */
         this.context2d = canvas.getContext('2d');
 
         this.size.onChanged.add(this.__handleSizeChange, this);

package/view/elements/image/HTMLElementCacheKey.js

@@ -1,8 +1,8 @@
-import { isArrayEqual } from "../../../core/collection/ArrayUtils.js";
 import { KeyValuePair } from "../../../core/collection/KeyValuePair.js";
 import { computeStringHash } from "../../../core/primitives/strings/computeStringHash.js";
 import { computeHashArray } from "../../../core/collection/array/computeHashArray.js";
 import { computeHashIntegerArray } from "../../../core/collection/array/computeHashIntegerArray.js";
+import { isArrayEqual } from "../../../core/collection/array/isArrayEqual.js";
 
 /**
  *

package/view/util/DomSizeObserver.js

@@ -54,13 +54,11 @@ export class DomSizeObserver {
      * @param {number} [depth=0] how deep should the observation go
      */
     constructor({ depth = 0 } = {}) {
-        const rectangle = new Rectangle();
-
         /**
          *
          * @type {Rectangle}
          */
-        this.dimensions = rectangle;
+        this.dimensions = new Rectangle();
 
         /**
          *
@@ -169,7 +167,7 @@ export class DomSizeObserver {
     }
 
     /**
-     *
+     * Will attach to the view's element and automatically start/stop observing when the view is linked/unlinked
      * @param {View} view
      */
     watchView(view) {
@@ -184,7 +182,7 @@ export class DomSizeObserver {
     }
 
     /**
-     *
+     * Counterpart to {@link #watchView}
      * @param {View} view
      */
     unwatchView(view) {

package/core/collection/ArrayUtils.js

@@ -1,263 +0,0 @@
-/**
- *
- * @param {Array} first
- * @param {Array} second
- * @returns {boolean}
- */
-import { assert } from "../assert.js";
-import { returnZero } from "../function/Functions.js";
-import { min2 } from "../math/min2.js";
-import { HashMap } from "./HashMap.js";
-import { randomIntegerBetween } from "../math/random/randomIntegerBetween.js";
-
-
-/**
- * @template T
- * @param {function} random
- * @param {T[]} array
- */
-export function randomizeArrayElementOrder(random, array) {
-    const n = array.length;
-
-    const lastValidIndex = n - 1;
-
-    for (let i = 0; i < n; i++) {
-        const t = randomIntegerBetween(random, 0, lastValidIndex);
-
-        if (t === i) {
-            continue;
-        }
-
-        arraySwapElements(array, i, t);
-    }
-}
-
-/**
- * Pick multiple random items from an array
- *
- * @template T
- * @param {function} random
- * @param {T[]} source
- * @param {T[]} target
- * @param {number} count how many items to pick
- * @returns {T}
- */
-export function randomMultipleFromArray(random, source, target, count) {
-
-    const order = [];
-
-    const source_length = source.length;
-    for (let i = 0; i < source_length; i++) {
-        order[i] = i;
-    }
-
-    randomizeArrayElementOrder(random, order);
-
-    const target_length = min2(source_length, count);
-
-    for (let i = 0; i < target_length; i++) {
-        const index = order[i];
-        const element = source[index];
-        target.push(element);
-    }
-
-    return target_length;
-}
-
-/**
- * @template T,R
- * @param {T[]} first
- * @param {R[]} second
- * @return {boolean}
- */
-export function isArrayEqual(first, second) {
-
-    const il = first.length;
-
-    if (il !== second.length) return false;
-
-    let i = 0;
-
-    for (; i < il; i++) {
-
-        const a = first[i];
-        const b = second[i];
-
-        if (a === b) {
-            continue;
-        }
-
-
-        if (a === undefined) {
-            //a is undefined, and B is something else
-            return false;
-        }
-
-        if (a === null) {
-            //a is null and B is something else
-            return false;
-        }
-
-        //try "equals" method
-        if (typeof a.equals === "function") {
-
-            if (!a.equals(b)) {
-                return false;
-            }
-
-        } else {
-            return false;
-        }
-
-    }
-
-    return true;
-
-}
-
-/**
- * @template T
- * @param {T[]} array
- * @param {function(T):number} scoreFunction
- * @returns {T[]}
- */
-export function arrayPickBestElements(array, scoreFunction) {
-    assert.notEqual(array, undefined, 'array is undefined');
-    assert.isArray(array, 'array');
-
-    assert.typeOf(scoreFunction, 'function', 'scoreFunction');
-
-    let bestScore;
-
-    const size = array.length;
-
-    if (size === 0) {
-        return [];
-    }
-
-    const first = array[0];
-
-    bestScore = scoreFunction(first);
-
-    assert.isNumber(bestScore, 'bestScore');
-
-    const result = [first];
-
-    for (let i = 1; i < size; i++) {
-        const el = array[i];
-
-        // compute score
-        const score = scoreFunction(el);
-
-        assert.isNumber(score, 'score');
-
-        if (score > bestScore) {
-            bestScore = score;
-
-            result.splice(0, result.length);
-
-            result.push(el);
-        } else if (score === bestScore) {
-            result.push(el);
-        }
-    }
-
-    return result;
-}
-
-/**
- * @template T
- * @param {T[]} array
- * @param {function(T):number} scoreFunction
- * @returns {T}
- */
-export function arrayPickMinElement(array, scoreFunction) {
-    assert.notEqual(array, undefined, 'array is undefined');
-    assert.typeOf(scoreFunction, 'function', 'scoreFunction');
-
-    let bestElement;
-    let bestScore;
-
-    const size = array.length;
-
-    if (size === 0) {
-        return undefined;
-    }
-
-    bestElement = array[0];
-
-    bestScore = scoreFunction(bestElement);
-
-    assert.typeOf(bestScore, 'number', 'bestScore');
-
-    for (let i = 1; i < size; i++) {
-        const el = array[i];
-
-        // compute score
-        const score = scoreFunction(el);
-
-        assert.typeOf(score, 'number', 'score');
-
-        if (score < bestScore) {
-            bestScore = score;
-            bestElement = el;
-        }
-    }
-
-    return bestElement;
-}
-
-/**
- * @template T,K
- * @param {T[]} array
- * @param {function(T):K} groupingFunction
- * @param keyHashFunction
- * @returns {Map<K,T[]>}
- */
-export function groupArrayBy(array, groupingFunction, keyHashFunction = returnZero) {
-    const result = new HashMap({
-        keyHashFunction,
-        keyEqualityFunction(a, b) {
-            if (a === b) {
-                return true;
-            }
-
-            if (typeof a === "object" && a !== null && typeof a.equals === "function") {
-                return a.equals(b);
-            }
-
-            return false;
-        }
-    });
-
-    for (let i = 0; i < array.length; i++) {
-        const element = array[i];
-
-        const groupKey = groupingFunction(element);
-
-        const group = result.get(groupKey);
-
-        if (group === undefined) {
-            result.set(groupKey, [element]);
-        } else {
-            group.push(element);
-        }
-    }
-
-    return result;
-}
-
-
-/**
- * @template T
- * @param {T[]} array
- * @param {number} index0
- * @param {number} index1
- */
-export function arraySwapElements(array, index0, index1) {
-    const t = array[index0];
-
-    array[index0] = array[index1];
-    array[index1] = t;
-}
-

package/core/geom/3d/tetrahedra/delaunay/tetrahedral_mesh_compute_cavity.js

@@ -1,73 +0,0 @@
-import { assert } from "../../../../assert.js";
-import { point_in_tetrahedron_circumsphere } from "../point_in_tetrahedron_circumsphere.js";
-import { INVALID_NEIGHBOUR } from "../tetrahedra_collection.js";
-
-/**
- *
- * @param {TetrahedralMesh} mesh
- * @param {Cavity} cavity
- * @param {number[]|Float32Array} points
- * @param {number} containing_tetra tetrahedron that contains point
- * @param {number} point_index point that forms the cavity
- */
-export function tetrahedral_mesh_compute_cavity(mesh, cavity, points, containing_tetra, point_index) {
-    assert.isNonNegativeInteger(containing_tetra, 'containing_tetra');
-
-    cavity.reset();
-
-    /**
-     *
-     * @type {number[]}
-     */
-    const open_set = [
-        containing_tetra
-    ];
-
-    /**
-     *
-     * @type {number[]}
-     */
-    const closed_set = [];
-
-    // 2. find the Delaunay "cavity", a set of tetrahedrons who's circumsphere overlarlaps the point
-    // perform breadth-first expansion on the containing tetra to identify the cavity
-    while (open_set.length > 0) {
-
-        const tetra = open_set.pop();
-        cavity.push(tetra);
-        closed_set.push(tetra);
-
-        // get neighbours
-        for (let i = 0; i < 4; i++) {
-
-            const neighbour_encoded = mesh.getNeighbour(tetra, i);
-            const neighbour_tetra_index = neighbour_encoded >>> 2;
-
-            if (
-                (neighbour_encoded === INVALID_NEIGHBOUR) // no neighbour
-                || closed_set.includes(neighbour_tetra_index)   // already visited
-                || open_set.includes(neighbour_tetra_index) // already in open set
-            ) {
-
-                continue;
-            }
-
-            const a = mesh.getCornerIndex(neighbour_tetra_index, 0);
-            const b = mesh.getCornerIndex(neighbour_tetra_index, 1);
-            const c = mesh.getCornerIndex(neighbour_tetra_index, 2);
-            const d = mesh.getCornerIndex(neighbour_tetra_index, 3);
-
-            // check neighbour
-            const is_in_sphere = point_in_tetrahedron_circumsphere(points, a, b, c, d, containing_tetra);
-
-            if (is_in_sphere) {
-                open_set.push(neighbour_tetra_index);
-            } else {
-                // move directly to closed set
-                closed_set.push(neighbour_tetra_index);
-            }
-
-
-        }
-    }
-}