@woosh/meep-engine 2.84.3 → 2.84.5

package/src/core/process/matcher/isInstanceOf.js

@@ -0,0 +1,10 @@
+/**
+ * performs instanceof match
+ * @param {function} type
+ * @returns {function(*): boolean}
+ */
+export function isInstanceOf(type) {
+    return function (m) {
+        return m instanceof type;
+    }
+}

package/src/core/process/matcher/isLessThan.js

@@ -0,0 +1,10 @@
+/**
+ *
+ * @param {number} value
+ * @returns {function(*): boolean}
+ */
+export function isLessThan(value) {
+    return function (x) {
+        return x < value;
+    }
+}

package/src/core/process/matcher/isLessThanOrEqualTo.js

@@ -0,0 +1,10 @@
+/**
+ *
+ * @param {number} value
+ * @returns {function(*): boolean}
+ */
+export function isLessThanOrEqualTo(value) {
+    return function (x) {
+        return x <= value;
+    }
+}

package/src/core/process/matcher/isNull.js

@@ -0,0 +1,8 @@
+/**
+ *
+ * @param {*} value
+ * @returns {boolean}
+ */
+export function isNull(value) {
+    return value === null;
+}

package/src/core/process/matcher/isTypeOf.js

@@ -0,0 +1,16 @@
+import { assert } from "../../assert.js";
+
+const VALID_TYPES = ['number', 'boolean', 'string', 'function', 'object', 'undefined'];
+
+/**
+ * performs typeof match
+ * @param {string} type
+ * @returns {function(*): boolean}
+ */
+export function isTypeOf(type) {
+    assert.notEqual(VALID_TYPES.indexOf(type), -1, `type must be one of [${VALID_TYPES.join(', ')}], instead was '${type}'`);
+
+    return function (m) {
+        return typeof m === type;
+    }
+}

package/src/core/process/matcher/not.js

@@ -0,0 +1,10 @@
+/**
+ *
+ * @param {function} m
+ * @returns {function(*): boolean}
+ */
+export function not(m) {
+    return function (v) {
+        return !m(v);
+    }
+}

package/src/core/process/matcher/or.js

@@ -0,0 +1,16 @@
+import { assert } from "../../assert.js";
+
+/**
+ * Joins two matchers via OR
+ * @param {function(*):boolean} a
+ * @param {function(*):boolean} b
+ * @returns {function(*):boolean}
+ */
+export function or(a, b) {
+    assert.isFunction(a, 'a');
+    assert.isFunction(b, 'b');
+
+    return function (m) {
+        return a(m) || b(m);
+    }
+}

package/src/core/process/task/util/actionTask.spec.js

@@ -0,0 +1,14 @@
+import { jest } from "@jest/globals";
+import { actionTask } from "./actionTask.js";
+
+test("main", () => {
+
+    const mock = jest.fn();
+
+    const task = actionTask(mock);
+
+    task.executeSync();
+
+    expect(mock).toHaveBeenCalledTimes(1);
+
+});

package/src/core/process/task/util/countTask.js

@@ -4,7 +4,7 @@ import { TaskSignal } from "../TaskSignal.js";
 /**
  *
  * @param {number|function(*):number} initial
- * @param {number|function(*):number} limit
+ * @param {number|function(*):number} limit limit is excluded from the count, same as `for(;i < limit;)`
  * @param {function(index:int)} callback
  * @returns {Task}
  */

package/src/core/process/task/util/countTask.spec.js

@@ -0,0 +1,18 @@
+import { jest } from "@jest/globals";
+import { countTask } from "./countTask.js";
+
+test("static count", () => {
+
+    const mock = jest.fn();
+
+    const task = countTask(3, 7, mock);
+
+    task.executeSync();
+
+    expect(mock).toHaveBeenCalledTimes(4);
+
+    expect(mock).toHaveBeenCalledWith(3)
+    expect(mock).toHaveBeenCalledWith(4)
+    expect(mock).toHaveBeenCalledWith(5)
+    expect(mock).toHaveBeenCalledWith(6)
+});

package/src/engine/asset/AssetDescription.js

@@ -49,3 +49,9 @@ export class AssetDescription {
         return `{ type: '${this.type}', path: '${this.path}' }`;
     }
 }
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+AssetDescription.prototype.isAssetDescription = true;

package/src/engine/ecs/Entity.js

@@ -1,8 +1,8 @@
+import { assert } from "../../core/assert.js";
 import Signal from "../../core/events/signal/Signal.js";
-import {assert} from "../../core/assert.js";
-import {EventType} from "./EntityManager.js";
-import {isDefined} from "../../core/process/matcher/Matchers.js";
-import {EntityFlags} from "./EntityFlags.js";
+import { isDefined } from "../../core/process/matcher/isDefined.js";
+import { EntityFlags } from "./EntityFlags.js";
+import { EventType } from "./EntityManager.js";
 
 /**
  * Set of default flags
@@ -205,6 +205,8 @@ class Entity {
      * @returns {*|null}
      */
     removeComponent(klass) {
+        assert.defined(klass, 'klass');
+
         const elements = this.components;
         const n = elements.length;
 
@@ -332,6 +334,7 @@ class Entity {
             dataset.removeEntity(entity);
 
             this.id = -1;
+            this.generation = -1;
 
             this.clearFlag(EntityFlags.Built);
 
@@ -359,6 +362,7 @@ class Entity {
         }
 
         const entity = this.id = dataset.createEntity();
+        this.generation = dataset.getEntityGeneration(entity);
         this.dataset = dataset;
 
         let i;
@@ -416,6 +420,7 @@ class Entity {
         r.setFlag(EntityFlags.Built);
         r.id = entity;
         r.dataset = dataset;
+        r.generation = dataset.getEntityGeneration(entity);
 
         return r;
     }

package/src/engine/ecs/EntityComponentDataset.js

@@ -1,13 +1,14 @@
-import {BitSet} from "../../core/binary/BitSet.js";
-import {assert} from "../../core/assert.js";
+import { assert } from "../../core/assert.js";
+import { BitSet } from "../../core/binary/BitSet.js";
+import { array_shrink_to_size } from "../../core/collection/array/array_shrink_to_size.js";
+import { arraySetDiff } from "../../core/collection/array/arraySetDiff.js";
 import Signal, {
     findSignalHandlerIndexByHandle,
     findSignalHandlerIndexByHandleAndContext
 } from "../../core/events/signal/Signal.js";
-import {EventType} from "./EntityManager.js";
-import {SignalHandler} from "../../core/events/signal/SignalHandler.js";
-import {arraySetDiff} from "../../core/collection/array/arraySetDiff.js";
-import {array_shrink_to_size} from "../../core/collection/array/array_shrink_to_size.js";
+import { SignalHandler } from "../../core/events/signal/SignalHandler.js";
+import { max3 } from "../../core/math/max3.js";
+import { EventType } from "./EntityManager.js";
 
 /**
  *
@@ -116,6 +117,15 @@ export class EntityComponentDataset {
      * @type {BitSet}
      */
     entityOccupancy = new BitSet();
+
+    /**
+     * For each entity ID records generation when entity was created
+     * Values are invalid for unused entity IDs
+     * @private
+     * @type {Uint32Array}
+     */
+    entityGeneration = new Uint32Array(0);
+
     /**
      * @private
      * @type {BitSet}
@@ -167,7 +177,7 @@ export class EntityComponentDataset {
 
     /**
      * @readonly
-     * @type {Signal}
+     * @type {Signal<number>}
      */
     onEntityCreated = new Signal();
 
@@ -448,6 +458,7 @@ export class EntityComponentDataset {
      */
     setComponentTypeMap(map) {
         assert.defined(map, "map");
+        assert.isArray(map, 'map');
 
         const newComponentTypeCount = map.length;
 
@@ -726,38 +737,79 @@ export class EntityComponentDataset {
 
     /**
      *
-     * @returns {number} entityIndex
+     * @param {number} min_size
      */
-    createEntity() {
-        const entityIndex = this.entityOccupancy.nextClearBit(0);
-        this.entityOccupancy.set(entityIndex, true);
+    enlargeGenerationTable(min_size) {
+        const old_generation_table_size = this.entityGeneration.length;
 
-        this.entityCount++;
+        const new_size = max3(
+            min_size,
+            Math.ceil(old_generation_table_size * 1.2),
+            old_generation_table_size + 16
+        );
 
-        this.onEntityCreated.send1(entityIndex);
+        const new_generation_table = new Uint32Array(new_size);
 
-        this.generation++;
+        new_generation_table.set(this.entityGeneration);
 
-        return entityIndex;
+        this.entityGeneration = new_generation_table
     }
 
     /**
-     *
-     * @param {number} entityIndex
-     * @throws {Error} if entity index is already in use
+     * Produces generation ID for a given entity
+     * @param {number} entity_id
+     * @returns {number}
+     */
+    getEntityGeneration(entity_id) {
+        return this.entityGeneration[entity_id];
+    }
+
+    /**
+     * @private
+     * @param {number} entity_id
      */
-    createEntitySpecific(entityIndex) {
-        if (this.entityExists(entityIndex)) {
-            throw new Error(`EntityId ${entityIndex} is already in use`);
+    createEntityUnsafe(entity_id) {
+        this.entityOccupancy.set(entity_id, true);
+
+        // record entity generation
+        if (this.entityGeneration.length <= entity_id) {
+            // needs to be resized
+            this.enlargeGenerationTable(entity_id + 1);
         }
 
-        this.entityOccupancy.set(entityIndex, true);
+        const current_generation = this.generation;
+        this.generation = current_generation + 1;
+
+        this.entityGeneration[entity_id] = current_generation;
 
         this.entityCount++;
 
-        this.onEntityCreated.send1(entityIndex);
+        this.onEntityCreated.send1(entity_id);
+    }
+
+    /**
+     *
+     * @returns {number} entityIndex
+     */
+    createEntity() {
+        const entity_id = this.entityOccupancy.nextClearBit(0);
+
+        this.createEntityUnsafe(entity_id);
+
+        return entity_id;
+    }
+
+    /**
+     *
+     * @param {number} entity_id
+     * @throws {Error} if entity index is already in use
+     */
+    createEntitySpecific(entity_id) {
+        if (this.entityExists(entity_id)) {
+            throw new Error(`EntityId ${entity_id} is already in use`);
+        }
 
-        this.generation++;
+        this.createEntityUnsafe(entity_id);
     }
 
     /**
@@ -887,7 +939,7 @@ export class EntityComponentDataset {
         const componentClass = this.componentTypeMap[componentIndex];
 
         //dispatch event to components
-        this.sendEvent(entityIndex, EventType.ComponentRemoved, {klass: componentClass, instance: componentInstance});
+        this.sendEvent(entityIndex, EventType.ComponentRemoved, { klass: componentClass, instance: componentInstance });
     }
 
     /**
@@ -999,7 +1051,7 @@ export class EntityComponentDataset {
         const componentClass = this.componentTypeMap[componentIndex];
 
         //dispatch event to components
-        this.sendEvent(entityIndex, EventType.ComponentAdded, {klass: componentClass, instance: componentInstance});
+        this.sendEvent(entityIndex, EventType.ComponentAdded, { klass: componentClass, instance: componentInstance });
     }
 
     /**

package/src/view/common/LabelView.js

@@ -14,7 +14,9 @@ import ObservedString from "../../core/model/ObservedString.js";
 import ObservedValue from "../../core/model/ObservedValue.js";
 import Stat from "../../core/model/stat/Stat.js";
 import { number_pretty_print } from "../../core/primitives/numbers/number_pretty_print.js";
-import { isInstanceOf, isTypeOf, or } from "../../core/process/matcher/Matchers.js";
+import { isInstanceOf } from "../../core/process/matcher/isInstanceOf.js";
+import { isTypeOf } from "../../core/process/matcher/isTypeOf.js";
+import { or } from "../../core/process/matcher/or.js";
 import { frameThrottle } from "../../engine/graphics/FrameThrottle.js";
 import View from "../View.js";
 

package/src/view/elements/windrose/WindRoseDiagram.js

@@ -1,10 +1,10 @@
-import View from "../../View.js";
 import { assert } from "../../../core/assert.js";
-import EmptyView from "../EmptyView.js";
+import { isDefined } from "../../../core/process/matcher/isDefined.js";
 import LabelView from "../../common/LabelView.js";
 import SVG from "../../SVG.js";
+import View from "../../View.js";
+import EmptyView from "../EmptyView.js";
 import ImageView from "../image/ImageView.js";
-import { isDefined } from "../../../core/process/matcher/Matchers.js";
 
 export class WindRoseDiagram extends View {
 

package/src/core/math/spline/spline_catmullrom_1d.js

@@ -1,120 +0,0 @@
-
-/**
- *
- * @param {number} p0
- * @param {number} p1
- * @param {number} half_alpha between 0..0.5
- * @returns {number}
- */
-function getT(p0, p1, half_alpha) {
-    const dx = p0 - p1;
-
-    const a = dx * dx;
-
-    return Math.pow(a, half_alpha);
-}
-
-
-/**
- * Alpha assumed to be 0.5
- * @param {number} f
- * @param {number} p0
- * @param {number} p1
- * @param {number} p2
- * @param {number} p3
- * @returns {number}
- */
-export function spline_catmullrom_1d(
-    f,
-    p0, p1, p2, p3
-) {
-    const half_alpha = 0.25;
-
-    // calculate T
-    const t0 = 0;
-    let t_01 = getT(p0, p1, half_alpha);
-    let t_02 = getT(p1, p2, half_alpha);
-    let t_03 = getT(p2, p3, half_alpha);
-
-    // safety check for repeated points, to prevent division by 0
-    if (t_01 < 1e-5) {
-        t_01 = 1;
-    }
-    if (t_02 < 1e-5) {
-        t_02 = t_01;
-    }
-    if (t_03 < 1e-5) {
-        t_03 = t_02;
-    }
-
-    const t1 = t_01 + t0;
-    const t2 = t_02 + t1;
-    const t3 = t_03 + t2;
-
-    /**
-     * Interpolation between points 1 and 2
-     * @type {number}
-     */
-    const t = t1 * (1 - f) + t2 * f;
-
-    /*
-            Vector2 A1 = (t1-t)/(t1-t0)*p0 + (t-t0)/(t1-t0)*p1;
-		    Vector2 A2 = (t2-t)/(t2-t1)*p1 + (t-t1)/(t2-t1)*p2;
-		    Vector2 A3 = (t3-t)/(t3-t2)*p2 + (t-t2)/(t3-t2)*p3;
-
-		    Vector2 B1 = (t2-t)/(t2-t0)*A1 + (t-t0)/(t2-t0)*A2;
-		    Vector2 B2 = (t3-t)/(t3-t1)*A2 + (t-t1)/(t3-t1)*A3;
-
-		    Vector2 C = (t2-t)/(t2-t1)*B1 + (t-t1)/(t2-t1)*B2;
-     */
-
-    const d_t1_t0 = t1 - t0;
-
-    const m_A1_0 = (t1 - t) / d_t1_t0;
-    const m_A1_1 = (t - t0) / d_t1_t0;
-
-    const d_t2_t1 = t2 - t1;
-
-    const m_A2_0 = (t2 - t) / d_t2_t1;
-
-    const d_t_t1 = t - t1;
-
-    const m_A2_1 = d_t_t1 / d_t2_t1;
-
-    const d_t3_t2 = t3 - t2;
-
-    const d_t3_t = t3 - t;
-
-    const m_A3_0 = d_t3_t / d_t3_t2;
-    const m_A3_1 = (t - t2) / d_t3_t2;
-
-    const d_t2_t0 = t2 - t0;
-
-    const m_B1_0 = (t2 - t) / d_t2_t0;
-    const m_B1_1 = (t - t0) / d_t2_t0;
-
-    const d_t3_t1 = t3 - t1;
-
-    const m_B2_0 = d_t3_t / d_t3_t1;
-    const m_B2_1 = d_t_t1 / d_t3_t1;
-
-    const m_C_0 = (t2 - t) / d_t2_t1;
-    const m_C_1 = d_t_t1 / d_t2_t1;
-
-    // read vector values for the dimension
-    const v0 = p0;
-    const v1 = p1;
-    const v2 = p2;
-    const v3 = p3;
-
-    // compute resulting value in this dimension
-    const A1 = m_A1_0 * v0 + m_A1_1 * v1;
-    const A2 = m_A2_0 * v1 + m_A2_1 * v2;
-    const A3 = m_A3_0 * v2 + m_A3_1 * v3;
-
-    const B1 = m_B1_0 * A1 + m_B1_1 * A2;
-    const B2 = m_B2_0 * A2 + m_B2_1 * A3;
-
-    return m_C_0 * B1 + m_C_1 * B2;
-
-}

package/src/core/process/IntervalExecutor.js

@@ -1,78 +0,0 @@
-/**
- * Created by Alex on 22/05/2016.
- */
-
-/**
- *
- * @param {number} quietTime in milliseconds
- * @param {number} workTime in milliseconds
- * @constructor
- */
-function IntervalExecutor(quietTime, workTime) {
-    this.quietTime = quietTime;
-    this.workTime = workTime;
-    this.tasks = [];
-    this.busy = false;
-    this.timeLastWorkDone = 0;
-}
-
-/**
- *
- * @param {function} task
- */
-IntervalExecutor.prototype.add = function (task) {
-    this.tasks.push(task);
-    this.prod();
-};
-
-IntervalExecutor.prototype.prod = function () {
-    const self = this;
-    const tasks = this.tasks;
-
-    function processCycle() {
-        const t = Date.now();
-        let timeNow = t;
-
-        let workTime = 0;
-
-        while (tasks.length > 0) {
-            const task = tasks.shift();
-            task();
-
-            timeNow = Date.now();
-            workTime = timeNow - t;
-            if (workTime >= self.workTime) {
-                //time slice ended
-                break;
-            }
-        }
-
-        self.timeLastWorkDone = timeNow;
-
-        if (tasks.length > 0) {
-            //compute adaptive quiet time based on how long we worked for
-            const workOverBudget = workTime - self.workTime;
-            const sleepTime = self.quietTime + Math.max(workOverBudget, 0);
-
-            //still some tasks left, schedule next slice
-            setTimeout(processCycle, sleepTime);
-        } else {
-            //all tasks done, reset the 'busy' flag
-            self.busy = false;
-        }
-    }
-
-    if (!this.busy && tasks.length > 0) {
-        this.busy = true;
-        const timeSinceLastWork = Date.now() - this.timeLastWorkDone;
-        const quietTimeDelta = this.quietTime - timeSinceLastWork;
-        if (quietTimeDelta < 0) {
-            processCycle();
-        } else {
-            setTimeout(processCycle, quietTimeDelta);
-        }
-    }
-};
-
-
-export default IntervalExecutor;