@woosh/meep-engine 2.110.13 → 2.110.15

package/src/core/model/ObservedBoolean.spec.js

@@ -1,81 +0,0 @@
-import { jest } from "@jest/globals";
-import ObservedBoolean from "./ObservedBoolean.js";
-
-test("invert", () => {
-    const b = new ObservedBoolean(false);
-
-    b.invert();
-
-    expect(b.getValue()).toEqual(true);
-
-    b.invert();
-
-    expect(b.getValue()).toEqual(false);
-});
-
-test("set works correctly", () => {
-    const b = new ObservedBoolean(false);
-
-    b.set(true);
-
-    expect(b.getValue()).toBe(true);
-
-    b.set(false);
-
-    expect(b.getValue()).toBe(false);
-});
-
-test("onChanged triggered correctly", () => {
-    const b = new ObservedBoolean(false);
-
-    const fn = jest.fn();
-
-    b.onChanged.add(fn);
-
-    //should not trigger change
-    b.set(false);
-
-    expect(fn).not.toBeCalled();
-
-    b.set(true);
-
-    expect(fn).toHaveBeenCalledTimes(1);
-
-    b.set(true);
-
-    expect(fn).toHaveBeenCalledTimes(1);
-
-    b.set(false);
-
-    expect(fn).toHaveBeenCalledTimes(2);
-});
-
-test("to/from JSON serialization consistency", () => {
-    const t = new ObservedBoolean(true);
-    const f = new ObservedBoolean(false);
-
-    const temp = new ObservedBoolean(false);
-
-    temp.fromJSON(t.toJSON());
-
-    expect(temp.equals(t)).toBe(true);
-
-    temp.fromJSON(f.toJSON());
-
-    expect(temp.equals(f)).toBe(true);
-});
-
-test("equals", () => {
-    const aT = new ObservedBoolean(true);
-    const aF = new ObservedBoolean(false);
-
-    const bT = new ObservedBoolean(true);
-    const bF = new ObservedBoolean(false);
-
-    expect(aT.equals(aT)).toBe(true);
-    expect(aT.equals(aF)).toBe(false);
-    expect(aT.equals(bT)).toBe(true);
-
-    expect(aF.equals(aT)).toBe(false);
-    expect(aF.equals(bF)).toBe(true);
-});

package/src/core/model/ObservedInteger.spec.js

@@ -1,51 +0,0 @@
-import { BinaryBuffer } from "../binary/BinaryBuffer.js";
-import ObservedInteger from "./ObservedInteger.js";
-
-test('BinaryBuffer serialization consistency', () => {
-    function tryValue(value) {
-        const buffer = new BinaryBuffer();
-
-        const expected = new ObservedInteger(value);
-
-        const actual = new ObservedInteger(value + 1);
-
-        expected.toBinaryBuffer(buffer);
-
-        buffer.position = 0;
-
-        actual.fromBinaryBuffer(buffer);
-
-        expect(actual.getValue()).toBe(expected.getValue());
-    }
-
-    tryValue(0);
-    tryValue(1);
-    tryValue(-1);
-
-    tryValue(Infinity);
-    tryValue(-Infinity);
-});
-
-test("increment should work correctly", () => {
-    const i = new ObservedInteger(0);
-
-    i.increment();
-
-    expect(i.getValue()).toBe(1);
-
-    i.increment();
-
-    expect(i.getValue()).toBe(2);
-});
-
-test("decrement works", ()=> {
-    const i = new ObservedInteger(1);
-
-    i.decrement();
-
-    expect(i.getValue()).toBe(0);
-
-    i.decrement();
-
-    expect(i.getValue()).toBe(-1);
-});

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

@@ -1,33 +0,0 @@
-import { Connection } from "./Connection.js";
-
-test("stable hash", () => {
-    const a = new Connection();
-    const b = new Connection();
-
-    expect(a.hash()).toEqual(b.hash());
-});
-
-test("equality of fresh instances", () => {
-    const a = new Connection();
-    const b = new Connection();
-
-    expect(a.equals(b)).toBe(true);
-});
-
-test("equality on self", () => {
-    const thing = new Connection();
-
-    expect(thing.equals(thing)).toBe(true);
-});
-
-test("isAttachedToNode", () => {
-    const connection = new Connection();
-
-    expect(connection.isAttachedToNode(0)).toBe(false);
-});
-
-test("toString", () => {
-    const ut = new Connection();
-
-    expect(typeof ut.toString()).toBe("string");
-});

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

@@ -1,107 +0,0 @@
-import { NodeDescription } from "./node/NodeDescription.js";
-import { PortDirection } from "./node/PortDirection.js";
-import { NodeGraph } from "./NodeGraph.js";
-import { DataType } from "./type/DataType.js";
-
-test("constructor doesn't throw", () => {
-    new NodeGraph();
-});
-
-test("createNode returns a number", () => {
-    const node = new NodeDescription();
-
-    const g = new NodeGraph();
-
-    expect(typeof g.createNode(node)).toBe('number');
-});
-
-test("createConnection returns a number", () => {
-    const node = new NodeDescription();
-
-    const dt = new DataType();
-
-    const pInt = node.createPort(dt, "in", PortDirection.In);
-    const pOut = node.createPort(dt, "out", PortDirection.Out);
-
-
-    const g = new NodeGraph();
-
-    const i0 = g.createNode(node);
-    const i1 = g.createNode(node);
-
-    expect(typeof g.createConnection(i0, pOut, i1, pInt)).toBe('number');
-});
-
-test("createConnection populates NodeInstance.connections", () => {
-    const node = new NodeDescription();
-
-    const dt = new DataType();
-
-    const pInt = node.createPort(dt, "in", PortDirection.In);
-    const pOut = node.createPort(dt, "out", PortDirection.Out);
-
-    const g = new NodeGraph();
-
-    const i0 = g.createNode(node);
-    const i1 = g.createNode(node);
-
-    g.createConnection(i0, pOut, i1, pInt);
-
-    expect(g.getNode(i0).connections.length).toBe(1);
-    expect(g.getNode(i1).connections.length).toBe(1);
-});
-
-test("getConnection", () => {
-
-    const g = new NodeGraph();
-
-    const node = new NodeDescription();
-
-    const dt = new DataType();
-
-    const pInt = node.createPort(dt, "in", PortDirection.In);
-    const pOut = node.createPort(dt, "out", PortDirection.Out);
-
-    const i0 = g.createNode(node);
-    const i1 = g.createNode(node);
-
-    const connectionId = g.createConnection(i0, pOut, i1, pInt);
-
-    const connection = g.getConnection(connectionId);
-
-    expect(connection).toBeDefined();
-    expect(connection.id).toBe(connectionId);
-
-});
-
-test('getNode produces correct result', () => {
-    const graph = new NodeGraph();
-
-    //
-    expect(graph.getNode(0)).toBe(undefined);
-
-    const d = new NodeDescription();
-
-    const node_id = graph.createNode(d);
-
-    const node_instance = graph.getNode(node_id);
-
-    expect(node_instance).toBeDefined();
-    expect(node_instance.id).toBe(node_id);
-});
-
-
-test('.copy method with 1 node', () => {
-    const g0 = new NodeGraph();
-
-    const nodeDescription = new NodeDescription();
-
-    g0.createNode(nodeDescription);
-
-    const g1 = new NodeGraph();
-
-    g1.copy(g0);
-
-    expect(g1.nodes.length).toBe(1);
-    expect(g1.getNodesByDescription(nodeDescription).length).toBe(1);
-});

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

@@ -1,81 +0,0 @@
-import { DataType } from "../type/DataType.js";
-import { NodeDescription } from "./NodeDescription.js";
-import { PortDirection } from "./PortDirection.js";
-
-const DUMMY_TYPE = DataType.from(0, 'dummy');
-
-test('ports are assigned unique IDs', () => {
-    const node = new NodeDescription();
-
-    const id_a = node.createPort(DUMMY_TYPE, 'a', PortDirection.Unspecified);
-    const id_b = node.createPort(DUMMY_TYPE, 'b', PortDirection.Unspecified);
-
-    expect(id_a).not.toEqual(id_b);
-});
-
-test("get port by ID", () => {
-    const node = new NodeDescription();
-
-    expect(node.getPortById(1)).toBeNull();
-
-    const id = node.createPort(DUMMY_TYPE, "a", PortDirection.In);
-
-    const port = node.getPortById(id);
-
-    expect(port).not.toBeNull();
-    expect(port.name).toBe("a");
-});
-
-test("get ports by name", () => {
-
-    const node = new NodeDescription();
-
-    expect(node.getPortsByName("a")).toEqual([]);
-
-    node.createPort(DUMMY_TYPE, "a", PortDirection.In);
-
-    const result_0 = node.getPortsByName("a");
-    expect(result_0.length).toBe(1);
-    expect(result_0[0].name).toBe("a");
-
-    node.createPort(DUMMY_TYPE, "b", PortDirection.In);
-
-    const result_1 = node.getPortsByName("a");
-    expect(result_1.length).toBe(1);
-    expect(result_1[0].name).toBe("a");
-});
-
-test("delete port", () => {
-    const node = new NodeDescription();
-
-    expect(node.deletePort(1)).toBe(false);
-
-    const id = node.createPort(DUMMY_TYPE, "a", PortDirection.In);
-
-    expect(node.deletePort(id)).toBe(true);
-
-    expect(node.getPorts()).toEqual([]);
-});
-
-test("id uniqueness is preserved when ports are added and deleted out of order", () => {
-
-    const node = new NodeDescription();
-
-    const a = node.createPort(DUMMY_TYPE, "a", PortDirection.In);
-    const b = node.createPort(DUMMY_TYPE, "b", PortDirection.In);
-    const c = node.createPort(DUMMY_TYPE, "c", PortDirection.In);
-
-    node.deletePort(b);
-
-    const d = node.createPort(DUMMY_TYPE, "d", PortDirection.In);
-
-    expect(d).toEqual(b);
-
-});
-
-test("toString", () => {
-    const node = new NodeDescription();
-
-    expect(typeof node.toString()).toBe("string");
-    expect(node.toString().length).toBeGreaterThan(0);
-});

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

@@ -1,82 +0,0 @@
-import { jest } from "@jest/globals";
-import { NodeGraph } from "../NodeGraph.js";
-import { DataType } from "../type/DataType.js";
-import { NodeDescription } from "./NodeDescription.js";
-import { NodeInstance } from "./NodeInstance.js";
-import { PortDirection } from "./PortDirection.js";
-
-
-test("getConnectionsByPort", () => {
-    const type = DataType.from(7, "x");
-
-    const graph = new NodeGraph();
-
-    const description = new NodeDescription();
-
-    const p_in = description.createPort(type, "in", PortDirection.In);
-    const p_out = description.createPort(type, "out", PortDirection.Out);
-
-    const n_0 = graph.createNode(description);
-    const n_1 = graph.createNode(description);
-
-    const c_id = graph.createConnection(n_0, p_out, n_1, p_in);
-
-    /**
-     *
-     * @type {Connection[]}
-     */
-    const connections = [];
-
-    const result_count = graph.getNode(n_0).getConnectionsByPort(p_out, PortDirection.Out, connections);
-
-    expect(result_count).toEqual(result_count);
-    expect(connections).toEqual([
-        graph.getConnection(c_id)
-    ]);
-});
-
-test("setParameterValue", () => {
-
-    const instance = new NodeInstance();
-
-    const cb_added = jest.fn();
-    const cb_changed = jest.fn();
-
-    instance.on.parameterAdded.add(cb_added);
-    instance.on.parameterChanged.add(cb_changed);
-
-    instance.setParameterValue("x", 42);
-
-    expect(instance.hasParameter("x")).toBe(true);
-
-    expect(instance.getParameterValue("x")).toEqual(42);
-
-    expect(cb_added).toHaveBeenCalledTimes(1);
-    expect(cb_added).toHaveBeenLastCalledWith("x", 42);
-
-    expect(cb_changed).toHaveBeenCalledTimes(1);
-    expect(cb_changed).toHaveBeenLastCalledWith("x", 42, undefined);
-});
-
-test("deleteParameter", () => {
-
-    const instance = new NodeInstance();
-
-    const cb_deleted = jest.fn();
-
-    instance.on.parameterRemoved.add(cb_deleted);
-
-    expect(instance.deleteParameter("x")).toEqual(false);
-
-    expect(cb_deleted).not.toHaveBeenCalled();
-
-    instance.setParameterValue("x", 42);
-
-    expect(instance.deleteParameter("x")).toEqual(true);
-
-    expect(cb_deleted).toHaveBeenCalledTimes(1);
-    expect(cb_deleted).toHaveBeenLastCalledWith("x", 42);
-
-    expect(instance.hasParameter("x")).toBe(false);
-
-});

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

@@ -1,109 +0,0 @@
-import { NodeGraph } from "../NodeGraph.js";
-import { DataType } from "../type/DataType.js";
-import { NodeDescription } from "./NodeDescription.js";
-import { NodeInstancePortReference } from "./NodeInstancePortReference.js";
-import { PortDirection } from "./PortDirection.js";
-
-const DUMMY_TYPE = DataType.from(0, 'dummy');
-test("constructor does not throw", () => {
-    new NodeInstancePortReference()
-});
-
-test("outgoing connections", () => {
-    const nd = new NodeDescription();
-    const port_a_id = nd.createPort(DUMMY_TYPE, "a", PortDirection.Out);
-    const port_b_id = nd.createPort(DUMMY_TYPE, "b", PortDirection.In);
-
-
-    const graph = new NodeGraph();
-    const node_instance_id = graph.createNode(nd);
-
-    const port_a_ref = graph.getConnectionEndpoint(node_instance_id, port_a_id);
-
-    expect(port_a_ref.outConnections).toEqual([]);
-
-    const connection_id = graph.createConnection(node_instance_id, port_a_id, node_instance_id, port_b_id);
-
-    const connection = graph.getConnection(connection_id);
-
-    expect(port_a_ref.outConnections).toEqual([connection]);
-});
-
-test("incoming connections", () => {
-    const nd = new NodeDescription();
-    const port_a_id = nd.createPort(DUMMY_TYPE, "a", PortDirection.Out);
-    const port_b_id = nd.createPort(DUMMY_TYPE, "b", PortDirection.In);
-
-
-    const graph = new NodeGraph();
-    const node_instance_id = graph.createNode(nd);
-
-    const port_b_ref = graph.getConnectionEndpoint(node_instance_id, port_b_id);
-
-    expect(port_b_ref.inConnections).toEqual([]);
-
-    const connection_id = graph.createConnection(node_instance_id, port_a_id, node_instance_id, port_b_id);
-
-    const connection = graph.getConnection(connection_id);
-
-    expect(port_b_ref.inConnections).toEqual([connection]);
-});
-
-test("isConnectedToNode", () => {
-    const nd = new NodeDescription();
-
-    const port_in_id = nd.createPort(DUMMY_TYPE, "in", PortDirection.In);
-    const port_out_id = nd.createPort(DUMMY_TYPE, "out", PortDirection.Out);
-
-    const graph = new NodeGraph();
-    const node_a_id = graph.createNode(nd);
-    const node_b_id = graph.createNode(nd);
-
-    const endpoint_a_out = graph.getNode(node_a_id).getEndpoint(port_out_id);
-
-    expect(endpoint_a_out.isConnectedToNode(node_a_id)).toBe(true);
-    expect(endpoint_a_out.isConnectedToNode(node_b_id)).toBe(false);
-
-    graph.createConnection(node_a_id, port_out_id, node_b_id, port_in_id);
-
-    expect(endpoint_a_out.isConnectedToNode(node_b_id)).toBe(true);
-
-});
-
-/**
- *
- * @returns {NodeInstancePortReference}
- */
-function sample_a() {
-    const nd = new NodeDescription();
-    const port_a_id = nd.createPort(DUMMY_TYPE, "a", PortDirection.Out);
-
-
-    const graph = new NodeGraph();
-    const node_instance_id = graph.createNode(nd);
-
-    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/NodeRegistry.spec.js

@@ -1,123 +0,0 @@
-import { DataType } from "../type/DataType.js";
-import { NodeDescription } from "./NodeDescription.js";
-import { NodeRegistry } from "./NodeRegistry.js";
-import { Port } from "./Port.js";
-import { PortDirection } from "./PortDirection.js";
-
-test("serialize/deserialize 1 node with 1 port", () => {
-    const t0 = new DataType();
-    t0.id = 42;
-    t0.name = "kitty";
-
-    const n0 = new NodeDescription();
-    n0.id = 7;
-    n0.name = "Yarr";
-
-    const p0 = new Port();
-    p0.id = 13;
-    p0.name = "fluffy";
-    p0.dataType = t0;
-    p0.direction = PortDirection.In;
-
-    n0.getPorts().push(p0);
-
-    const lA = new NodeRegistry();
-
-    lA.addNode(n0);
-
-    const json = lA.toJSON();
-
-    const lB = new NodeRegistry();
-
-    lB.fromJSON(json);
-
-    expect(lB.nodes.size).toBe(1);
-    expect(lB.types.size).toBe(1);
-
-    const n1 = lB.getNode(7);
-
-    expect(n1.id).toBe(7);
-    expect(n1.name).toBe("Yarr");
-
-    const ports1 = n1.getPorts();
-
-    expect(ports1.length).toBe(1);
-
-    const port = ports1[0];
-    expect(port.id).toBe(13);
-    expect(port.name).toBe("fluffy");
-    expect(port.direction).toBe(PortDirection.In);
-    expect(port.dataType.name).toBe("kitty");
-    expect(port.dataType.id).toBe(42);
-});
-
-test("port types are added automatically when node is added", () => {
-    const registry = new NodeRegistry();
-
-    const type = DataType.from(0, 'a');
-
-    const node = new NodeDescription();
-    node.createPort(type, "port name", PortDirection.In);
-
-    registry.addNode(node);
-
-    expect(registry.hasType(type));
-});
-
-test("hasType", () => {
-    const registry = new NodeRegistry();
-
-    const type = DataType.from(0, 'a');
-
-    expect(registry.hasType(type)).toBe(false);
-
-    registry.addType(type);
-
-    expect(registry.hasType(type)).toBe(true);
-});
-
-test("inPorts works as intended", () => {
-    const node = new NodeDescription();
-
-    const type = DataType.from(0, 'a');
-
-    expect(node.inPorts.length).toBe(0);
-
-    node.createPort(type, 'a', PortDirection.Out);
-
-    expect(node.inPorts.length).toBe(0);
-
-    node.createPort(type, 'a', PortDirection.In);
-
-    expect(node.inPorts.length).toBe(1);
-
-});
-
-test("outPorts works as intended", () => {
-    const node = new NodeDescription();
-
-    const type = DataType.from(0, 'a');
-
-    expect(node.outPorts.length).toBe(0);
-
-    node.createPort(type, 'a', PortDirection.In);
-
-    expect(node.outPorts.length).toBe(0);
-
-    node.createPort(type, 'a', PortDirection.Out);
-
-    expect(node.outPorts.length).toBe(1);
-
-});
-
-test("createPort assigns unique IDs for ports", () => {
-
-    const node = new NodeDescription();
-
-    const type = DataType.from(0, 'a');
-
-    const a = node.createPort(type, 'a', PortDirection.In);
-    const b = node.createPort(type, 'a', PortDirection.In);
-
-    expect(a).not.toEqual(b);
-});