@woosh/meep-engine 2.110.14 → 2.111.0

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

@@ -1,102 +0,0 @@
-import { DataType } from "../type/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();
-});
-
-test("hash is consistent", () => {
-    const port = new Port();
-
-    expect(port.hash()).toEqual(port.hash());
-});
-
-test("hash is an unsigned integer", () => {
-    const port = new Port();
-
-    const hash = port.hash();
-
-    expect(typeof hash).toEqual("number");
-    expect(Number.isInteger(hash)).toEqual(true);
-    expect(hash).toBeGreaterThanOrEqual(0);
-});
-
-test("hash is different for different ports", () => {
-
-    const a = new Port();
-    const b = new Port();
-
-    expect(a.hash()).not.toEqual(b.hash());
-});
-
-test("equality works as intended", () => {
-    const a = new Port();
-
-    expect(a.equals(a)).toEqual(true);
-
-    const b = new Port();
-
-    expect(b.equals(a)).toEqual(false);
-
-    b.id = a.id;
-
-    expect(b.equals(a)).toEqual(true);
-
-});
-
-test("toString on newly crated instance produces a valid string", () => {
-    const port = new Port();
-
-    const s = port.toString();
-
-    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/model/node-graph/type/DataType.spec.js

@@ -1,47 +0,0 @@
-import { DataType } from "./DataType.js";
-
-test('to/from json', () => {
-    const a = DataType.from(7, 'kitty');
-
-    const b = new DataType();
-
-    b.fromJSON(a.toJSON());
-
-    expect(b.id).toBe(a.id);
-    expect(b.name).toBe(a.name);
-
-});
-
-test('equals', () => {
-    const a = DataType.from(7, 'kitty');
-    const b = DataType.from(7, 'kitty');
-    const c = DataType.from(7, 'fluffy');
-    const d = DataType.from(9, 'kitty');
-
-
-    expect(a.equals(b)).toBe(true);
-
-    expect(a.equals(c)).toBe(false);
-    expect(a.equals(d)).toBe(false);
-
-    expect(c.equals(d)).toBe(false);
-});
-
-test("hash", () => {
-
-    const a = DataType.from(7, 'kitty');
-    const b = DataType.from(7, 'kitty');
-
-    expect(a.hash()).toEqual(a.hash()); //stability
-    expect(typeof a.hash()).toBe("number");
-    expect(Number.isInteger(a.hash())).toBe(true);
-
-
-    expect(a.hash()).toEqual(b.hash());
-});
-
-test("toString", () => {
-    const type = DataType.from(7, 'kitty');
-
-    expect(typeof type.toString()).toBe("string");
-});

package/src/core/model/node-graph/type/ParametricDataType.spec.js

@@ -1,63 +0,0 @@
-import { DataType } from "./DataType.js";
-import { ParametricDataType } from "./ParametricDataType.js";
-
-test("to/from json", () => {
-
-    const t = ParametricDataType.from(1, "x", [
-        DataType.from(7, "a")
-    ]);
-
-    const json = t.toJSON();
-
-
-    const actual = new ParametricDataType();
-
-    actual.fromJSON(json);
-
-    expect(actual.id).toEqual(1);
-    expect(actual.name).toEqual("x");
-    expect(actual.parameters.length).toEqual(1);
-    expect(actual.parameters[0].id).toEqual(7);
-    expect(actual.parameters[0].name).toEqual("a");
-    expect(actual.parameters[0]).toBeInstanceOf(DataType);
-});
-
-test("equals", () => {
-
-    expect(
-        ParametricDataType.from(1, "x", [
-            DataType.from(7, "a")
-        ]).equals(ParametricDataType.from(1, "x", [
-            DataType.from(7, "a")
-        ]))
-    ).toBe(true);
-
-    const t = ParametricDataType.from(1, "x");
-
-    expect(t.equals(t)).toBe(true);
-
-    expect(ParametricDataType.from(1, "x").equals(ParametricDataType.from(7, "x"))).toBe(false);
-    expect(ParametricDataType.from(1, "x").equals(ParametricDataType.from(1, "y"))).toBe(false);
-
-    expect(
-        ParametricDataType.from(1, "x", [
-            DataType.from(7, "a")
-        ]).equals(ParametricDataType.from(1, "x", [
-            DataType.from(11, "a")
-        ]))
-    ).toBe(false);
-
-    expect(
-        ParametricDataType.from(1, "x", [
-            DataType.from(7, "a")
-        ]).equals(ParametricDataType.from(1, "x", [
-            DataType.from(7, "b")
-        ]))
-    ).toBe(false);
-
-    expect(
-        ParametricDataType.from(1, "x", [
-            DataType.from(7, "a")
-        ]).equals(ParametricDataType.from(1, "x"))
-    ).toBe(false);
-});

package/src/core/model/node-graph/visual/PortVisualData.spec.js

@@ -1,16 +0,0 @@
-import { PortVisualData } from "./PortVisualData.js";
-
-test("to/from JSON serialization", () => {
-    const a = new PortVisualData();
-
-    const b = new PortVisualData();
-
-    a.id = 7;
-    a.position.set(3, 11);
-
-    b.fromJSON(a.toJSON());
-
-    expect(b.id).toBe(7);
-    expect(b.position.x).toBe(3);
-    expect(b.position.y).toBe(11);
-});

package/src/core/model/object/ObjectPoolFactory.spec.js

@@ -1,54 +0,0 @@
-import { ObjectPoolFactory } from "./ObjectPoolFactory.js";
-
-function create() {
-    return {};
-}
-
-function destroy() {
-
-}
-
-function reset() {
-
-}
-
-test("Reuses objects", () => {
-    const sut = new ObjectPoolFactory(create, destroy, reset);
-
-    const a = sut.create();
-
-    sut.release(a);
-
-    const b = sut.create();
-
-    //must be the same object
-    expect(a).toBe(b);
-});
-
-test("maxSize is respected", () => {
-
-    const sut = new ObjectPoolFactory(create, destroy, reset);
-
-    sut.maxSize = 2;
-
-    const a = sut.create();
-    const b = sut.create();
-    const c = sut.create();
-
-    sut.release(a);
-    sut.release(b);
-    //this one is beyond pool capacity
-    sut.release(c);
-
-    const x = sut.create();
-    const y = sut.create();
-    const z = sut.create();
-
-    expect(x === a || x === b).toBeTruthy();
-    expect(x).not.toBe(c);
-
-    expect(y === a || y === b).toBeTruthy();
-    expect(y).not.toBe(c);
-
-    expect(z).not.toBe(c);
-});

package/src/core/model/object/objectDeepEquals.spec.js

@@ -1,54 +0,0 @@
-import { objectDeepEquals } from "./objectDeepEquals.js";
-
-test('objectDeepEquals', () => {
-    expect(objectDeepEquals({}, {})).toBe(true);
-    expect(objectDeepEquals({ a: 1 }, { a: 1 })).toBe(true);
-    expect(objectDeepEquals({ a: 1 }, { a: 2 })).toBe(false);
-    expect(objectDeepEquals({ a: 2 }, { a: 1 })).toBe(false);
-
-    expect(objectDeepEquals({ a: 1, b: "cat" }, { a: 1, b: "cat" })).toBe(true);
-
-    expect(objectDeepEquals({ a: 1, b: "cat" }, { a: 1 })).toBe(false);
-
-    expect(objectDeepEquals({ a: 1 }, { a: 1, b: "cat" })).toBe(false);
-});
-
-test("null values", () => {
-    expect(objectDeepEquals(null, null)).toBe(true);
-    expect(objectDeepEquals(null, {})).toBe(false);
-    expect(objectDeepEquals({}, null)).toBe(false);
-});
-
-test("same-type primitives", () => {
-    expect(objectDeepEquals(1, 1)).toBe(true);
-    expect(objectDeepEquals(-1, 1)).toBe(false);
-    expect(objectDeepEquals(-1, -1)).toBe(true);
-    expect(objectDeepEquals(-1, -3)).toBe(false);
-
-    expect(objectDeepEquals("cat", "cat")).toBe(true);
-    expect(objectDeepEquals("cat", "")).toBe(false);
-    expect(objectDeepEquals("", "cat")).toBe(false);
-    expect(objectDeepEquals("sat", "cat")).toBe(false);
-    expect(objectDeepEquals("cat", "sat")).toBe(false);
-
-    expect(objectDeepEquals(true, false)).toBe(false);
-    expect(objectDeepEquals(false, true)).toBe(false);
-    expect(objectDeepEquals(true, true)).toBe(true);
-    expect(objectDeepEquals(false, false)).toBe(true);
-
-    expect(objectDeepEquals(undefined, undefined)).toBe(true);
-});
-
-test("mixed primitives", () => {
-    expect(objectDeepEquals(1, undefined)).toBe(false);
-    expect(objectDeepEquals(undefined, 1)).toBe(false);
-
-    expect(objectDeepEquals("cat", 1)).toBe(false);
-    expect(objectDeepEquals(1, "cat")).toBe(false);
-
-    expect(objectDeepEquals(1, true)).toBe(false);
-    expect(objectDeepEquals(true, 1)).toBe(false);
-
-    expect(objectDeepEquals("cat", undefined)).toBe(false);
-    expect(objectDeepEquals(undefined, "cat")).toBe(false);
-});

package/src/core/model/object/write_property.spec.js

@@ -1,26 +0,0 @@
-import { write_property } from "./write_property.js";
-
-test("write via setter method", () => {
-
-    let value = 1;
-
-    const thing = {
-        setValue(v) {
-            value = v
-        }
-    }
-
-    write_property(thing, ['value'], 0, 1, 31);
-
-    expect(value).toEqual(31);
-});
-test("write via property accessor", () => {
-
-    const thing = {
-        value: 1
-    }
-
-    write_property(thing, ['value'], 0, 1, 31);
-
-    expect(thing.value).toEqual(31);
-});

package/src/core/model/reactive/evaluation/MultiPredicateEvaluator.spec.js

@@ -1,158 +0,0 @@
-import { seededRandom } from "../../../math/random/seededRandom.js";
-import DataType from "../../../parser/simple/DataType.js";
-import { ReactiveLiteralBoolean } from "../model/terminal/ReactiveLiteralBoolean.js";
-import { ReactiveLiteralNumber } from "../model/terminal/ReactiveLiteralNumber.js";
-import { ReactiveLiteralString } from "../model/terminal/ReactiveLiteralString.js";
-import { ReactiveReference } from "../model/terminal/ReactiveReference.js";
-import { createRandomReactiveExpression } from "../model/util/createRandomReactiveExpression.js";
-import { MultiPredicateEvaluator } from "./MultiPredicateEvaluator.js";
-import { randomFromArray } from "../../../math/random/randomFromArray.js";
-import { randomFloatBetween } from "../../../math/random/randomFloatBetween.js";
-import { randomIntegerBetween } from "../../../math/random/randomIntegerBetween.js";
-import { ReactiveEquals } from "../model/comparative/ReactiveEquals.js";
-
-test('constructor does not throw', () => {
-    expect(() => new MultiPredicateEvaluator()).not.toThrow();
-});
-
-test('build empty', () => {
-    const processor = new MultiPredicateEvaluator();
-
-    expect(() => processor.build([])).not.toThrow();
-});
-
-test('match against empty list of predicates', () => {
-
-    const processor = new MultiPredicateEvaluator();
-    processor.build([]);
-
-    processor.initialize({});
-
-    expect(processor.next()).toBeUndefined();
-});
-
-test('match against one predicate', () => {
-
-    const processor = new MultiPredicateEvaluator();
-
-    const predicate = ReactiveEquals.from(new ReactiveReference('a'), ReactiveLiteralNumber.from(7));
-
-    processor.build([predicate]);
-
-    processor.initialize({ a: 1 });
-
-    expect(processor.next()).toBeUndefined();
-
-    processor.finalize();
-    processor.initialize({ a: 7 });
-
-    expect(processor.next()).toBe(predicate);
-    expect(processor.next()).toBeUndefined();
-
-});
-
-test.skip('performance', () => {
-    const random = seededRandom(12319);
-
-    const names = [];
-
-    const NAME_COUNT = 100;
-    for (let i = 0; i < NAME_COUNT; i++) {
-        names.push(`n${i}`);
-    }
-
-    const references = names.map(n => {
-        const ref = new ReactiveReference(n);
-
-        ref.dataType = DataType.Number;
-
-        return ref;
-    });
-
-    const literals = [];
-
-    for (let i = 0; i < 5; i++) {
-        literals.push(ReactiveLiteralNumber.from(randomFloatBetween(random, -10, 10)));
-    }
-
-    for (let i = 0; i < 5; i++) {
-        literals.push(ReactiveLiteralString.from(`string-${i}`));
-    }
-
-    literals.push(ReactiveLiteralBoolean.from(true));
-    literals.push(ReactiveLiteralBoolean.from(false));
-
-    const terminals = references.concat(literals);
-
-    const expressions = [];
-
-    const EXPRESSION_COUNT = 5000;
-    for (let i = 0; i < EXPRESSION_COUNT; i++) {
-
-        let exp;
-
-        do {
-            exp = createRandomReactiveExpression(random, terminals, randomIntegerBetween(random, 3, 15));
-        } while (exp.dataType !== DataType.Boolean);
-
-        expressions.push(exp);
-
-    }
-    const contexts = [];
-
-    const CONTEXT_COUNT = 5000;
-
-    for (let i = 0; i < CONTEXT_COUNT; i++) {
-        const v = {};
-
-        for (let j = 0; j < NAME_COUNT; j++) {
-            const roll = random();
-
-            if (roll < 0.03) {
-                continue;
-            }
-
-            const name = names[j];
-
-            v[name] = randomIntegerBetween(random, -10, 10);
-        }
-
-        contexts[i] = v;
-    }
-
-    const evaluator = new MultiPredicateEvaluator(exp => exp.computeTreeSize());
-
-    evaluator.build(expressions);
-
-
-    function cycle(context) {
-        evaluator.initialize(context);
-        evaluator.next();
-        evaluator.finalize();
-    }
-
-    const prewarm_random = seededRandom(63);
-
-    // pre-warm code
-    for (let i = 0; i < 10; i++) {
-
-        const context = randomFromArray(prewarm_random, contexts);
-
-        cycle(context);
-    }
-
-    const t0 = performance.now();
-
-    for (let i = 0; i < CONTEXT_COUNT; i++) {
-        const context = contexts[i];
-
-        cycle(context);
-    }
-
-    const overall_time = (performance.now() - t0) / 1000;
-
-
-    const overall_time_ps = overall_time * 1e12;
-
-    console.log(`Time per expression: ${Math.round(overall_time_ps / (CONTEXT_COUNT * EXPRESSION_COUNT))}ps(picoseconds)`);
-});

package/src/core/model/reactive/js/compileReactiveToJS.spec.js

@@ -1,14 +0,0 @@
-import { compileReactiveToJS } from "./compileReactiveToJS.js";
-import { ReactiveLiteralBoolean } from "../model/terminal/ReactiveLiteralBoolean.js";
-import { ReactiveLiteralNumber } from "../model/terminal/ReactiveLiteralNumber.js";
-import { ReactiveLiteralString } from "../model/terminal/ReactiveLiteralString.js";
-
-test("literal expressions", () => {
-
-    expect(compileReactiveToJS(ReactiveLiteralBoolean.from(true))).toEqual("true");
-
-    expect(compileReactiveToJS(ReactiveLiteralNumber.from(13.1))).toEqual("13.1");
-
-    expect(compileReactiveToJS(ReactiveLiteralString.from("a"))).toEqual("'a'");
-
-});

package/src/core/model/reactive/model/logic/ReactiveAnd.spec.js

@@ -1,51 +0,0 @@
-import { ReactiveLiteralBoolean } from "../terminal/ReactiveLiteralBoolean.js";
-import { ReactiveAnd } from "./ReactiveAnd.js";
-
-test('copy method does not modify the sources', () => {
-
-    const b0 = ReactiveLiteralBoolean.from(false);
-    const b1 = ReactiveLiteralBoolean.from(true);
-
-    const a = new ReactiveAnd();
-
-
-    a.connect(b0, b1);
-
-    const b = new ReactiveAnd();
-
-    b.copy(a);
-
-    expect(b0.getValue()).toBe(false);
-    expect(b1.getValue()).toBe(true);
-
-});
-
-test("equals", () => {
-
-    const a = ReactiveAnd.from(ReactiveLiteralBoolean.from(true), ReactiveLiteralBoolean.from(true));
-    const b = ReactiveAnd.from(ReactiveLiteralBoolean.from(true), ReactiveLiteralBoolean.from(true));
-    const c = ReactiveAnd.from(ReactiveLiteralBoolean.from(true), ReactiveLiteralBoolean.from(false));
-    const d = ReactiveAnd.from(ReactiveLiteralBoolean.from(false), ReactiveLiteralBoolean.from(true));
-
-    expect(a.equals(b)).toBe(true);
-    expect(a.equals(c)).toBe(false);
-    expect(a.equals(d)).toBe(false);
-
-    expect(a.equals(ReactiveLiteralBoolean.from(true))).toBe(false);
-});
-
-test("evaluate", () => {
-    const a = ReactiveAnd.from(ReactiveLiteralBoolean.from(true), ReactiveLiteralBoolean.from(true));
-    const b = ReactiveAnd.from(ReactiveLiteralBoolean.from(true), ReactiveLiteralBoolean.from(false));
-
-    expect(a.evaluate({})).toBe(true);
-    expect(b.evaluate({})).toBe(false);
-});
-
-test("clone", () => {
-    const source = ReactiveAnd.from(ReactiveLiteralBoolean.from(true), ReactiveLiteralBoolean.from(false));
-
-    const clone = source.clone();
-
-    expect(clone.equals(source)).toBe(true);
-});

package/src/core/model/reactive/model/logic/ReactiveOr.spec.js

@@ -1,53 +0,0 @@
-import { ReactiveLiteralBoolean } from "../terminal/ReactiveLiteralBoolean.js";
-import { ReactiveOr } from "./ReactiveOr.js";
-
-test('copy method does not modify the sources', () => {
-
-    const b0 = ReactiveLiteralBoolean.from(false);
-    const b1 = ReactiveLiteralBoolean.from(true);
-
-    const a = new ReactiveOr();
-
-
-    a.connect(b0, b1);
-
-    const b = new ReactiveOr();
-
-    b.copy(a);
-
-    expect(b0.getValue()).toBe(false);
-    expect(b1.getValue()).toBe(true);
-
-});
-
-test("equals", () => {
-
-    const a = ReactiveOr.from(ReactiveLiteralBoolean.from(true), ReactiveLiteralBoolean.from(true));
-    const b = ReactiveOr.from(ReactiveLiteralBoolean.from(true), ReactiveLiteralBoolean.from(true));
-    const c = ReactiveOr.from(ReactiveLiteralBoolean.from(true), ReactiveLiteralBoolean.from(false));
-    const d = ReactiveOr.from(ReactiveLiteralBoolean.from(false), ReactiveLiteralBoolean.from(true));
-
-    expect(a.equals(b)).toBe(true);
-    expect(a.equals(c)).toBe(false);
-    expect(a.equals(d)).toBe(false);
-
-    expect(a.equals(ReactiveLiteralBoolean.from(true))).toBe(false);
-});
-
-test("evaluate", () => {
-    const a = ReactiveOr.from(ReactiveLiteralBoolean.from(true), ReactiveLiteralBoolean.from(true));
-    const b = ReactiveOr.from(ReactiveLiteralBoolean.from(true), ReactiveLiteralBoolean.from(false));
-    const c = ReactiveOr.from(ReactiveLiteralBoolean.from(false), ReactiveLiteralBoolean.from(false));
-
-    expect(a.evaluate({})).toBe(true);
-    expect(b.evaluate({})).toBe(true);
-    expect(c.evaluate({})).toBe(false);
-});
-
-test("clone", () => {
-    const source = ReactiveOr.from(ReactiveLiteralBoolean.from(true), ReactiveLiteralBoolean.from(false));
-
-    const clone = source.clone();
-
-    expect(clone.equals(source)).toBe(true);
-});

package/src/core/model/reactive/model/terminal/ReactiveReference.spec.js

@@ -1,26 +0,0 @@
-import { jest } from "@jest/globals";
-import ObservedBoolean from "../../../ObservedBoolean.js";
-import { ReactiveReference } from "./ReactiveReference.js";
-
-test('onChange dispatch', () => {
-    const ref = new ReactiveReference('x');
-
-    const b = new ObservedBoolean(false);
-
-    ref.connect(b);
-
-    const handler = jest.fn();
-
-    ref.onChanged.add(handler);
-
-    expect(handler).not.toHaveBeenCalled();
-
-    b.set(false);
-
-    expect(handler).not.toHaveBeenCalled();
-
-    b.set(true);
-
-    expect(handler).toHaveBeenCalledTimes(1);
-    expect(handler).toHaveBeenLastCalledWith(true, false);
-});

package/src/core/model/reactive/trigger/BlackboardTrigger.spec.js

@@ -1,24 +0,0 @@
-import { BlackboardTrigger } from "./BlackboardTrigger.js";
-import { Blackboard } from "../../../../engine/intelligence/blackboard/Blackboard.js";
-
-test("constructor does not throw", () => {
-    expect(() => new BlackboardTrigger()).not.toThrow();
-});
-
-test("numeric equality", () => {
-
-    const trigger = new BlackboardTrigger();
-    trigger.code = "a == 7";
-
-    const bb = Blackboard.fromJSON({
-        a: 7
-    });
-
-    trigger.link(bb);
-
-    expect(trigger.getExpression().getValue()).toBe(true);
-
-    bb.acquireNumber("a").set(1);
-
-    expect(trigger.getExpression().getValue()).toBe(false);
-});