@woosh/meep-engine 2.50.3 → 2.52.0

package/src/core/math/noise/sdnoise.spec.js

@@ -0,0 +1,87 @@
+import { sdnoise1, sdnoise2, sdnoise3, sdnoise4 } from "./sdnoise.js";
+
+describe("sdnoise1", () => {
+    test("sanity", () => {
+        const derivatives = [];
+
+        const value = sdnoise1(derivatives, 0);
+
+        expect(typeof value).toBe("number");
+        expect(value).not.toBeNaN();
+
+        expect(derivatives.length).toEqual(1);
+
+        expect(typeof derivatives[0]).toBe("number");
+        expect(derivatives[0]).not.toBeNaN();
+
+    });
+});
+
+describe("sdnoise2", () => {
+    test("sanity", () => {
+        const derivatives = [];
+
+        const value = sdnoise2(derivatives, 0, 0);
+
+        expect(typeof value).toBe("number");
+        expect(value).not.toBeNaN();
+
+        expect(derivatives.length).toEqual(2);
+
+        expect(typeof derivatives[0]).toBe("number");
+        expect(derivatives[0]).not.toBeNaN();
+
+        expect(typeof derivatives[1]).toBe("number");
+        expect(derivatives[1]).not.toBeNaN();
+
+    });
+});
+
+describe("sdnoise3", () => {
+    test("sanity", () => {
+        const derivatives = [];
+
+        const value = sdnoise3(derivatives, 0, 0, 0);
+
+        expect(typeof value).toBe("number");
+        expect(value).not.toBeNaN();
+
+        expect(derivatives.length).toEqual(3);
+
+        expect(typeof derivatives[0]).toBe("number");
+        expect(derivatives[0]).not.toBeNaN();
+
+        expect(typeof derivatives[1]).toBe("number");
+        expect(derivatives[1]).not.toBeNaN();
+
+        expect(typeof derivatives[2]).toBe("number");
+        expect(derivatives[2]).not.toBeNaN();
+
+    });
+});
+
+describe("sdnoise4", () => {
+    test("sanity", () => {
+        const derivatives = [];
+
+        const value = sdnoise4(derivatives, 0, 0, 0, 0);
+
+        expect(typeof value).toBe("number");
+        expect(value).not.toBeNaN();
+
+        expect(derivatives.length).toEqual(4);
+
+        expect(typeof derivatives[0]).toBe("number");
+        expect(derivatives[0]).not.toBeNaN();
+
+        expect(typeof derivatives[1]).toBe("number");
+        expect(derivatives[1]).not.toBeNaN();
+
+        expect(typeof derivatives[2]).toBe("number");
+        expect(derivatives[2]).not.toBeNaN();
+
+        expect(typeof derivatives[3]).toBe("number");
+        expect(derivatives[3]).not.toBeNaN();
+
+    });
+});

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

package/src/engine/Clock.js

@@ -5,16 +5,15 @@
 
 import Stat from "../core/model/stat/Stat.js";
 
+//Use highest available resolution time source
+const source = typeof performance === "undefined" ? Date : performance;
 
 /**
  *
  * @returns {number}
  */
 export function currentTimeInSeconds() {
-    //Use highest available resolution time source
-    const source = typeof performance === "undefined" ? Date : performance;
-
-    return source.now() / 1000;
+    return source.now() * 0.001;
 }
 
 /**
@@ -29,35 +28,37 @@ function updateElapsedTime(clock) {
 }
 
 class Clock {
-    constructor() {
-        /**
-         *
-         * @type {number}
-         * @private
-         */
-        this.__lastMeasurement = 0;
-
-        /**
-         *
-         * @type {number}
-         */
-        this.elapsedTime = 0;
 
-        this.timeAtDelta = 0;
+    /**
+     *
+     * @type {number}
+     * @private
+     */
+    __lastMeasurement = 0;
 
-        /**
-         *
-         * @type {boolean}
-         * @private
-         */
-        this.__isRunning = false;
+    /**
+     *
+     * @type {number}
+     */
+    elapsedTime = 0;
+
+    timeAtDelta = 0;
+
+    /**
+     *
+     * @type {boolean}
+     * @private
+     */
+    __isRunning = false;
 
 
-        /**
-         * how fast clock ticks in relation to real time
-         * @type {Stat}
-         */
-        this.speed = new Stat(1);
+    /**
+     * how fast clock ticks in relation to real time
+     * @type {Stat}
+     */
+    speed = new Stat(1);
+
+    constructor() {
         this.speed.postprocess = Stat.Process.clampMin(0);
     }
 

package/src/engine/Clock.spec.js

@@ -0,0 +1,26 @@
+import Clock from "./Clock.js";
+import { delay } from "../core/process/delay.js";
+
+test("constructor does not throw", () => {
+    new Clock();
+});
+
+test("reset", () => {
+    const clock = new Clock();
+    clock.reset();
+
+    expect(clock.getElapsedTime()).toBe(0);
+    expect(clock.getDelta()).toBe(0);
+});
+
+test("getDelta", async () => {
+    const clock = new Clock();
+
+    clock.start();
+
+    await delay(30);
+
+    const delta = clock.getDelta();
+
+    expect(delta).toBeCloseTo(0.03, 0.01);
+});

package/src/engine/{Platform.js → browserInfo.js}

@@ -4,7 +4,7 @@ let cached = null;
  * https://stackoverflow.com/questions/5916900/how-can-you-detect-the-version-of-a-browser
  * @returns {{name:String, version:Number}}
  */
-function browserInfo() {
+export function browserInfo() {
     if (cached !== null) {
         return cached;
     }
@@ -46,7 +46,3 @@ function browserInfo() {
 
     return result;
 }
-
-export {
-    browserInfo
-}