@woosh/meep-engine 2.54.0 → 2.56.0

package/editor/view/node-graph/PortView.js

@@ -1,10 +1,10 @@
 import View from "../../../src/view/View.js";
 import { PortDirection } from "../../../src/core/model/node-graph/node/PortDirection.js";
-import { camelToKebab } from "../../../src/core/primitives/strings/StringUtils.js";
 import LabelView from "../../../src/view/common/LabelView.js";
 import EmptyView from "../../../src/view/elements/EmptyView.js";
 import { Color } from "../../../src/core/color/Color.js";
 import { objectKeyByValue } from "../../../src/core/model/object/objectKeyByValue.js";
+import { string_format_camel_to_kebab } from "../../../src/core/primitives/strings/string_format_camel_to_kebab.js";
 
 const DEFAULT_TYPE_COLOR = new Color(1, 1, 1);
 
@@ -35,7 +35,7 @@ export class PortView extends View {
 
         this.addClass(`direction-${objectKeyByValue(PortDirection, port.direction).toLocaleLowerCase()}`);
 
-        this.addClass(`data-type-${camelToKebab(port.dataType.name)}`);
+        this.addClass(`data-type-${string_format_camel_to_kebab(port.dataType.name)}`);
 
         //add port name label
         const vName = new LabelView(port.name, {

package/package.json

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

package/src/core/__module.js

@@ -1,6 +1,6 @@
 
 export { Cache } from "./cache/Cache.js";
-export { HashMap } from "./collection/HashMap.js";
+export { HashMap } from "./collection/map/HashMap.js";
 
 export * from "./geom/Vector3.js";
 export * from "./geom/Vector4.js";

package/src/core/binary/BinaryBuffer.js

@@ -52,7 +52,8 @@ export class BinaryBuffer {
     position = 0;
 
     /**
-     * @deprecated
+     * Same as {@link capacity}
+     * @deprecated use {@link position} or {@link capacity} instead
      * @type {number}
      */
     length = 0;

package/src/core/cache/Cache.js

@@ -1,5 +1,5 @@
 import { assert } from "../assert.js";
-import { HashMap } from "../collection/HashMap.js";
+import { HashMap } from "../collection/map/HashMap.js";
 import Signal from "../events/signal/Signal.js";
 import { returnOne, returnZero, strictEquals } from "../function/Functions.js";
 import { CacheElement } from "./CacheElement.js";

package/src/core/cache/LoadingCache.js

@@ -1,6 +1,7 @@
 //
 
 import { Cache } from "./Cache.js";
+import { current_time_in_seconds } from "../time/current_time_in_seconds.js";
 
 /**
  * @template R
@@ -18,13 +19,16 @@ class Record {
     }
 }
 
-function current_time_in_seconds() {
-    return performance.now() * 1e-3;
-}
-
-const DEFAULT_TIME_TO_LIVE = 10;
+/**
+ * In seconds
+ * @readonly
+ * @type {number}
+ */
+const DEFAULT_TIME_TO_LIVE = 300; // 5 Minutes
 
 /**
+ * Asynchronous cache capable of resolving its own values by keys
+ * Modelled on Guava's LoadingCache concept
  * @template K,V
  */
 export class LoadingCache {
@@ -33,6 +37,7 @@ export class LoadingCache {
      */
     #internal
     /**
+     * Time until records are marked as invalid, invalid records are not served back and trigger re-loading of the value
      * In seconds
      * @type {number}
      */

package/src/core/collection/Stack.js

@@ -5,23 +5,20 @@ import Signal from "../events/signal/Signal.js";
  * @class
  */
 export class Stack {
+
     /**
-     * @template T
+     * @private
+     * @type {T[]}
      */
-    constructor() {
-
-        /**
-         * @private
-         * @type {T[]}
-         */
-        this.data = [];
-
-        this.on = {
-            removed: new Signal(),
-            added: new Signal()
-        };
+    data = [];
 
-    }
+    /**
+     * @readonly
+     */
+    on = {
+        removed: new Signal(),
+        added: new Signal()
+    };
 
     /**
      * @returns {T[]}

package/src/core/collection/array/array_contains_duplicates.js

@@ -11,12 +11,15 @@ export function array_contains_duplicates(
     end_index = source.length - 1
 ) {
 
-    for (let k = start_index; k <= end_index; k++) {
+    // going to n-1, as we check all elements forward from the current
+    const last = end_index - 1;
+
+    for (let k = start_index; k <= last; k++) {
 
         const element = source[k];
 
         // look for future occurrences of the same element
-        if (source.indexOf(element, k + 1) === -1) {
+        if (source.indexOf(element, k + 1) !== -1) {
             return true;
         }
 

package/src/core/collection/array/array_contains_duplicates.spec.js

@@ -0,0 +1,14 @@
+import { array_contains_duplicates } from "./array_contains_duplicates.js";
+
+test("basics", () => {
+    expect(array_contains_duplicates([])).toBe(false);
+
+    expect(array_contains_duplicates([1])).toBe(false);
+
+    expect(array_contains_duplicates([1, 2, 3])).toBe(false);
+
+    expect(array_contains_duplicates([1, 1])).toBe(true);
+    expect(array_contains_duplicates([0, 1, 1])).toBe(true);
+    expect(array_contains_duplicates([1, 0, 1])).toBe(true);
+    expect(array_contains_duplicates([1, 1, 0])).toBe(true);
+});

package/src/core/collection/array/array_copy_entire.js

@@ -1,3 +1,6 @@
+import { array_copy } from "./array_copy.js";
+import { array_shrink_to_size } from "./array_shrink_to_size.js";
+
 /**
  * @template T
  * @param {T[]} source
@@ -5,17 +8,9 @@
  */
 export function array_copy_entire(source, target) {
 
-    const n = source.length;
-    for (let i = 0; i < n; i++) {
-        const v = source[i];
-
-        target[i] = v;
-    }
-
+    const source_length = source.length;
 
-    const tL = target.length;
+    array_copy(source, 0, target, 0, source_length);
+    array_shrink_to_size(target, source_length);
 
-    if (n > tL) {
-        target.splice(n, tL - n);
-    }
 }

package/src/core/collection/array/array_get_index_in_range.js

@@ -1,3 +1,5 @@
+import { assert } from "../../assert.js";
+
 /**
  * @template T
  * @param {T[]} array
@@ -6,6 +8,9 @@
  * @param {number} max_index
  */
 export function array_get_index_in_range(array, needle, min_index, max_index) {
+    assert.lessThanOrEqual(max_index, array.length - 1, 'max_length must is too large');
+    assert.isNonNegativeInteger(min_index, 'min_index');
+
     for (let i = min_index; i <= max_index; i++) {
         if (array[i] === needle) {
             return i;

package/src/core/collection/array/array_get_index_in_range.spec.js

@@ -0,0 +1,16 @@
+import { array_get_index_in_range } from "./array_get_index_in_range.js";
+
+test("basics", () => {
+
+    expect(array_get_index_in_range([], 1, 0, -1)).toBe(-1);
+    expect(array_get_index_in_range([1], 1, 0, 0)).toBe(0);
+
+    expect(array_get_index_in_range([3, 1], 1, 0, 1)).toBe(1);
+    expect(array_get_index_in_range([3, 1], 1, 0, 0)).toBe(-1);
+    expect(array_get_index_in_range([3, 1], 1, 1, 1)).toBe(1);
+
+    expect(array_get_index_in_range([1, 3], 1, 0, 1)).toBe(0);
+    expect(array_get_index_in_range([1, 3], 1, 1, 1)).toBe(-1);
+    expect(array_get_index_in_range([1, 3], 1, 0, 0)).toBe(0);
+
+});

package/src/core/collection/array/array_remove_element.js

@@ -1,4 +1,7 @@
+import { array_remove_first } from "./array_remove_first.js";
+
 /**
+ * @deprecated
  * @template T
  * @param {T[]} array
  * @param {number} start_index
@@ -7,13 +10,7 @@
  * @return {boolean}
  */
 export function array_remove_element(array, start_index, end_index, element) {
-    for (let i = start_index; i < end_index; i++) {
-        if (array[i] === element) {
-            array.splice(i, 1);
-
-            return true;
-        }
-    }
+    console.warn('deprecated, use array_remove_first instead');
 
-    return false;
-}
+    array_remove_first(array, element, start_index, end_index - start_index);
+}

package/src/core/collection/array/array_remove_first.js

@@ -1,15 +1,22 @@
 /**
+ * Remove first occurrence of element from the array
  * @template T
  * @param {T[]} array
  * @param {T} element
- * @return {boolean}
+ * @param {number} [start_index]
+ * @param {number} [length]
+ * @return {boolean} true if element was removed, false if it was not found
  */
-export function array_remove_first(array, element){
-    const i = array.indexOf(element);
+export function array_remove_first(array, element, start_index = 0, length = array.length) {
 
-    if(i !== -1){
-        array.splice(i,1);
-        return true;
+    const end_index = start_index + length;
+
+    for (let i = start_index; i < end_index; i++) {
+        if (array[i] === element) {
+            array.splice(i, 1);
+
+            return true;
+        }
     }
 
     return false;

package/src/core/collection/array/array_remove_first.spec.js

@@ -0,0 +1,39 @@
+import { array_remove_first } from "./array_remove_first.js";
+
+test("basics", () => {
+
+    expect(array_remove_first([], 1)).toBe(false);
+    expect(array_remove_first([2], 1)).toBe(false);
+    expect(array_remove_first([2, 3], 1)).toBe(false);
+
+    let array = [1];
+
+    expect(array_remove_first(array, 1)).toBe(true);
+
+    expect(array).toEqual([]);
+
+    array = [1, 1];
+
+    expect(array_remove_first(array, 1)).toBe(true);
+
+    expect(array).toEqual([1]);
+
+    array = [2, 1];
+
+    expect(array_remove_first(array, 1)).toBe(true);
+
+    expect(array).toEqual([2]);
+
+    array = [1, 2];
+
+    expect(array_remove_first(array, 1)).toBe(true);
+
+    expect(array).toEqual([2]);
+
+    array = [1, 2, 1];
+
+    expect(array_remove_first(array, 1)).toBe(true);
+
+    expect(array).toEqual([2, 1]);
+
+});

package/src/core/collection/array/binarySearchHighIndex.spec.js

@@ -1,50 +1,51 @@
 import { binarySearchHighIndex } from "./binarySearchHighIndex.js";
-import { compareNumbersAscending } from "../../function/Functions.js";
+
+import { number_compare_ascending } from "../../primitives/numbers/number_compare_ascending.js";
 
 test('exact match single element 1', () => {
     expect(
-        binarySearchHighIndex([1], 1, compareNumbersAscending, 0, 0)
+        binarySearchHighIndex([1], 1, number_compare_ascending, 0, 0)
     ).toBe(0);
 });
 
 test('exact match single element 0', () => {
     expect(
-        binarySearchHighIndex([0], 0, compareNumbersAscending, 0, 0)
+        binarySearchHighIndex([0], 0, number_compare_ascending, 0, 0)
     ).toBe(0);
 });
 
 test('exact match single element -1', () => {
     expect(
-        binarySearchHighIndex([-1], -1, compareNumbersAscending, 0, 0)
+        binarySearchHighIndex([-1], -1, number_compare_ascending, 0, 0)
     ).toBe(0);
 });
 
 test('0 -> 0,0', () => {
     expect(
-        binarySearchHighIndex([0, 0], 0, compareNumbersAscending, 0, 1)
+        binarySearchHighIndex([0, 0], 0, number_compare_ascending, 0, 1)
     ).toBe(0);
 });
 
 test('0 -> 0,1', () => {
     expect(
-        binarySearchHighIndex([0, 1], 0, compareNumbersAscending, 0, 1)
+        binarySearchHighIndex([0, 1], 0, number_compare_ascending, 0, 1)
     ).toBe(0);
 });
 
 test('1 -> 1,1', () => {
     expect(
-        binarySearchHighIndex([1, 1], 1, compareNumbersAscending, 0, 1)
+        binarySearchHighIndex([1, 1], 1, number_compare_ascending, 0, 1)
     ).toBe(0);
 });
 
 test('0 -> 1,2', () => {
     expect(
-        binarySearchHighIndex([1, 2], 0, compareNumbersAscending, 0, 1)
+        binarySearchHighIndex([1, 2], 0, number_compare_ascending, 0, 1)
     ).toBe(0);
 });
 
 test('1.5 -> 1,2', () => {
     expect(
-        binarySearchHighIndex([1, 2], 1.5, compareNumbersAscending, 0, 1)
+        binarySearchHighIndex([1, 2], 1.5, number_compare_ascending, 0, 1)
     ).toBe(1);
 });

package/src/core/collection/array/groupArrayBy.js

@@ -1,5 +1,5 @@
 import { returnZero } from "../../function/Functions.js";
-import { HashMap } from "../HashMap.js";
+import { HashMap } from "../map/HashMap.js";
 
 /**
  * @template T,K

package/src/core/collection/array/isArrayEqual.js

@@ -8,7 +8,10 @@ export function isArrayEqual(first, second) {
 
     const il = first.length;
 
-    if (il !== second.length) return false;
+    if (il !== second.length) {
+        // arrays are of different size
+        return false;
+    }
 
     let i = 0;
 

package/src/core/collection/array/randomizeArrayElementOrder.js

@@ -2,6 +2,7 @@ import { randomIntegerBetween } from "../../math/random/randomIntegerBetween.js"
 import { arraySwapElements } from "./arraySwapElements.js";
 
 /**
+ * Randomly re-orders of items in-place
  * @template T
  * @param {function} random
  * @param {T[]} array

package/src/core/collection/array/randomizeArrayElementOrder.spec.js

@@ -0,0 +1,27 @@
+import { randomizeArrayElementOrder } from "./randomizeArrayElementOrder.js";
+
+test("sanity", () => {
+
+    const random = () => 0;
+
+    const a = [];
+
+    randomizeArrayElementOrder(random, a);
+
+    expect(a).toEqual([]);
+
+    const b = [1];
+
+    randomizeArrayElementOrder(random, b);
+
+    expect(b).toEqual([1]);
+
+    const c = [1, 2, 3];
+
+    randomizeArrayElementOrder(random, c);
+
+    expect(c.length).toBe(3);
+    expect(c).toContain(1);
+    expect(c).toContain(2);
+    expect(c).toContain(3);
+});

package/src/core/collection/heap/Uin32Heap.spec.js

@@ -1,4 +1,5 @@
 import { Uint32Heap } from "./Uint32Heap.js";
+import { seededRandom } from "../../math/random/seededRandom.js";
 
 test('initial capacity setting via constructor', () => {
     const heap = new Uint32Heap(3);
@@ -57,3 +58,102 @@ test('insert 5 out of order, retrieve in order', () => {
     expect(heap.pop_min()).toBe(3);
     expect(heap.pop_min()).toBe(5);
 });
+
+test("remove", () => {
+
+    const heap = new Uint32Heap();
+
+    expect(heap.remove(7)).toBe(false);
+
+    heap.insert(7, 3);
+
+    expect(heap.remove(7)).toBe(true);
+
+    expect(heap.is_empty()).toBe(true);
+});
+
+test("is_empty", () => {
+
+    const heap = new Uint32Heap();
+
+    expect(heap.is_empty()).toBe(true);
+
+    heap.insert(7, 0);
+
+    expect(heap.is_empty()).toBe(false);
+});
+
+test("update_score", () => {
+
+    const heap = new Uint32Heap();
+
+    heap.insert(1, 3);
+    heap.insert(7, 11);
+
+    heap.update_score(7, -1);
+
+    expect(heap.pop_min()).toEqual(7);
+    expect(heap.pop_min()).toEqual(1);
+
+    // expect request to a missing element to throw
+    expect(() => heap.update_score(7, 0)).toThrow();
+});
+
+test("get_score", () => {
+
+    const heap = new Uint32Heap();
+
+    expect(heap.get_score(7)).toBeNaN();
+
+    heap.insert(7, 31);
+
+    expect(heap.get_score(7)).toBe(31);
+});
+
+test("insert_or_update", () => {
+
+    const heap = new Uint32Heap();
+
+    heap.insert_or_update(7, 1);
+
+    expect(heap.size).toBe(1);
+    expect(heap.get_score(7)).toBe(1);
+
+    heap.insert_or_update(7, 17);
+
+    expect(heap.size).toBe(1);
+    expect(heap.get_score(7)).toBe(17);
+
+});
+
+
+test.skip("performance 1,000,000 random element fill / drain", () => {
+
+    const random = seededRandom(7);
+
+    const COUNT = 1000000;
+
+    const random_values = new Float32Array(COUNT);
+
+    for (let i = 0; i < COUNT; i++) {
+        random_values[i] = random();
+    }
+
+    const heap = new Uint32Heap();
+
+    const t0 = performance.now();
+    for (let i = 0; i < COUNT; i++) {
+        heap.insert(i, random_values[i]);
+    }
+    const t1 = performance.now();
+
+    for (let i = 0; i < COUNT; i++) {
+        heap.pop_min();
+    }
+    const t2 = performance.now();
+
+    const fill_time = t1 - t0;
+    const drain_time = t2 - t1;
+
+    console.log(`Fill took ${fill_time}ms (${COUNT / (fill_time * 0.001)} elements per second), drain took ${drain_time}ms (${COUNT / (drain_time * 0.001)} elements per second)`);
+});

package/src/core/collection/heap/Uint32Heap.js

@@ -87,10 +87,10 @@ export class Uint32Heap {
     __capacity_grow() {
         const old_capacity = this.__capacity;
 
-        const new_capacity = max2(
+        const new_capacity = Math.ceil(max2(
             old_capacity * RESIZE_GROW_FACTOR,
             old_capacity + RESIZE_GROW_MIN_COUNT
-        );
+        ));
 
         assert.greaterThan(new_capacity, old_capacity, 'invalid growth');
 
@@ -117,7 +117,10 @@ export class Uint32Heap {
     compare(a, b) {
         const float32 = this.__data_float32;
 
-        return float32[a * 2] < float32[b * 2];
+        const a2 = a << 1; // same as a*2
+        const b2 = b << 1; // same as b*2
+
+        return float32[a2] < float32[b2];
     }
 
     /**
@@ -127,8 +130,9 @@ export class Uint32Heap {
      * @param {number} j element index
      */
     swap(i, j) {
-        const i2 = i * 2;
-        const j2 = j * 2;
+        // fast multiplication by 2
+        const i2 = i << 1; // same as i*2
+        const j2 = j << 1; // same as j*2
 
         const uint32 = this.__data_uint32;
 
@@ -279,13 +283,17 @@ export class Uint32Heap {
     /**
      *
      * @param {number} id
+     * @returns {boolean}
      */
     remove(id) {
         const i = this.find_index_by_id(id);
 
-        if (i !== -1) {
-            this.__remove_by_index(i);
+        if (i === -1) {
+            return false;
         }
+
+        this.__remove_by_index(i);
+        return true;
     }
 
     /**
@@ -381,6 +389,7 @@ export class Uint32Heap {
     insert(id, score) {
         assert.isNonNegativeInteger(id, 'value');
         assert.lessThanOrEqual(id, UINT32_MAX - 1, 'must be less than or equal to (2^32 - 2)');
+        assert.isNumber(score, 'score');
 
         if (this.__size >= this.__capacity) {
             // need to re-allocate

package/src/core/collection/list/List.js

@@ -920,6 +920,7 @@ class List {
         const l = this.length;
 
         const other_length = other.length;
+
         if (l !== other_length) {
             return l - other_length;
         }

package/src/core/collection/{HashMap.js → map/HashMap.js}

@@ -1,13 +1,13 @@
-import { assert } from "../assert.js";
-import { invokeObjectEquals } from "../model/object/invokeObjectEquals.js";
-import { invokeObjectHash } from "../model/object/invokeObjectHash.js";
-import { isPowerOfTwo } from "../math/isPowerOrTwo.js";
-import { ctz32 } from "../binary/ctz32.js";
-import { ceilPowerOfTwo } from "../binary/operations/ceilPowerOfTwo.js";
-import { UintArrayForCount } from "./array/typed/uint_array_for_count.js";
-import { array_copy } from "./array/array_copy.js";
-import { min2 } from "../math/min2.js";
-import { arraySwapElements } from "./array/arraySwapElements.js";
+import { assert } from "../../assert.js";
+import { invokeObjectEquals } from "../../model/object/invokeObjectEquals.js";
+import { invokeObjectHash } from "../../model/object/invokeObjectHash.js";
+import { isPowerOfTwo } from "../../math/isPowerOrTwo.js";
+import { ctz32 } from "../../binary/ctz32.js";
+import { ceilPowerOfTwo } from "../../binary/operations/ceilPowerOfTwo.js";
+import { UintArrayForCount } from "../array/typed/uint_array_for_count.js";
+import { array_copy } from "../array/array_copy.js";
+import { min2 } from "../../math/min2.js";
+import { arraySwapElements } from "../array/arraySwapElements.js";
 
 /*
  * Heavily inspired by ruby's "new" (circa 2016) hash table implementation

package/src/core/collection/{HashMap.spec.js → map/HashMap.spec.js}

@@ -1,5 +1,5 @@
 import { generate_next_linear_congruential_index, HashMap } from "./HashMap.js";
-import { passThrough, returnOne, strictEquals } from "../function/Functions.js";
+import { passThrough, returnOne, strictEquals } from "../../function/Functions.js";
 
 /**
  *

package/src/core/collection/{ObservedMap.js → map/ObservedMap.js}

@@ -1,4 +1,4 @@
-import Signal from "../events/signal/Signal.js";
+import Signal from "../../events/signal/Signal.js";
 
 export class ObservedMap {
     /**