@woosh/meep-engine 2.84.2 → 2.84.4

package/build/meep.module.js

@@ -63964,7 +63964,7 @@ Task.prototype.isTask = true;
 /**
  *
  * @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}
  */
@@ -69662,6 +69662,36 @@ function array_remove_first(array, element, start_index = 0, length = array.leng
     return false;
 }
 
+/**
+ *
+ * @param {*} value
+ * @return {boolean}
+ */
+function isDefined(value) {
+    return value !== undefined;
+}
+
+/**
+ *
+ * @enum
+ */
+const EntityFlags = {
+    /**
+     * Whether the entity is built, set internally
+     */
+    Built: 1,
+    /**
+     * If component type is not registered on the {@link EntityComponentDataset} when calling {@link Entity#build} - will register the component first
+     */
+    RegisterComponents: 2,
+    /**
+     * Entity builder will watch destruction of the entity (subscribe to event), this will make the {@link Entity} automatically
+     * recognize when the corresponding entity is destroyed outside the {@link Entity} API
+     * NOTE: useful to turn off to save a bit of memory, as those event listeners take up a bit of space. Feel free to turn this flag off when you don't care to keep the reference to the {@link Entity}
+     */
+    WatchDestruction: 4
+};
+
 /**
  * de Bruijn sequence
  * @see https://graphics.stanford.edu/~seander/bithacks.html
@@ -72274,78 +72304,6 @@ class EntityManager {
     }
 }
 
-/**
- * @author Alex Goldring
- * @copyright Alex Goldring 2017
- */
-
-
-/**
- *
- * @param {*} value
- * @return {boolean}
- */
-function isDefined(value) {
-    return value !== undefined;
-}
-
-/**
- * performs instanceof match
- * @param {function} type
- * @returns {function(*): boolean}
- */
-function isInstanceOf$1(type) {
-    return function (m) {
-        return m instanceof type;
-    }
-}
-
-/**
- * performs typeof match
- * @param {string} type
- * @returns {function(*): boolean}
- */
-function isTypeOf(type) {
-
-    return function (m) {
-        return typeof m === type;
-    }
-}
-
-/**
- * Joins two matchers via OR
- * @param {function(*):boolean} a
- * @param {function(*):boolean} b
- * @returns {function(*):boolean}
- */
-function or(a, b) {
-
-    return function (m) {
-        return a(m) || b(m);
-    }
-}
-
-/**
- *
- * @enum
- */
-const EntityFlags = {
-    /**
-     * Whether the entity is built, set internally
-     */
-    Built: 1,
-    /**
-     * If component type is not registered on the {@link EntityComponentDataset} when calling {@link Entity#build} - will register the component first
-     */
-    RegisterComponents: 2,
-    /**
-     * Entity builder will watch destruction of the entity (subscribe to event), this will make the {@link Entity} automatically
-     * recognize when the corresponding entity is destroyed outside the {@link Entity} API
-     * NOTE: useful to turn off to save a bit of memory, as those event listeners take up a bit of space. Feel free to turn this flag off when you don't care to keep the reference to the {@link Entity}
-     */
-    WatchDestruction: 4
-};
-
 /**
  * Set of default flags
  * @type {number}
@@ -89823,7 +89781,7 @@ class InputDeviceSwitch {
  * @param klass
  * @returns {boolean}
  */
-function isInstanceOf(thing, klass) {
+function isInstanceOf$1(thing, klass) {
     if (klass === undefined) {
         return false;
     }
@@ -89844,12 +89802,12 @@ function isInstanceOf(thing, klass) {
  * @param {Element} el
  */
 function isFocusable(el) {
-    return isInstanceOf(el, HTMLInputElement)
-        || isInstanceOf(el, HTMLSelectElement)
-        || isInstanceOf(el, HTMLTextAreaElement)
-        || isInstanceOf(el, HTMLAnchorElement)
-        || isInstanceOf(el, HTMLButtonElement)
-        || isInstanceOf(el, HTMLAreaElement)
+    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)
 }
 
 /**
@@ -96121,6 +96079,42 @@ function number_pretty_print(value) {
 
 }
 
+/**
+ * performs instanceof match
+ * @param {function} type
+ * @returns {function(*): boolean}
+ */
+function isInstanceOf(type) {
+    return function (m) {
+        return m instanceof type;
+    }
+}
+
+/**
+ * performs typeof match
+ * @param {string} type
+ * @returns {function(*): boolean}
+ */
+function isTypeOf(type) {
+
+    return function (m) {
+        return typeof m === type;
+    }
+}
+
+/**
+ * Joins two matchers via OR
+ * @param {function(*):boolean} a
+ * @param {function(*):boolean} b
+ * @returns {function(*):boolean}
+ */
+function or(a, b) {
+
+    return function (m) {
+        return a(m) || b(m);
+    }
+}
+
 /**
  * Created by Alex on 01/11/2014.
  * @copyright Alex Goldring 2014
@@ -96269,14 +96263,14 @@ function p(m, e, f) {
  * @type {Array.<ValueProcessor>}
  */
 const processors = [
-    p(isInstanceOf$1(ObservedBoolean), extractorGetValue, format),
-    p(isInstanceOf$1(ObservedValue), extractorGetValue, format),
-    p(isInstanceOf$1(ObservedString), extractorGetValue, format),
-    p(isInstanceOf$1(LinearValue), extractorGetValue, formatNumber),
-    p(isInstanceOf$1(BoundedValue), extractBoundedValue, formatArray),
-    p(isInstanceOf$1(Stat), extractorGetValue, formatNumber),
-    p(isInstanceOf$1(Vector1), extractorGetValue, formatNumber),
-    p(isInstanceOf$1(ObservedInteger), extractorGetValue, formatNumber),
+    p(isInstanceOf(ObservedBoolean), extractorGetValue, format),
+    p(isInstanceOf(ObservedValue), extractorGetValue, format),
+    p(isInstanceOf(ObservedString), extractorGetValue, format),
+    p(isInstanceOf(LinearValue), extractorGetValue, formatNumber),
+    p(isInstanceOf(BoundedValue), extractBoundedValue, formatArray),
+    p(isInstanceOf(Stat), extractorGetValue, formatNumber),
+    p(isInstanceOf(Vector1), extractorGetValue, formatNumber),
+    p(isInstanceOf(ObservedInteger), extractorGetValue, formatNumber),
     p(or(isTypedArray, Array.isArray), arrayUnwrap, formatArray),
     p(isTypeOf("number"), passThrough, formatNumber),
     p(isTypeOf("string"), passThrough, passThrough),

package/editor/view/ecs/EntityEditor.js

@@ -1,22 +1,21 @@
 /**
  * Created by Alex on 15/01/2017.
  */
-import View from "../../../src/view/View.js";
-import dom from "../../../src/view/DOM.js";
-
 import List from '../../../src/core/collection/list/List.js';
 import ObservedValue from '../../../src/core/model/ObservedValue.js';
+import { isDefined } from "../../../src/core/process/matcher/isDefined.js";
+import { EntityManager, EventType } from "../../../src/engine/ecs/EntityManager.js";
 import LabelView from '../../../src/view/common/LabelView.js';
+import dom from "../../../src/view/DOM.js";
 import ButtonView from '../../../src/view/elements/button/ButtonView.js';
 import DropDownSelectionView from '../../../src/view/elements/DropDownSelectionView.js';
 import EmptyView from "../../../src/view/elements/EmptyView.js";
-import { EntityManager, EventType } from "../../../src/engine/ecs/EntityManager.js";
-import ComponentRemoveAction from "../../actions/concrete/ComponentRemoveAction.js";
+import View from "../../../src/view/View.js";
 import ComponentAddAction from "../../actions/concrete/ComponentAddAction.js";
-import { LineView } from "./components/common/LineView.js";
-import { ComponentControlView } from "./ComponentControlView.js";
+import ComponentRemoveAction from "../../actions/concrete/ComponentRemoveAction.js";
 import { buildObjectEditorFromRegistry } from "../../ecs/component/createObjectEditor.js";
-import { isDefined } from "../../../src/core/process/matcher/Matchers.js";
+import { ComponentControlView } from "./ComponentControlView.js";
+import { LineView } from "./components/common/LineView.js";
 
 
 class EntityEditor extends View {

package/package.json

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

package/src/core/math/random/roundFair.js

@@ -5,11 +5,14 @@
  * @returns {int}
  */
 export function roundFair(number, random) {
+
     const mantissa = number % 1;
     const roll = random();
+
     if (roll < mantissa) {
-        return Math.ceil(number);
-    } else {
         return Math.floor(number);
+    } else {
+        return Math.ceil(number);
     }
+
 }

package/src/core/math/random/roundFair.spec.js

@@ -0,0 +1,12 @@
+import { roundFair } from "./roundFair.js";
+
+test("basics", () => {
+
+    expect(roundFair(0.3, () => 0)).toEqual(0);
+    expect(roundFair(0.3, () => 0.1)).toEqual(0);
+    expect(roundFair(0.3, () => 0.299)).toEqual(0);
+    expect(roundFair(0.3, () => 0.31)).toEqual(1);
+    expect(roundFair(0.3, () => 0.9)).toEqual(1);
+    expect(roundFair(0.3, () => 1)).toEqual(1);
+
+});

package/src/core/math/random/seededRandom.d.ts

@@ -1,4 +1 @@
-export declare function seededRandom(seed?: number): () => number | {
-    setCurrentSeed(v: number): void,
-    getCurrentSeed(): number
-}
+export declare function seededRandom(seed?: number): () => number

package/src/core/math/random/seededRandom_Mulberry32.spec.js

@@ -0,0 +1,19 @@
+import { seededRandom_Mulberry32 } from "./seededRandom_Mulberry32.js";
+
+test("predictable sequence", () => {
+
+    const random = seededRandom_Mulberry32(1337);
+
+    const seq_a = new Array(29).map(random);
+
+    const seed_a = random.getCurrentSeed();
+
+    random.setCurrentSeed(1337);
+
+    const seq_b = new Array(29).map(random);
+
+    const seed_b = random.getCurrentSeed();
+
+    expect(seq_b).toEqual(seq_a);
+    expect(seed_a).toEqual(seed_b);
+});

package/src/core/model/node-graph/node/NodeInstancePortReference.spec.js

@@ -49,8 +49,12 @@ test("incoming connections", () => {
     expect(port_b_ref.inConnections).toEqual([connection]);
 });
 
-test("hash", () => {
 
+/**
+ *
+ * @returns {NodeInstancePortReference}
+ */
+function sample_a() {
     const nd = new NodeDescription();
     const port_a_id = nd.createPort(DUMMY_TYPE, "a", PortDirection.Out);
 
@@ -58,9 +62,28 @@ test("hash", () => {
     const graph = new NodeGraph();
     const node_instance_id = graph.createNode(nd);
 
-    const port_a_ref = graph.getConnectionEndpoint(node_instance_id, port_a_id);
+    return graph.getConnectionEndpoint(node_instance_id, port_a_id);
+}
+
+test("hash", () => {
+    const port_a_ref = sample_a();
 
     expect(port_a_ref.hash()).toEqual(port_a_ref.hash());
     expect(typeof port_a_ref.hash()).toBe("number");
     expect(Number.isInteger(port_a_ref.hash())).toBe(true);
+});
+
+test("toString", () => {
+
+    const s = sample_a().toString();
+
+    expect(typeof s).toEqual("string");
+    expect(s.length).toBeGreaterThan(0);
+});
+
+test("self equality", () => {
+
+    const ref = sample_a();
+
+    expect(ref.equals(ref)).toBe(true);
 });

package/src/core/model/node-graph/node/Port.js

@@ -1,9 +1,9 @@
-import {assert} from "../../../assert.js";
-import {computeHashIntegerArray} from "../../../collection/array/computeHashIntegerArray.js";
-import {computeStringHash} from "../../../primitives/strings/computeStringHash.js";
-import {objectKeyByValue} from "../../object/objectKeyByValue.js";
-import {DataType} from "../DataType.js";
-import {PortDirection} from "./PortDirection.js";
+import { assert } from "../../../assert.js";
+import { computeHashIntegerArray } from "../../../collection/array/computeHashIntegerArray.js";
+import { computeStringHash } from "../../../primitives/strings/computeStringHash.js";
+import { objectKeyByValue } from "../../object/objectKeyByValue.js";
+import { DataType } from "../DataType.js";
+import { PortDirection } from "./PortDirection.js";
 
 /**
  * @type {number}
@@ -94,6 +94,8 @@ export class Port {
                  id, name, direction, dataType
              }, registry) {
 
+        assert.isNonNegativeInteger(id, 'id');
+
         this.id = id;
         this.name = name;
         this.direction = PortDirection[direction];

package/src/core/model/node-graph/node/Port.spec.js

@@ -1,4 +1,7 @@
+import { DataType } from "../DataType.js";
+import { NodeRegistry } from "./NodeRegistry.js";
 import { Port } from "./Port.js";
+import { PortDirection } from "./PortDirection.js";
 
 test("constructor does not throw", () => {
     expect(() => new Port()).not.toThrow();
@@ -51,3 +54,49 @@ test("toString on newly crated instance produces a valid string", () => {
     expect(typeof s).toBe('string');
     expect(s.trim().length).toBeGreaterThan(0); // non-empty
 });
+
+test("fromJSON", () => {
+
+    const registry = new NodeRegistry();
+
+    registry.addType(DataType.from(7, "t"));
+
+    const port = new Port();
+
+    port.fromJSON({
+        id: 3,
+        name: "x",
+        direction: "In",
+        dataType: {
+            id: 7,
+            name: "t"
+        }
+    }, registry);
+
+    expect(port.id).toEqual(3);
+    expect(port.name).toEqual("x");
+    expect(port.direction).toEqual(PortDirection.In);
+    expect(port.dataType.id).toEqual(7);
+    expect(port.dataType.name).toEqual("t");
+});
+
+test("toJSON", () => {
+
+    const port = new Port();
+
+    port.id = 3;
+    port.name = "x";
+    port.direction = PortDirection.Out;
+    port.dataType = DataType.from(7, "t");
+
+    expect(port.toJSON()).toEqual({
+        id: 3,
+        name: "x",
+        direction: "Out",
+        dataType: {
+            id: 7,
+            name: "t"
+        }
+    });
+
+});

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

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

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

@@ -0,0 +1,8 @@
+/**
+ *
+ * @param {*} value
+ * @return {boolean}
+ */
+export function isDefined(value) {
+    return value !== undefined;
+}

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

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

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

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

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

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

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/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

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";