@woosh/meep-engine 2.51.0 → 2.53.0

package/src/core/geom/Vector2.js

@@ -450,7 +450,10 @@ class Vector2 {
      * @param {number} fraction
      */
     lerpVectors(a, b, fraction) {
-        v2Lerp(this, a, b, fraction);
+        const x = lerp(a.x, b.x, fraction);
+        const y = lerp(a.y, b.y, fraction);
+
+        this.set(x, y);
     }
 
     /**
@@ -538,7 +541,7 @@ class Vector2 {
      *
      * @returns {number}
      */
-    hashCode() {
+    hash() {
         const x = Math.sin(this.x) * 1367130550;
         const y = Math.sin(this.y) * 1367130550;
 
@@ -550,7 +553,7 @@ class Vector2 {
     }
 
     /**
-     *
+     * Rotation is counter-clockwise
      * @param {number} angle in radians
      */
     rotate(angle) {
@@ -558,7 +561,7 @@ class Vector2 {
         const cos = Math.cos(angle);
 
         const x = this.x * cos - this.y * sin
-        const y = this.x * sin - this.y * cos;
+        const y = this.x * sin + this.y * cos;
 
         this.set(x, y);
     }
@@ -597,7 +600,7 @@ class Vector2 {
      * @return {boolean}
      */
     roughlyEquals(other, tolerance) {
-        return this._roughlyEquals(other.x, other.y,  tolerance);
+        return this._roughlyEquals(other.x, other.y, tolerance);
     }
 
     /**
@@ -677,23 +680,6 @@ Vector2.one = Object.freeze(new Vector2(1, 1));
  * @type {boolean}
  */
 Vector2.prototype.isVector2 = true;
-
-/**
- *
- * @param {Vector2} result
- * @param {Vector2} a
- * @param {Vector2} b
- * @param {number} fraction
- */
-function v2Lerp(result, a, b, fraction) {
-
-    const x = lerp(a.x, b.x, fraction);
-    const y = lerp(a.y, b.y, fraction);
-
-    result.set(x, y);
-}
-
-
 /**
  *
  * @param {number} x0

package/src/core/geom/Vector2.spec.js

@@ -8,6 +8,21 @@ test("setting x and y via constructor", () => {
     expect(v.y).toBe(13);
 });
 
+test("array-style accessors", () => {
+
+    const v = new Vector2();
+
+    v[0] = 3;
+    v[1] = -7;
+
+    expect(v[0]).toEqual(3);
+    expect(v.x).toEqual(3);
+
+    expect(v[1]).toEqual(-7);
+    expect(v.y).toEqual(-7);
+
+});
+
 test('add works', () => {
     const a = new Vector2(1, 3);
     const b = new Vector2(5, 7);
@@ -140,3 +155,141 @@ test("onChange is dispatched when y changes via set", () => {
 
     expect(changeHandler).toHaveBeenLastCalledWith(2, 3, 1, 3);
 });
+
+test("rotate", () => {
+
+    const v = new Vector2(0, 0);
+
+    v.rotate(0);
+
+    expect(v.x).toBeCloseTo(0);
+    expect(v.y).toBeCloseTo(0);
+
+    v.set(1, 0);
+
+    v.rotate(0);
+
+    expect(v.x).toBeCloseTo(1);
+    expect(v.y).toBeCloseTo(0);
+
+    v.set(0, 1);
+
+    v.rotate(0);
+
+    expect(v.x).toBeCloseTo(0);
+    expect(v.y).toBeCloseTo(1);
+
+    v.set(1, 0);
+
+    v.rotate(Math.PI);
+
+    expect(v.x).toBeCloseTo(-1);
+    expect(v.y).toBeCloseTo(0);
+
+    v.set(-1, 0);
+
+    v.rotate(Math.PI);
+
+    expect(v.x).toBeCloseTo(1);
+    expect(v.y).toBeCloseTo(0);
+
+    v.set(0, 1);
+
+    v.rotate(Math.PI);
+
+    expect(v.x).toBeCloseTo(0);
+    expect(v.y).toBeCloseTo(-1);
+
+    v.set(0, -1);
+
+    v.rotate(Math.PI);
+
+    expect(v.x).toBeCloseTo(0);
+    expect(v.y).toBeCloseTo(1);
+
+    v.set(1, 1);
+
+    v.rotate(Math.PI * 0.5);
+
+    expect(v.x).toBeCloseTo(-1);
+    expect(v.y).toBeCloseTo(1);
+});
+
+test("hash", () => {
+
+    function validate(x, y) {
+
+        const v = new Vector2(x, y);
+
+        const hash = v.hash();
+
+        expect(hash).toEqual(v.hash()); // stability
+        expect(typeof hash).toBe("number");
+        expect(Number.isInteger(hash)).toBe(true);
+
+    }
+
+    validate(0, 0);
+    validate(0, 1);
+    validate(1, 0);
+    validate(1, 1);
+
+    validate(0, -1);
+    validate(-1, 0);
+    validate(-1, -1);
+});
+
+test("normalize", () => {
+
+    const v = new Vector2(1, 1);
+
+    v.normalize();
+
+    const s = 1 / Math.SQRT2;
+
+    expect(v.x).toBeCloseTo(s);
+    expect(v.y).toBeCloseTo(s);
+
+    v.set(-1, -1);
+
+    v.normalize();
+
+    expect(v.x).toBeCloseTo(-s);
+    expect(v.y).toBeCloseTo(-s);
+
+});
+
+test("length", () => {
+
+    expect(new Vector2(1, 0).length()).toBeCloseTo(1);
+    expect(new Vector2(0, 1).length()).toBeCloseTo(1);
+
+    expect(new Vector2(1, 1).length()).toBeCloseTo(Math.SQRT2);
+
+    expect(new Vector2(-1, 1).length()).toBeCloseTo(Math.SQRT2);
+
+    expect(new Vector2(1, -1).length()).toBeCloseTo(Math.SQRT2);
+
+    expect(new Vector2(-1, -1).length()).toBeCloseTo(Math.SQRT2);
+});
+
+
+test("manhattanDistanceTo", () => {
+    const a = new Vector2(1, 3);
+    const b = new Vector2(5, 11);
+
+    expect(a.manhattanDistanceTo(b)).toEqual(12)
+});
+
+test("lerpVectors", () => {
+
+
+    const a = new Vector2(-1, 3);
+    const b = new Vector2(5, -11);
+
+    a.lerpVectors(a, b, 0.1);
+
+    expect(a.x).toBeCloseTo(-1 * 0.9 + 5 * 0.1);
+    expect(a.y).toBeCloseTo(3 * 0.9 - 11 * 0.1);
+
+});

package/src/core/model/ModuleRegistry.js

@@ -15,9 +15,7 @@ export class ModuleRegistry {
 
     constructor() {
 
-        const self = this;
-
-        this.proxy = new Proxy({}, {
+        this.proxy = new Proxy(this, {
             /**
              *
              * @param target
@@ -26,7 +24,7 @@ export class ModuleRegistry {
              * @returns {Class}
              */
             get(target, p, receiver) {
-                const module = self.get(p);
+                const module = target.get(p);
 
                 if (module === undefined) {
                     throw new Error(`Module '${p}' not found in the registry`);

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

@@ -0,0 +1,31 @@
+import { ModuleRegistry } from "./ModuleRegistry.js";
+
+test("constructor does not throw", () => {
+
+    expect(() => new ModuleRegistry()).not.toThrow();
+
+});
+
+test("add/retrieve", () => {
+
+    const registry = new ModuleRegistry();
+
+    const module = {};
+
+    registry.add("x", module);
+
+    expect(registry.get("x")).toBe(module);
+
+});
+
+test("retrieve by proxy", () => {
+
+    const registry = new ModuleRegistry();
+
+    const module = {};
+
+    registry.add("x", module);
+
+    expect(registry.proxy.x).toBe(module);
+
+});

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

@@ -0,0 +1,14 @@
+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,7 +1,7 @@
 import { ReactiveLiteralBoolean } from "../terminal/ReactiveLiteralBoolean.js";
 import { ReactiveAnd } from "./ReactiveAnd.js";
 
-test('.copy method must not change the original', () => {
+test('copy method does not modify the sources', () => {
 
     const b0 = ReactiveLiteralBoolean.from(false);
     const b1 = ReactiveLiteralBoolean.from(true);
@@ -19,3 +19,33 @@ test('.copy method must not change the original', () => {
     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

@@ -0,0 +1,53 @@
+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/stat/LinearModifier.js

@@ -13,8 +13,8 @@ class LinearModifier {
      * @constructor
      */
     constructor(a = 1, b = 0) {
-        assert.typeOf(a, 'number', 'a');
-        assert.typeOf(b, 'number', 'b');
+        assert.isNumber(a, 'a');
+        assert.isNumber(b, 'b');
 
         /**
          * gradient (slope)

package/src/core/model/stat/LinearModifier.spec.js

@@ -33,3 +33,65 @@ test("equals method", () => {
     expect(a.equals(c)).toBe(false);
     expect(a.equals(d)).toBe(false);
 });
+
+test("hash", () => {
+    const mod = new LinearModifier(3, -7);
+
+    const hash = mod.hash();
+
+    expect(mod.hash()).toEqual(hash); // idempotency
+    expect(typeof hash).toEqual("number");
+    expect(Number.isInteger(hash)).toBe(true);
+});
+
+test("copy", () => {
+
+    const source = new LinearModifier(3, -7);
+    const target = new LinearModifier(1, 1);
+
+    target.copy(source);
+
+    expect(target.a).toBe(3);
+    expect(target.b).toBe(-7);
+
+    // check that original was not changed
+
+    expect(source.a).toBe(3);
+    expect(source.b).toBe(-7);
+});
+
+test("clone", () => {
+
+    const source = new LinearModifier(3, -7);
+
+    const clone = source.clone();
+
+    expect(clone.equals(source)).toBe(true);
+
+});
+
+test("to/from JSON consistency", () => {
+
+    const source = new LinearModifier(3, -7);
+    const target = new LinearModifier(1, 1);
+
+    target.fromJSON(source.toJSON());
+
+    expect(target.a).toBe(3);
+    expect(target.b).toBe(-7);
+
+    // check that original was not changed
+
+    expect(source.a).toBe(3);
+    expect(source.b).toBe(-7);
+});
+
+test("toString produces a valid string", () => {
+
+    const s = new LinearModifier(3, -7).toString();
+
+    expect(typeof s).toBe("string");
+    expect(s.trim().length).toBeGreaterThan(0);
+
+});
+

package/src/core/model/stat/Stat.js

@@ -140,6 +140,15 @@ class Stat extends Number {
         this.updateValue();
     }
 
+    /**
+     *
+     * @param {LinearModifier} mod
+     * @return {boolean}
+     */
+    hasModifier(mod) {
+        return this.__modifiers.contains(mod);
+    }
+
     /**
      *
      * @param {LinearModifier} mod
@@ -174,6 +183,8 @@ class Stat extends Number {
     copy(other) {
         this.base.copy(other.base);
         this.__modifiers.copy(other.__modifiers);
+
+        this.updateValue();
     }
 
     /**
@@ -226,6 +237,7 @@ class Stat extends Number {
     fromJSON(json) {
         this.base.fromJSON(json.base);
         this.__modifiers.fromJSON(json.modifiers, LinearModifier);
+        this.updateValue();
     }
 
     /**

package/src/core/model/stat/Stat.spec.js

@@ -73,3 +73,39 @@ test("order of modifiers doesn't matter", () => {
         expect(s.getValue()).toEqual(-45);
     }
 });
+
+test("toString produces a valid string", () => {
+    const stat = new Stat(1);
+
+    const s = stat.toString();
+
+    expect(typeof s).toBe("string");
+    expect(s.trim().length).toBeGreaterThan(0);
+});
+
+test("copy", () => {
+    const source = new Stat(7);
+
+    source.addModifier(LinearModifier.CONSTANT_ONE);
+
+    const other = new Stat(1);
+
+    other.copy(source);
+
+    expect(other.getBaseValue()).toBe(7);
+    expect(other.hasModifier(LinearModifier.CONSTANT_ONE));
+
+    expect(other.equals(source)).toBe(true);
+});
+
+test("to/from JSON consistency", () => {
+
+    const source = new Stat(7);
+    source.addModifier(LinearModifier.CONSTANT_ONE);
+
+    const destination = new Stat(1);
+
+    destination.fromJSON(source.toJSON());
+
+    expect(destination.equals(source)).toBe(true);
+});

package/src/core/primitives/array/computeStridedIntegerArrayHash.spec.js

@@ -0,0 +1,28 @@
+import { computeStridedIntegerArrayHash } from "./computeStridedIntegerArrayHash.js";
+
+/**
+ *
+ * @param {number[]} value
+ * @param {number} [stride]
+ */
+function check(value, stride = 1) {
+    const hash = computeStridedIntegerArrayHash(value, 0, value.length, 1);
+
+    expect(typeof hash).toBe('number');
+    expect(Number.isInteger(hash)).toBe(true);
+
+}
+
+test("sanity", () => {
+
+    check([], 1);
+
+    check([1], 1);
+    check([1], 3);
+
+    check([1, 3], 1);
+    check([1, 3], 3);
+
+    check([1, 3, 7], 3);
+
+});

package/src/core/primitives/numbers/number_format_by_thousands.js

@@ -0,0 +1,14 @@
+import { assert } from "../../assert.js";
+
+/**
+ *
+ * @param {number} x
+ * @param {string} [separator=',']
+ * @returns {string}
+ */
+export function number_format_by_thousands(x, separator = ',') {
+    assert.isNumber(x, 'x');
+    assert.isString(separator, 'separator');
+
+    return x.toString().replace(/\B(?=(\d{3})+(?!\d))/g, separator);
+}

package/src/core/primitives/numbers/number_pretty_print.js

@@ -0,0 +1,49 @@
+import { assert } from "../../assert.js";
+import { number_format_by_thousands } from "./number_format_by_thousands.js";
+
+/**
+ *
+ * @param {string} value
+ * @returns {number}
+ */
+function countDecimals(value) {
+    if (value % 1 === 0) {
+        //whole number
+        return 0;
+    }
+    const s = value.toString();
+    const index = s.indexOf('.');
+
+    if (index === -1) {
+        return 0;
+    }
+
+    //find last 0
+    let endIndex = s.length - 1;
+    for (; endIndex > index && s.charAt(endIndex) === "0"; endIndex--) {
+
+    }
+    return endIndex - index;
+}
+
+/**
+ *
+ * @param {number} value
+ * @returns {string|number}
+ */
+export function number_pretty_print(value) {
+    assert.isNumber(value, 'value');
+
+    const MAX_DECIMALS = 2;
+
+    const fraction = value % 1;
+    if (fraction !== 0 && Math.abs(value) < 100) {
+        const decimals = countDecimals(value.toFixed(MAX_DECIMALS));
+        const decimalsToPrint = Math.min(decimals, MAX_DECIMALS);
+        return value.toFixed(decimalsToPrint);
+    } else {
+        //no fraction
+        return number_format_by_thousands(value - fraction, ",");
+    }
+
+}

package/src/core/primitives/strings/computeStringHash.spec.js

@@ -1,13 +1,20 @@
 import { computeStringHash } from "./computeStringHash.js";
 
-test('hash', () => {
+function check(value) {
     // must produce a number
-    expect(typeof computeStringHash('')).toBe('number');
+    const hash = computeStringHash(value);
+    expect(typeof hash).toBe('number');
+    expect(Number.isInteger(hash)).toBe(true);
+    expect(computeStringHash(value)).toEqual(hash); // stability
+}
 
-    // check for identical results from identical inputs
-    expect(computeStringHash('')).toBe(computeStringHash(''));
+test('hash', () => {
 
-    expect(computeStringHash('cat')).toBe(computeStringHash('cat'));
+    check('');
+    check('cat');
+    check('tomato');
+    check(null);
+    check(undefined);
 
     expect(computeStringHash('tomato')).not.toBe(computeStringHash('potato'));
 });

package/src/core/process/BaseProcess.js

@@ -4,14 +4,14 @@ import ObservedEnum from "../model/ObservedEnum.js";
 import { ProcessState } from "./ProcessState.js";
 
 export class BaseProcess {
-    constructor() {
-        this.id = "";
-        /**
-         * @readonly
-         * @type {ObservedEnum.<ProcessState>}
-         */
-        this.__state = new ObservedEnum(ProcessState.New, ProcessState);
-    }
+
+    id = "";
+    /**
+     * @readonly
+     * @type {ObservedEnum.<ProcessState>}
+     */
+    __state = new ObservedEnum(ProcessState.New, ProcessState);
+
 
     /**
      * @returns {ObservedEnum<ProcessState>}