@woosh/meep-engine 2.110.14 → 2.110.15

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

@@ -1,27 +0,0 @@
-import { string_strip_trailing } from "./string_strip_trailing.js";
-
-test("strip empty from empty", () => {
-    expect(
-        string_strip_trailing("", "")
-    ).toBe("");
-});
-
-test("strip repeating 2 character sequence", () => {
-
-    expect(
-        string_strip_trailing("Cabab", "ab")
-    ).toBe("C");
-
-});
-
-test("mistakes", () => {
-
-    expect(
-        string_strip_trailing("food", "o")
-    ).toBe("food");
-
-    expect(
-        string_strip_trailing("food", "f")
-    ).toBe("food");
-
-});

package/src/core/process/PromiseWatcher.spec.js

@@ -1,69 +0,0 @@
-import { noop } from "../function/noop.js";
-import { PromiseWatcher } from "./PromiseWatcher.js";
-
-function trigger() {
-    let _resolve;
-    let _reject;
-
-    const promise = new Promise((resolve, reject) => {
-        _resolve = resolve;
-        _reject = reject;
-    });
-
-    //Node.js doesn't allow unhandled rejections, lets handle it with noop
-    promise.catch(noop);
-
-    return {
-        promise,
-        reject(r) {
-            setTimeout(() => _reject(r), 1);
-        },
-        resolve(v) {
-            _resolve(v);
-        }
-    };
-}
-
-// TODO broken tests, skipped for now
-describe.skip("suite", () => {
-
-    test('constructor', () => {
-        const w = new PromiseWatcher();
-
-        expect(w.unresolvedCount.getValue()).toBe(0);
-        expect(w.unresolved.isEmpty()).toBe(true);
-    });
-
-
-    test('add one and resolve', async () => {
-        const w = new PromiseWatcher();
-
-        const t0 = trigger();
-
-        w.add(t0.promise);
-
-        expect(w.unresolvedCount.getValue()).toBe(1);
-
-        t0.resolve();
-
-        await t0.promise;
-
-        expect(w.unresolvedCount.getValue()).toBe(0);
-    });
-
-    test('add one and reject', async () => {
-        const w = new PromiseWatcher();
-
-        const t0 = trigger();
-
-        w.add(t0.promise);
-
-        expect(w.unresolvedCount.getValue()).toBe(1);
-
-        t0.reject("Apple Sauce");
-
-        await t0.promise.catch(noop);
-
-        expect(w.unresolvedCount.getValue()).toBe(0);
-    });
-})

package/src/core/process/executor/ConcurrentExecutor.spec.js

@@ -1,135 +0,0 @@
-import { jest } from "@jest/globals";
-import Task from "../task/Task.js"
-import TaskGroup from "../task/TaskGroup.js";
-import { TaskSignal } from "../task/TaskSignal.js";
-import TaskState from "../task/TaskState.js";
-import ConcurrentExecutor from "./ConcurrentExecutor.js";
-import { emptyTask } from "../task/util/emptyTask.js";
-import { failingTask } from "../task/util/failingTask.js";
-
-/**
- *
- * @return {ConcurrentExecutor}
- */
-function makeExecutor() {
-    return new ConcurrentExecutor(1, 1);
-}
-
-test("Constructor doesn't throw", () => {
-    expect(() => new ConcurrentExecutor(0, 1)).not.toThrow();
-});
-
-test("Execute simple task", async () => {
-    const task = emptyTask();
-
-    const cycle = jest.spyOn(task, 'cycle');
-    const initialize = jest.spyOn(task, 'initialize');
-
-    const executor = makeExecutor();
-
-    executor.run(task);
-
-    await Task.promise(task);
-
-    expect(cycle).toHaveBeenCalledTimes(1);
-    expect(initialize).toHaveBeenCalledTimes(1);
-
-    expect(task.state.getValue()).toBe(TaskState.SUCCEEDED);
-});
-
-test("Execute chain of dependent tasks submitted in reverse order", async () => {
-    const taskA = emptyTask();
-    const taskB = emptyTask();
-    const taskC = emptyTask();
-
-    taskC.addDependency(taskB);
-    taskB.addDependency(taskA);
-
-
-    const cycleA = jest.spyOn(taskA, 'cycle');
-    const cycleB = jest.spyOn(taskB, 'cycle');
-    const cycleC = jest.spyOn(taskC, 'cycle');
-
-
-    const executor = makeExecutor();
-
-    executor.run(taskC);
-    executor.run(taskB);
-    executor.run(taskA);
-
-    await Task.promise(taskC);
-
-    expect(cycleA).toHaveBeenCalledTimes(1);
-    expect(cycleB).toHaveBeenCalledTimes(1);
-    expect(cycleC).toHaveBeenCalledTimes(1);
-
-    expect(taskA.state.getValue()).toBe(TaskState.SUCCEEDED);
-    expect(taskB.state.getValue()).toBe(TaskState.SUCCEEDED);
-    expect(taskC.state.getValue()).toBe(TaskState.SUCCEEDED);
-});
-
-
-test("TaskGroup state is set to SUCCEEDED after all children succeed", async () => {
-    const group = new TaskGroup([emptyTask(), emptyTask()], "a");
-
-    const executor = makeExecutor();
-
-    executor.runGroup(group);
-
-    await Task.promise(group);
-
-    expect(group.state.getValue()).toBe(TaskState.SUCCEEDED);
-});
-
-test("TaskGroup state is set to FAILED after one child fails", async () => {
-    const group = new TaskGroup([emptyTask(), failingTask("Fail")], "a");
-
-    const executor = makeExecutor();
-
-    executor.runGroup(group);
-
-    await new Promise((resolve, reject) => Task.join(group, resolve, resolve));
-
-    expect(group.state.getValue()).toBe(TaskState.FAILED);
-});
-
-test("Remove task during its execution", async () => {
-    const executor = makeExecutor();
-
-    let i = 0;
-    const task = new Task({
-        name: 'test',
-        cycleFunction() {
-
-            if (i === 0) {
-                const removed = executor.removeTask(task);
-                expect(removed).toBe(true);
-            }
-
-            i++;
-
-            return TaskSignal.Continue;
-        }
-    });
-
-    const checkerTask = new Task({
-        name: 'Checker',
-        cycleFunction() {
-
-            if (executor.contains(task)) {
-                return TaskSignal.Yield;
-            }
-
-            return TaskSignal.EndSuccess;
-        }
-    });
-
-
-    executor.run(task);
-    executor.run(checkerTask);
-
-    await Task.promise(checkerTask);
-
-    expect(task.state.getValue()).toBe(TaskState.RUNNING);
-    expect(executor.contains(task)).toBe(false);
-});

package/src/core/process/task/util/actionTask.spec.js

@@ -1,14 +0,0 @@
-import { jest } from "@jest/globals";
-import { actionTask } from "./actionTask.js";
-
-test("main", () => {
-
-    const mock = jest.fn();
-
-    const task = actionTask(mock);
-
-    task.executeSync();
-
-    expect(mock).toHaveBeenCalledTimes(1);
-
-});

package/src/core/process/task/util/countTask.spec.js

@@ -1,18 +0,0 @@
-import { jest } from "@jest/globals";
-import { countTask } from "./countTask.js";
-
-test("static count", () => {
-
-    const mock = jest.fn();
-
-    const task = countTask(3, 7, mock);
-
-    task.executeSync();
-
-    expect(mock).toHaveBeenCalledTimes(4);
-
-    expect(mock).toHaveBeenCalledWith(3)
-    expect(mock).toHaveBeenCalledWith(4)
-    expect(mock).toHaveBeenCalledWith(5)
-    expect(mock).toHaveBeenCalledWith(6)
-});

package/src/core/process/undo/ActionProcessor.spec.js

@@ -1,64 +0,0 @@
-import { ActionProcessor } from "./ActionProcessor.js";
-import { Action } from "./Action.js";
-
-class DummyContext {
-    constructor() {
-        this.value = 0;
-    }
-}
-
-class DummyAction extends Action {
-    async apply(context) {
-        // do nothing
-        context.value++;
-    }
-
-    async revert(context) {
-        context.value--;
-    }
-}
-
-test('navigateTo backwards', async () => {
-    const ctx = new DummyContext();
-    const ap = new ActionProcessor(ctx);
-
-    ap.mark('a');
-    await ap.do(new DummyAction());
-    ap.mark('b');
-    await ap.do(new DummyAction());
-
-    const nav_result = await ap.navigateTo('a');
-
-    expect(nav_result).toBe(true);
-
-    expect(ctx.value).toBe(1);
-});
-
-test('navigateTo forward', async () => {
-    const ctx = new DummyContext();
-    const ap = new ActionProcessor(ctx);
-
-    ap.mark('a');
-    await ap.do(new DummyAction());
-    ap.mark('b');
-    await ap.do(new DummyAction());
-    ap.mark('c');
-
-    await ap.undo();
-    await ap.undo();
-    await ap.undo();
-
-    const nav_result = await ap.navigateTo('c');
-
-    expect(nav_result).toBe(true);
-
-    expect(ctx.value).toBe(2);
-});
-
-test('navigateTo non-existent on empty', async () => {
-    const ctx = new DummyContext();
-    const ap = new ActionProcessor(ctx);
-
-    const nav_result = await ap.navigateTo('a');
-    expect(nav_result).toBe(false);
-});

package/src/engine/Clock.spec.js

@@ -1,26 +0,0 @@
-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/Engine.spec.js

@@ -1,15 +0,0 @@
-/**
- * @jest-environment jsdom
- */
-
-import Engine from "./Engine.js";
-import { InMemoryEnginePlatform } from "./platform/InMemoryEnginePlatform.js";
-
-test("constructor does not throw", () => {
-    const platform = new InMemoryEnginePlatform();
-
-    expect(() => new Engine(platform, {
-        enableAudio: false,
-        enableGraphics: false
-    })).not.toThrow();
-});

package/src/engine/achievements/Achievement.spec.js

@@ -1,21 +0,0 @@
-import { Achievement } from "./Achievement.js";
-
-test("constructor does not throw", () => {
-    expect(() => new Achievement()).not.toThrow();
-});
-
-test("fromJSON correctness", () => {
-    const achievement = new Achievement();
-
-    achievement.fromJSON({
-        id: "x",
-        condition: "hello == kitty",
-        icon: "y",
-        secret: true
-    });
-
-    expect(achievement.id).toEqual("x");
-    expect(achievement.condition).toEqual("hello == kitty");
-    expect(achievement.icon).toEqual("y");
-    expect(achievement.secret).toEqual(true);
-});

package/src/engine/animation/curve/AnimationCurve.spec.js

@@ -1,248 +0,0 @@
-import { AnimationCurve } from "./AnimationCurve.js";
-import { Keyframe } from "./Keyframe.js";
-
-test("constructor does not throw", () => {
-    expect(() => new AnimationCurve()).not.toThrow();
-});
-
-test("adding key increases length", () => {
-    const curve = new AnimationCurve();
-
-    curve.add(Keyframe.from(1, 7));
-
-    expect(curve.length).toBe(1);
-});
-
-test("removing non-existent key", () => {
-    const curve = new AnimationCurve();
-
-    expect(curve.remove(Keyframe.from(1, 7))).toBe(false);
-
-    expect(curve.length).toBe(0);
-
-});
-
-test("clear removes all keys", () => {
-
-    const curve = new AnimationCurve();
-
-    curve.add(Keyframe.from(0, 0));
-    curve.add(Keyframe.from(0, 0));
-
-    curve.clear();
-
-    expect(curve.length).toBe(0);
-});
-
-test("removing exising key", () => {
-    const curve = new AnimationCurve();
-
-    const key = Keyframe.from(1, 7);
-
-    curve.add(key);
-
-    expect(curve.remove(key)).toBe(true);
-
-    expect(curve.length).toBe(0);
-});
-
-test("evaluate on empty curve", () => {
-    const curve = new AnimationCurve();
-
-    expect(curve.evaluate(0)).toBe(0);
-});
-
-test("evaluate before first frame, 1 frame curve", () => {
-    const curve = new AnimationCurve();
-
-    curve.add(Keyframe.from(1, 7));
-
-    expect(curve.evaluate(0.9)).toEqual(7);
-});
-test("evaluate before first frame, 2 frame curve", () => {
-    const curve = new AnimationCurve();
-
-    curve.add(Keyframe.from(1, 7));
-    curve.add(Keyframe.from(2, 10));
-
-    expect(curve.evaluate(0.9)).toEqual(7);
-});
-
-test("sample linear curve with 2 points", () => {
-    const curve = new AnimationCurve();
-    curve.add(Keyframe.from(0, -3, 6, 6));
-    curve.add(Keyframe.from(1, 3, 6, 6));
-
-    expect(curve.evaluate(0)).toBeCloseTo(-3);
-    expect(curve.evaluate(1)).toBeCloseTo(3);
-    expect(curve.evaluate(0.5)).toBeCloseTo(0);
-});
-
-test("insert key out of order, should end up ordered", () => {
-
-    const curve = new AnimationCurve();
-
-    curve.add(Keyframe.from(0, 3));
-    curve.add(Keyframe.from(5, 7));
-
-    const out_of_order_key = Keyframe.from(1, 11);
-    curve.add(out_of_order_key);
-
-    expect(curve.keys[1]).toBe(out_of_order_key);
-
-});
-
-test("smooth tangents with a single keyframe does not throw", () => {
-    const curve = new AnimationCurve();
-
-    curve.add(Keyframe.from(0, 7));
-
-    expect(() => curve.smoothTangents(0, 1)).not.toThrow()
-});
-test("smooth tangents on a middle frame", () => {
-    const curve = new AnimationCurve();
-
-    curve.add(Keyframe.from(0, 1));
-    curve.add(Keyframe.from(1, 2));
-    curve.add(Keyframe.from(2, 3));
-
-    curve.smoothTangents(1, 1);
-
-    const key = curve.keys[1];
-
-    expect(key.inTangent).toEqual(key.outTangent);
-});
-
-test("extreme tangent interpolation", () => {
-
-
-    const curve = new AnimationCurve();
-
-    curve.add(Keyframe.from(0, 1, 0, -1));
-    curve.add(Keyframe.from(1, 2, -1, 0));
-
-    expect(curve.evaluate(0.1)).toBeLessThan(1);
-    expect(curve.evaluate(0.9)).toBeGreaterThan(2);
-
-});
-
-test("to/from JSON consistency", () => {
-
-    const curve = new AnimationCurve();
-
-    curve.add(Keyframe.from(3, -7, 13, -17));
-
-    const c2 = new AnimationCurve();
-
-    c2.fromJSON(curve.toJSON());
-
-    expect(c2.length).toBe(1);
-
-    const first_key = c2.keys[0];
-
-    expect(first_key.time).toBe(3);
-    expect(first_key.value).toBe(-7);
-    expect(first_key.inTangent).toBe(13);
-    expect(first_key.outTangent).toBe(-17);
-});
-
-
-test("static easeInOut constructor", () => {
-
-    const curve = AnimationCurve.easeInOut(1, 3, 5, 7);
-
-
-    expect(curve.evaluate(1.1)).toBeCloseTo(3, 0.1);
-    expect(curve.evaluate(4.9)).toBeCloseTo(7, 0.1);
-
-    expect(curve.evaluate(3)).toBeCloseTo(5, 0.01);
-});
-
-test("static linear constructor", () => {
-
-    const curve = AnimationCurve.linear(1, 3, 5, 7);
-
-
-    expect(curve.evaluate(1.1)).toBeCloseTo(3.1, 0.01);
-    expect(curve.evaluate(4.9)).toBeCloseTo(6.9, 0.01);
-
-    expect(curve.evaluate(3)).toBeCloseTo(5, 0.01);
-});
-
-test("static constant constructor", () => {
-
-    const curve = AnimationCurve.constant(1, 5, 7);
-
-
-    expect(curve.evaluate(1.1)).toBe(7);
-    expect(curve.evaluate(4.9)).toBe(7);
-
-    expect(curve.evaluate(3)).toBe(7);
-});
-
-test("equals method", () => {
-
-    expect(new AnimationCurve().equals(new AnimationCurve())).toBe(true);
-
-    // one frame
-    expect(
-        AnimationCurve.from([Keyframe.from(0, 0)])
-            .equals(AnimationCurve.from([Keyframe.from(0, 0)]))
-    ).toBe(true);
-
-    expect(
-        AnimationCurve.from([Keyframe.from(0, 1)])
-            .equals(AnimationCurve.from([Keyframe.from(0, 0)]))
-    ).toBe(false);
-
-    expect(
-        AnimationCurve.from([Keyframe.from(1, 0)])
-            .equals(AnimationCurve.from([Keyframe.from(0, 0)]))
-    ).toBe(false);
-
-    expect(
-        AnimationCurve.from([Keyframe.from(0, 0)])
-            .equals(AnimationCurve.from([Keyframe.from(0, 1)]))
-    ).toBe(false);
-
-    expect(
-        AnimationCurve.from([Keyframe.from(0, 0)])
-            .equals(AnimationCurve.from([Keyframe.from(0, 1)]))
-    ).toBe(false);
-
-    // different frame count
-
-    expect(
-        AnimationCurve.from([])
-            .equals(AnimationCurve.from([Keyframe.from(0, 0)]))
-    ).toBe(false);
-
-    expect(
-        AnimationCurve.from([Keyframe.from(0, 0)])
-            .equals(AnimationCurve.from([]))
-    ).toBe(false);
-
-});
-
-test("hash", () => {
-
-    expect(typeof AnimationCurve.from([Keyframe.from(0, 0)]).hash()).toBe("number")
-
-    expect(AnimationCurve.from([]).hash())
-        .toEqual(AnimationCurve.from([]).hash())
-
-});
-
-test("copy", () => {
-
-    const r = new AnimationCurve();
-
-    r.copy(AnimationCurve.from([Keyframe.from(1, -3, 5, -7)]))
-
-    expect(r.keys.length).toBe(1);
-    expect(r.keys[0].value).toBe(-3);
-    expect(r.keys[0].time).toBe(1);
-    expect(r.keys[0].inTangent).toBe(5);
-    expect(r.keys[0].outTangent).toBe(-7);
-
-});

package/src/engine/animation/curve/Keyframe.spec.js

@@ -1,42 +0,0 @@
-import { Keyframe } from "./Keyframe.js";
-
-test("toJSON", () => {
-
-    const k = Keyframe.from(1, 3, 5, 7);
-
-    expect(k.toJSON()).toEqual({
-        time: 1,
-        value: 3,
-        inTangent: 5,
-        outTangent: 7
-    });
-});
-
-test("fromJSON", () => {
-
-    const keyframe = new Keyframe();
-
-    keyframe.fromJSON({
-        time: 1,
-        value: 3,
-        inTangent: 5,
-        outTangent: 7
-    });
-
-    expect(keyframe.time).toEqual(1);
-    expect(keyframe.value).toEqual(3);
-    expect(keyframe.inTangent).toEqual(5);
-    expect(keyframe.outTangent).toEqual(7);
-
-});
-
-test("copy",()=>{
-    const keyframe = new Keyframe();
-
-    keyframe.copy(Keyframe.from(1, -3, 5, -7));
-
-    expect(keyframe.value).toBe(-3);
-    expect(keyframe.time).toBe(1);
-    expect(keyframe.inTangent).toBe(5);
-    expect(keyframe.outTangent).toBe(-7);
-});