@woosh/meep-engine 2.110.14 → 2.110.15

package/src/core/graph/graph_k_means_cluster.spec.js

@@ -1,23 +0,0 @@
-import { graph_k_means_cluster } from "./graph_k_means_cluster.js";
-import { Graph } from "./v2/Graph.js";
-
-test("empty graph", () => {
-    const graph = new Graph();
-
-    const clusters = graph_k_means_cluster(graph, 0, 0);
-
-    expect(Array.isArray(clusters)).toBe(true);
-    expect(clusters.length).toBe(0);
-});
-
-test("2-node graph with k=1", () => {
-    const graph = new Graph();
-    graph.addNode(3);
-    graph.addNode(7);
-
-    const clusters = graph_k_means_cluster(graph, 1, 0);
-
-    expect(Array.isArray(clusters)).toBe(true);
-    expect(clusters.length).toBe(1);
-    expect(clusters.map(cluster => cluster.sort())).toEqual([[0, 1]]);
-});

package/src/core/graph/mn_graph_coarsen.spec.js

@@ -1,45 +0,0 @@
-import { mn_graph_coarsen } from "./mn_graph_coarsen.js";
-import { MultiNode } from "./MultiNode.js";
-import { Graph } from "./v2/Graph.js";
-import { WeightedEdge } from "./WeightedEdge.js";
-
-test('coarsen 2 node graph with 1 edge', () => {
-    const graph = new Graph();
-
-    const n0 = MultiNode.fromOne(1);
-    const n1 = MultiNode.fromOne(2);
-    graph.addNode(n0);
-    graph.addNode(n1);
-
-    graph.addEdge(new WeightedEdge(n0, n1));
-
-    mn_graph_coarsen(graph, 2);
-
-    expect(graph.getNodeCount()).toBe(1);
-});
-
-test('coarsen chain, all nodes must still be linked', () => {
-    const g = new Graph();
-
-
-    const n = 100;
-    const nodes = [];
-
-    for (let i = 0; i < n; i++) {
-        const node = MultiNode.fromOne(i);
-        g.addNode(node);
-
-        nodes[i] = node;
-    }
-
-    for (let i = 0; i < n - 1; i++) {
-        const n0 = nodes[i];
-        const n1 = nodes[i + 1];
-
-        g.addEdge(new WeightedEdge(n0, n1));
-    }
-
-    mn_graph_coarsen(g, 100);
-
-    expect(g.getNodeCount()).toBe(1);
-});

package/src/core/graph/v2/Graph.spec.js

@@ -1,364 +0,0 @@
-import { Edge, EdgeDirectionType } from "../Edge.js";
-import { Graph } from "./Graph.js";
-import { jest } from "@jest/globals";
-
-test("constructor doesn't throw", () => {
-    expect(() => new Graph()).not.toThrow();
-});
-
-test("adding same node twice", () => {
-
-    const graph = new Graph();
-
-    expect(graph.addNode(1)).toBe(true);
-    expect(graph.addNode(1)).toBe(false); // node already added
-
-});
-
-test("adding node triggers nodeAdded signal", () => {
-
-    const graph = new Graph();
-
-    const callback = jest.fn();
-
-    graph.on.nodeAdded.add(callback);
-
-    graph.addNode(7);
-
-    expect(callback).toHaveBeenCalledTimes(1);
-    expect(callback).toHaveBeenCalledWith(7, graph);
-
-});
-
-test("removing node triggers nodeRemoved signal", () => {
-
-    const graph = new Graph();
-
-    const callback = jest.fn();
-
-    graph.on.nodeRemoved.add(callback);
-
-    graph.addNode(7);
-
-    expect(callback).not.toHaveBeenCalled();
-
-    graph.removeNode(1); // trying to remove non-existent node
-
-    expect(callback).not.toHaveBeenCalled();
-
-    graph.removeNode(7);
-
-    expect(callback).toHaveBeenCalledTimes(1);
-    expect(callback).toHaveBeenCalledWith(7, graph);
-
-    graph.removeNode(7); //node was already removed, so we expect nothing to happen
-
-    expect(callback).toHaveBeenCalledTimes(1);
-});
-
-test("check node existence", () => {
-
-    const graph = new Graph();
-
-    expect(graph.hasNode(1)).toBe(false);
-
-    graph.addNode(1);
-
-    expect(graph.hasNode(1)).toBe(true);
-
-});
-
-test("removing node that does not exist", () => {
-    const graph = new Graph();
-
-    expect(graph.removeNode(1)).toBe(false);
-
-});
-
-test("removing same node twice", () => {
-    const graph = new Graph();
-
-    graph.addNode(1);
-
-    expect(graph.removeNode(1)).toBe(true);
-    expect(graph.removeNode(1)).toBe(false);
-});
-
-test("nodeCount", () => {
-    const g = new Graph();
-
-    expect(g.nodeCount).toBe(0);
-
-    g.addNode(1);
-
-    expect(g.nodeCount).toBe(1);
-
-    g.removeNode(1);
-
-    expect(g.nodeCount).toBe(0);
-});
-
-test("findNode on empty graph", () => {
-    const graph = new Graph();
-
-    expect(graph.findNode(n => n === 1)).toBe(undefined);
-});
-
-test("findNode that doesn't exist on graph with 1 node", () => {
-    const graph = new Graph();
-
-    graph.addNode(3);
-
-    expect(graph.findNode(n => n === 1)).toBe(undefined);
-});
-
-test("findNode amongst two", () => {
-    const graph = new Graph();
-
-    graph.addNode(1);
-    graph.addNode(3);
-
-    expect(graph.findNode(n => n === 3)).toBe(3);
-});
-
-test("getNodeDegree", () => {
-
-    const graph = new Graph();
-
-    expect(graph.getNodeDegree(1)).toBe(0);
-
-    graph.addNode(1);
-
-    expect(graph.getNodeDegree(1)).toBe(0);
-
-    graph.addNode(3);
-
-    expect(graph.getNodeDegree(1)).toBe(0);
-    expect(graph.getNodeDegree(3)).toBe(0);
-
-    graph.createEdge(1, 3, EdgeDirectionType.Forward);
-
-    expect(graph.getNodeDegree(1)).toBe(1);
-    expect(graph.getNodeDegree(3)).toBe(1);
-});
-
-test("createEdge", () => {
-    const graph = new Graph();
-
-    graph.addNode(1);
-    graph.addNode(2);
-
-    graph.createEdge(1, 2, EdgeDirectionType.Forward);
-
-    expect(graph.edgeCount).toBe(1);
-
-    expect(graph.edgeExistsBetween(1, 2)).toBe(true);
-});
-
-test("adding edge where one of the nodes is not part of the graph should throw and exception", () => {
-    const graph = new Graph();
-
-    expect(() => graph.addEdge(new Edge(1, 2))).toThrow();
-
-    graph.addNode(1);
-
-    expect(() => graph.addEdge(new Edge(1, 2))).toThrow();
-
-    graph.removeNode(1);
-    graph.addNode(2);
-
-    expect(() => graph.addEdge(new Edge(1, 2))).toThrow();
-});
-
-test("add one valid edge", () => {
-
-    const graph = new Graph();
-
-    graph.addNode(1);
-    graph.addNode(2);
-
-    const edge = new Edge(1, 2);
-    expect(graph.addEdge(edge)).toBe(true);
-
-    expect(graph.hasEdge(edge)).toBe(true);
-
-    expect(graph.edgeCount).toBe(1);
-});
-
-test("add same edge twice", () => {
-
-    const graph = new Graph();
-
-    graph.addNode(1);
-    graph.addNode(2);
-
-    const edge = new Edge(1, 2);
-
-    expect(graph.addEdge(edge)).toBe(true);
-    expect(graph.addEdge(edge)).toBe(false); //already exists
-
-    expect(graph.hasEdge(edge)).toBe(true);
-
-    expect(graph.edgeCount).toBe(1);
-});
-
-test("remove non-existing edge", () => {
-
-    const graph = new Graph();
-
-    graph.addNode(1);
-    graph.addNode(2);
-
-    const edge = new Edge(1, 2);
-
-    expect(graph.removeEdge(edge)).toBe(false);
-});
-
-test("edgeCount", () => {
-    const g = new Graph();
-
-    expect(g.edgeCount).toBe(0);
-
-    g.addNode(1);
-    g.addNode(2);
-
-    const edge = new Edge(1, 2);
-    g.addEdge(edge);
-
-    expect(g.edgeCount).toBe(1);
-
-    g.removeEdge(edge);
-
-    expect(g.edgeCount).toBe(0);
-});
-
-test("after removing an edge, neighborhood is properly updated", () => {
-
-    const g = new Graph();
-
-    g.addNode(1);
-    g.addNode(2);
-
-    const edge = new Edge(1, 2);
-    g.addEdge(edge);
-
-    g.removeEdge(edge);
-
-    const t = [];
-
-    expect(g.getAttachedEdges(t, 1)).toBe(0);
-    expect(g.getAttachedEdges(t, 2)).toBe(0);
-});
-
-test("edgeExistsBetween", () => {
-    const graph = new Graph();
-
-    expect(graph.edgeExistsBetween(1, 2)).toBe(false);
-    expect(graph.edgeExistsBetween(2, 1)).toBe(false);
-
-    graph.addNode(1);
-
-    expect(graph.edgeExistsBetween(1, 2)).toBe(false);
-    expect(graph.edgeExistsBetween(2, 1)).toBe(false);
-
-    graph.addNode(2);
-
-    expect(graph.edgeExistsBetween(1, 2)).toBe(false);
-    expect(graph.edgeExistsBetween(2, 1)).toBe(false);
-
-    graph.createEdge(1, 2, EdgeDirectionType.Forward);
-
-    expect(graph.edgeExistsBetween(1, 2)).toBe(true);
-    expect(graph.edgeExistsBetween(2, 1)).toBe(true);
-
-});
-
-test("nodeHasEdges", () => {
-    const graph = new Graph();
-
-    expect(graph.nodeHasEdges(1)).toBe(false);
-
-    graph.addNode(1);
-
-    expect(graph.nodeHasEdges(1)).toBe(false);
-
-    graph.addNode(2);
-
-    expect(graph.nodeHasEdges(1)).toBe(false);
-
-    graph.createEdge(1, 2, EdgeDirectionType.Forward);
-
-    expect(graph.nodeHasEdges(1)).toBe(true);
-    expect(graph.nodeHasEdges(2)).toBe(true);
-});
-
-test("getAnyEdgeBetween", () => {
-
-    const graph = new Graph();
-
-    expect(graph.getAnyEdgeBetween(1, 2)).toBe(undefined);
-    expect(graph.getAnyEdgeBetween(2, 1)).toBe(undefined);
-
-    graph.addNode(1);
-
-    expect(graph.getAnyEdgeBetween(1, 2)).toBe(undefined);
-    expect(graph.getAnyEdgeBetween(2, 1)).toBe(undefined);
-
-    graph.addNode(2);
-
-    expect(graph.getAnyEdgeBetween(1, 2)).toBe(undefined);
-    expect(graph.getAnyEdgeBetween(2, 1)).toBe(undefined);
-
-    const edge = graph.createEdge(1, 2, EdgeDirectionType.Forward);
-
-    expect(graph.getAnyEdgeBetween(1, 2)).toBe(edge);
-    expect(graph.getAnyEdgeBetween(2, 1)).toBe(edge);
-});
-
-test("find path from node to itself", () => {
-    const graph = new Graph();
-
-    graph.addNode(1);
-
-    const path = graph.findPath(1, 1);
-
-    expect(path).toEqual([1]);
-});
-
-test("find path with 2 hops", () => {
-    const graph = new Graph();
-
-    graph.addNode(1);
-    graph.addNode(2);
-    graph.addNode(3);
-
-    graph.createEdge(1, 2, EdgeDirectionType.Forward);
-    graph.createEdge(2, 3, EdgeDirectionType.Forward);
-
-    const path = graph.findPath(1, 3);
-
-    expect(path).toEqual([1, 2, 3]);
-});
-
-test("clear method removes all nodes", () => {
-    const graph = new Graph();
-
-    graph.addNode(1);
-
-    graph.clear();
-
-    expect(graph.nodeCount).toBe(0);
-});
-
-test("clear method removes all edges", () => {
-    const graph = new Graph();
-
-    graph.addNode(1);
-    graph.addNode(2);
-
-    graph.createEdge(1, 2, EdgeDirectionType.Forward);
-
-    graph.clear();
-
-    expect(graph.edgeCount).toBe(0);
-});

package/src/core/json/resolvePath.spec.js

@@ -1,14 +0,0 @@
-import { resolvePath } from "./resolvePath.js";
-
-test("resolve global path", () => {
-    const root = {};
-    expect(resolvePath(root, '')).toBe(root);
-});
-
-test("resolve nested path", () => {
-    const nested_child = {};
-
-    const root = { a: { b: nested_child } };
-
-    expect(resolvePath(root, '/a/b')).toBe(nested_child);
-});

package/src/core/lang/reactive/compileReactiveExpression.spec.js

@@ -1,169 +0,0 @@
-import { ReactiveAdd } from "../../model/reactive/model/arithmetic/ReactiveAdd.js";
-import { ReactiveDivide } from "../../model/reactive/model/arithmetic/ReactiveDivide.js";
-import { ReactiveMultiply } from "../../model/reactive/model/arithmetic/ReactiveMultiply.js";
-import { ReactiveNegate } from "../../model/reactive/model/arithmetic/ReactiveNegate.js";
-import { ReactiveSubtract } from "../../model/reactive/model/arithmetic/ReactiveSubtract.js";
-import { ReactiveEquals } from "../../model/reactive/model/comparative/ReactiveEquals.js";
-import { ReactiveGreaterThan } from "../../model/reactive/model/comparative/ReactiveGreaterThan.js";
-import { ReactiveGreaterThanOrEqual } from "../../model/reactive/model/comparative/ReactiveGreaterThanOrEqual.js";
-import { ReactiveLessThan } from "../../model/reactive/model/comparative/ReactiveLessThan.js";
-import { ReactiveLessThanOrEqual } from "../../model/reactive/model/comparative/ReactiveLessThanOrEqual.js";
-import { ReactiveNotEquals } from "../../model/reactive/model/comparative/ReactiveNotEquals.js";
-import { ReactiveAnd } from "../../model/reactive/model/logic/ReactiveAnd.js";
-import { ReactiveNot } from "../../model/reactive/model/logic/ReactiveNot.js";
-import { ReactiveOr } from "../../model/reactive/model/logic/ReactiveOr.js";
-import { ReactiveLiteralNumber } from "../../model/reactive/model/terminal/ReactiveLiteralNumber.js";
-import { ReactiveReference } from "../../model/reactive/model/terminal/ReactiveReference.js";
-import { compileReactiveExpression } from "./compileReactiveExpression.js";
-
-test('compile: REFERENCE', () => {
-    const expression = compileReactiveExpression('a');
-
-    expect(expression instanceof ReactiveReference).toBe(true);
-    expect(expression.name).toBe('a');
-});
-
-test('compile: LITERAL_NUBMER', () => {
-    const expression = compileReactiveExpression("42");
-
-    expect(expression instanceof ReactiveLiteralNumber).toBe(true);
-    expect(expression.getValue()).toBe(42);
-});
-
-test('compile: MINUS REFERENCE', () => {
-    const expression = compileReactiveExpression("-x");
-
-    expect(expression instanceof ReactiveNegate).toBe(true);
-    expect(expression.source instanceof ReactiveReference).toBe(true);
-});
-
-test('compile: REFERENCE MINUS MINUS REFERENCE', () => {
-    const expression = compileReactiveExpression('x - - x');
-
-    expect(expression instanceof ReactiveSubtract).toBe(true);
-    expect(expression.left instanceof ReactiveReference).toBe(true);
-    expect(expression.right instanceof ReactiveNegate).toBe(true);
-    expect(expression.right.source instanceof ReactiveReference).toBe(true);
-});
-
-test('compile: NOT REFERENCE', () => {
-    const expression = compileReactiveExpression('!x');
-
-    expect(expression instanceof ReactiveNot).toBe(true);
-    expect(expression.source instanceof ReactiveReference).toBe(true);
-});
-
-test('compile: NOT NOT REFERENCE', () => {
-    const expression = compileReactiveExpression('!!x');
-
-    expect(expression instanceof ReactiveNot).toBe(true);
-    expect(expression.source instanceof ReactiveNot).toBe(true);
-    expect(expression.source.source instanceof ReactiveReference).toBe(true);
-});
-
-test('compile: REFERENCE > REFERENCE', () => {
-    const expression = compileReactiveExpression('x > y');
-
-    expect(expression instanceof ReactiveGreaterThan).toBe(true);
-    expect(expression.left instanceof ReactiveReference).toBe(true);
-    expect(expression.left.name).toBe('x');
-    expect(expression.right.name).toBe('y');
-});
-
-test('compile: ( REFERENCE )', () => {
-    const expression = compileReactiveExpression('(x)');
-
-    expect(expression instanceof ReactiveReference).toBe(true);
-});
-
-test('compile: REFERENCE > ( REFERENCE + REFERENCE )', () => {
-    const expression = compileReactiveExpression('x > ( y + z )');
-
-    expect(expression instanceof ReactiveGreaterThan).toBe(true);
-    expect(expression.left instanceof ReactiveReference).toBe(true);
-    expect(expression.right instanceof ReactiveAdd).toBe(true);
-});
-
-test('compile: a || b', () => {
-    const expression = compileReactiveExpression('a || b');
-
-    expect(expression instanceof ReactiveOr).toBe(true);
-});
-
-test('compile: a && b', () => {
-    const expression = compileReactiveExpression('a && b');
-
-    expect(expression instanceof ReactiveAnd).toBe(true);
-});
-
-test('compile: a > b', () => {
-    const expression = compileReactiveExpression('a > b');
-
-    expect(expression instanceof ReactiveGreaterThan).toBe(true);
-});
-
-test('compile: a >= b', () => {
-    const expression = compileReactiveExpression('a >= b');
-
-    expect(expression instanceof ReactiveGreaterThanOrEqual).toBe(true);
-});
-
-test('compile: a < b', () => {
-    const expression = compileReactiveExpression('a < b');
-
-    expect(expression instanceof ReactiveLessThan).toBe(true);
-});
-
-test('compile: a <= b', () => {
-    const expression = compileReactiveExpression('a <= b');
-
-    expect(expression instanceof ReactiveLessThanOrEqual).toBe(true);
-});
-
-test('compile: a == b', () => {
-    const expression = compileReactiveExpression('a == b');
-
-    expect(expression instanceof ReactiveEquals).toBe(true);
-});
-
-test('compile: a != b', () => {
-    const expression = compileReactiveExpression('a != b');
-
-    expect(expression instanceof ReactiveNotEquals).toBe(true);
-});
-
-test('compile: a + b', () => {
-    const expression = compileReactiveExpression('a + b');
-
-    expect(expression instanceof ReactiveAdd).toBe(true);
-});
-
-test('compile: a - b', () => {
-    const expression = compileReactiveExpression('a - b');
-
-    expect(expression instanceof ReactiveSubtract).toBe(true);
-});
-
-test('compile: a * b', () => {
-    const expression = compileReactiveExpression('a * b');
-
-    expect(expression instanceof ReactiveMultiply).toBe(true);
-});
-
-test('compile: a / b', () => {
-    const expression = compileReactiveExpression('a / b');
-
-    expect(expression instanceof ReactiveDivide).toBe(true);
-});
-
-test('compile: !a', () => {
-    const expression = compileReactiveExpression('!a');
-
-    expect(expression instanceof ReactiveNot).toBe(true);
-});
-
-test('compile: -a', () => {
-    const expression = compileReactiveExpression('-a');
-
-    expect(expression instanceof ReactiveNegate).toBe(true);
-});

package/src/core/math/bessel_j0.spec.js

@@ -1,43 +0,0 @@
-import { bessel_j0 } from "./bessel_j0.js";
-
-test("sanity", () => {
-    const v = bessel_j0(0);
-
-    expect(typeof v).toBe("number");
-    expect(v).not.toBeNaN();
-
-});
-
-test("sweep through low positive values", () => {
-    // https://www.wolframalpha.com/input?i=besselj%5B0%2Cx%5D
-
-    expect(bessel_j0(0)).toBeCloseTo(1, 1);
-    expect(bessel_j0(0.1)).toBeCloseTo(0.997, 1);
-    expect(bessel_j0(0.2)).toBeCloseTo(0.990, 1);
-    expect(bessel_j0(0.3)).toBeCloseTo(0.977, 1);
-    expect(bessel_j0(0.4)).toBeCloseTo(0.960, 1);
-    expect(bessel_j0(0.5)).toBeCloseTo(0.938, 1);
-    expect(bessel_j0(0.6)).toBeCloseTo(0.912, 1);
-    expect(bessel_j0(0.7)).toBeCloseTo(0.881, 1);
-    expect(bessel_j0(0.8)).toBeCloseTo(0.846, 1);
-    expect(bessel_j0(0.9)).toBeCloseTo(0.807, 1);
-    expect(bessel_j0(1)).toBeCloseTo(0.765, 1);
-    expect(bessel_j0(2)).toBeCloseTo(0.223, 1);
-
-});
-
-test("roots", () => {
-
-    expect(bessel_j0(2.40482555769577)).toBeCloseTo(0, 1);
-    expect(bessel_j0(-2.40482555769577)).toBeCloseTo(0, 1);
-
-    expect(bessel_j0(5.52007811028631)).toBeCloseTo(0, 1);
-    expect(bessel_j0(-5.52007811028631)).toBeCloseTo(0, 1);
-
-    expect(bessel_j0(8.65372791291101)).toBeCloseTo(0, 1);
-    expect(bessel_j0(-8.65372791291101)).toBeCloseTo(0, 1);
-
-    expect(bessel_j0(11.7915344390143)).toBeCloseTo(0, 1);
-    expect(bessel_j0(-11.7915344390143)).toBeCloseTo(0, 1);
-
-});

package/src/core/math/clamp.spec.js

@@ -1,15 +0,0 @@
-import { clamp } from "./clamp.js";
-
-test('clamp', () => {
-    expect(clamp(0, 0, 0)).toBe(0);
-
-    expect(clamp(0, 1, 1)).toBe(1);
-
-    expect(clamp(0, -1, -1)).toBe(-1);
-
-    expect(clamp(3, 1, 2)).toBe(2);
-
-    expect(clamp(0, 1, 2)).toBe(1);
-
-    expect(clamp(2, 1, 3)).toBe(2);
-});

package/src/core/math/computeGreatestCommonDivisor.spec.js

@@ -1,9 +0,0 @@
-import { computeGreatestCommonDivisor } from "./computeGreatestCommonDivisor.js";
-
-test("1 and 1", () => {
-    expect(computeGreatestCommonDivisor(1, 1)).toBe(1);
-});
-
-test("6 and 9", () => {
-    expect(computeGreatestCommonDivisor(6, 9)).toBe(3);
-});

package/src/core/math/computeIsoscelesTriangleApexAngle.spec.js

@@ -1,6 +0,0 @@
-import { computeIsoscelesTriangleApexAngle } from "./computeIsoscelesTriangleApexAngle.js";
-
-test("sanity", () => {
-    // right-angle triangle
-    expect(computeIsoscelesTriangleApexAngle(1, Math.SQRT2)).toBeCloseTo(Math.PI / 2);
-});

package/src/core/math/computeWholeDivisorLow.spec.js

@@ -1,9 +0,0 @@
-import { computeWholeDivisorLow } from "./computeWholeDivisorLow.js";
-
-test('computeWholeDivisorLow 1/1', () => {
-    expect(computeWholeDivisorLow(1, 1)).toEqual(1);
-});
-
-test('computeWholeDivisorLow 16/5', () => {
-    expect(computeWholeDivisorLow(16, 5)).toEqual(4);
-});