@woosh/meep-engine 2.43.1 → 2.43.4

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_walk_toward_cavity.js

@@ -1,48 +0,0 @@
-import { orient3d_fast } from "../../plane/orient3d_fast.js";
-
-/**
- * Walk from a given tetrahedron in the mesh towards tetrahedron that contains input point
- * This is an essential method for incrementally finding the next tetrahedron for cavity computation
- *
- * @see https://git.immc.ucl.ac.be/hextreme/hxt_seqdel/-/blob/master/src/hxt_tetrahedra.c#L330
- * @see p3 "One machine, one minute, three billion tetrahedra" by Célestin Marot, Jeanne Pellerin, Jean-François Remacle
- * @param {TetrahedralMesh} mesh
- * @param {number[]} points
- * @param {number} current_tet
- * @param {number} current_vertex
- * @returns {number}
- */
-function tetrahedral_mesh_walk_toward_cavity(mesh, points, current_tet, current_vertex) {
-
-    let entering_face = 4;
-
-    let curTet = current_tet;
-
-    while (true) {
-
-        let i;
-        for (i = 0; i < 4; i++) {
-
-            // we walk whenever the volume is positive
-            const a_i = (i + 1) & 3;
-            const b_i = (i & 2) ^ 3;
-            const c_i = (i + 3) & 2;
-
-            const a_index = mesh.getCornerIndex(curTet, a_i);
-            const b_index = mesh.getCornerIndex(curTet, b_i);
-            const c_index = mesh.getCornerIndex(curTet, c_i);
-
-            if (i !== entering_face && orient3d_fast(points, a_index, b_index, c_index, current_vertex) < 0.0) {
-                const neighbour = mesh.getNeighbour(curTet, i);
-                curTet = neighbour >> 2;
-                entering_face = neighbour & 3;
-                break;
-            }
-        }
-
-        if (i === 4) {
-            return curTet;
-        }
-    }
-
-}