@vived/app 3.8.0 → 3.9.0

package/lib/AppObjectComponents/Dispatcher/UC/SubmitResultResultUC.d.ts

@@ -0,0 +1,43 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+export interface HitResultDTO {
+    success: boolean;
+    description: string;
+}
+export interface ProgressResultDTO {
+    progress: number;
+    description: string;
+}
+export interface MultiHitResultDTO {
+    hits: number;
+    misses: number;
+    unanswered: number;
+    description: string;
+}
+export interface QualityResultDTO {
+    stars: number;
+    maxStars: number;
+    description: string;
+}
+export interface ScoreResultDTO {
+    score: number;
+    maxScore: number;
+    description: string;
+}
+export declare abstract class SubmitResultResultUC extends AppObjectUC {
+    static readonly type = "SubmitResultResultUC";
+    readonly requestType = "SUBMIT_RESULTS";
+    abstract submitHitResult(data: HitResultDTO): void;
+    abstract submitProgressResult(data: ProgressResultDTO): void;
+    abstract submitMultiHitResult(data: MultiHitResultDTO): void;
+    abstract submitQualityResult(data: QualityResultDTO): void;
+    abstract submitScoreResult(data: ScoreResultDTO): void;
+    static get(appObjects: AppObjectRepo): SubmitResultResultUC | undefined;
+}
+export declare function makeSubmitResultUC(appObject: AppObject): SubmitResultResultUC;
+export declare function submitHitResult(data: HitResultDTO, appObjects: AppObjectRepo): void;
+export declare function submitProgressResult(data: ProgressResultDTO, appObjects: AppObjectRepo): void;
+export declare function submitQualityResult(data: QualityResultDTO, appObjects: AppObjectRepo): void;
+export declare function submitScoreResult(data: ScoreResultDTO, appObjects: AppObjectRepo): void;
+export declare function submitMultiHitResult(data: MultiHitResultDTO, appObjects: AppObjectRepo): void;

package/lib/AppObjectComponents/Dispatcher/UC/SubmitResultResultUC.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.submitMultiHitResult = exports.submitScoreResult = exports.submitQualityResult = exports.submitProgressResult = exports.submitHitResult = exports.makeSubmitResultUC = exports.SubmitResultResultUC = void 0;
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const App_1 = require("../../App");
+const AppDispatcher_1 = require("../Entities/AppDispatcher");
+class SubmitResultResultUC extends AppObjectUC_1.AppObjectUC {
+    constructor() {
+        super(...arguments);
+        this.requestType = "SUBMIT_RESULTS";
+    }
+    static get(appObjects) {
+        const components = appObjects.getAllComponents(SubmitResultResultUC.type);
+        if (components.length === 0) {
+            App_1.submitWarning("RegisterExternalStylesheetsUC", `Unable to find component ${SubmitResultResultUC.type}. Add one on Mount`, appObjects);
+            return undefined;
+        }
+        else if (components.length > 1) {
+            App_1.submitWarning("RegisterExternalStylesheetsUC", `Multiple ${SubmitResultResultUC.type} found. There should only be one. Using the first one`, appObjects);
+        }
+        return components[0];
+    }
+}
+exports.SubmitResultResultUC = SubmitResultResultUC;
+SubmitResultResultUC.type = "SubmitResultResultUC";
+function makeSubmitResultUC(appObject) {
+    return new SubmitResultResultUCImp(appObject);
+}
+exports.makeSubmitResultUC = makeSubmitResultUC;
+function submitHitResult(data, appObjects) {
+    const dispatchUC = SubmitResultResultUC.get(appObjects);
+    if (dispatchUC) {
+        dispatchUC.submitHitResult(data);
+    }
+    else {
+        App_1.submitWarning("submitHitResult", "Can't find SubmitResultResultUC", appObjects);
+    }
+}
+exports.submitHitResult = submitHitResult;
+function submitProgressResult(data, appObjects) {
+    const dispatchUC = SubmitResultResultUC.get(appObjects);
+    if (dispatchUC) {
+        dispatchUC.submitProgressResult(data);
+    }
+    else {
+        App_1.submitWarning("submitProgressResult", "Can't find SubmitResultResultUC", appObjects);
+    }
+}
+exports.submitProgressResult = submitProgressResult;
+function submitQualityResult(data, appObjects) {
+    const dispatchUC = SubmitResultResultUC.get(appObjects);
+    if (dispatchUC) {
+        dispatchUC.submitQualityResult(data);
+    }
+    else {
+        App_1.submitWarning("submitQualityResult", "Can't find SubmitResultResultUC", appObjects);
+    }
+}
+exports.submitQualityResult = submitQualityResult;
+function submitScoreResult(data, appObjects) {
+    const dispatchUC = SubmitResultResultUC.get(appObjects);
+    if (dispatchUC) {
+        dispatchUC.submitScoreResult(data);
+    }
+    else {
+        App_1.submitWarning("submitScoreResult", "Can't find SubmitResultResultUC", appObjects);
+    }
+}
+exports.submitScoreResult = submitScoreResult;
+function submitMultiHitResult(data, appObjects) {
+    const dispatchUC = SubmitResultResultUC.get(appObjects);
+    if (dispatchUC) {
+        dispatchUC.submitMultiHitResult(data);
+    }
+    else {
+        App_1.submitWarning("submitMultiHitResult", "Can't find SubmitResultResultUC", appObjects);
+    }
+}
+exports.submitMultiHitResult = submitMultiHitResult;
+class SubmitResultResultUCImp extends SubmitResultResultUC {
+    constructor(appObject) {
+        super(appObject, SubmitResultResultUC.type);
+        this.requestVersion = 3;
+        this.appDispatcher = appObject.getComponent(AppDispatcher_1.AppDispatcher.type);
+        if (!this.appDispatcher) {
+            console.warn("DispatchStateChangeUC has been added to an App Object that does not have a AppDispatcher. Add a dispatcher first");
+            this.dispose();
+        }
+    }
+    submitHitResult(data) {
+        if (!this.appDispatcher)
+            return;
+        const { description, success } = data;
+        const payload = {
+            resultType: "HIT_V1",
+            description,
+            result: {
+                success,
+            },
+        };
+        this.appDispatcher.formRequestAndDispatch("SUBMIT_RESULTS", 3, payload);
+    }
+    submitProgressResult(data) {
+        if (!this.appDispatcher)
+            return;
+        const { description, progress } = data;
+        const payload = {
+            resultType: "PROGRESS_V1",
+            description,
+            result: {
+                progress,
+            },
+        };
+        this.appDispatcher.formRequestAndDispatch("SUBMIT_RESULTS", 3, payload);
+    }
+    submitMultiHitResult(data) {
+        if (!this.appDispatcher)
+            return;
+        const { description, hits, misses, unanswered } = data;
+        const payload = {
+            resultType: "MULTIHIT_V1",
+            description,
+            result: {
+                hits,
+                misses,
+                unanswered,
+            },
+        };
+        this.appDispatcher.formRequestAndDispatch("SUBMIT_RESULTS", 3, payload);
+    }
+    submitQualityResult(data) {
+        if (!this.appDispatcher)
+            return;
+        const { description, stars, maxStars } = data;
+        const payload = {
+            resultType: "QUALITY_V1",
+            description,
+            result: {
+                stars,
+                maxStars,
+            },
+        };
+        this.appDispatcher.formRequestAndDispatch("SUBMIT_RESULTS", 3, payload);
+    }
+    submitScoreResult(data) {
+        if (!this.appDispatcher)
+            return;
+        const { description, score, maxScore } = data;
+        const payload = {
+            resultType: "SCORE_V1",
+            description,
+            result: {
+                score,
+                maxScore,
+            },
+        };
+        this.appDispatcher.formRequestAndDispatch("SUBMIT_RESULTS", 3, payload);
+    }
+}

package/lib/AppObjectComponents/KeyboardInput/Entities/KeyboardInput.d.ts

@@ -0,0 +1,18 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectEntity } from "../../../AppObject/AppObjectEntity";
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+export interface KeyboardController {
+    onKeyDown?: (e: KeyboardEvent) => void;
+    onKeyUp?: (e: KeyboardEvent) => void;
+}
+export declare abstract class KeyboardInputEntity extends AppObjectEntity {
+    static readonly type = "KeyboardInputEntity";
+    abstract get eventElement(): HTMLElement | undefined;
+    abstract setEventElement: (eventElement: HTMLElement) => void;
+    abstract clearInputElement: () => void;
+    abstract registerController: (controller: KeyboardController) => void;
+    abstract removeController: (controller: KeyboardController) => void;
+    abstract isKeyPressed: (keyCode: string) => boolean;
+    static get(appObjects: AppObjectRepo): KeyboardInputEntity | undefined;
+}
+export declare function makeKeyboardInput(appObject: AppObject): KeyboardInputEntity;

package/lib/AppObjectComponents/KeyboardInput/Entities/KeyboardInput.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeKeyboardInput = exports.KeyboardInputEntity = void 0;
+const AppObjectEntity_1 = require("../../../AppObject/AppObjectEntity");
+const App_1 = require("../../App");
+class KeyboardInputEntity extends AppObjectEntity_1.AppObjectEntity {
+    static get(appObjects) {
+        const components = appObjects.getAllComponents(KeyboardInputEntity.type);
+        if (components.length === 0) {
+            App_1.submitWarning("KeyboardInputEntity", `Unable to find component ${KeyboardInputEntity.type}. Add one on Mount`, appObjects);
+            return undefined;
+        }
+        else if (components.length > 1) {
+            App_1.submitWarning("KeyboardInputEntity", `Multiple ${KeyboardInputEntity.type} found. There should only be one. Using the first one`, appObjects);
+        }
+        return components[0];
+    }
+}
+exports.KeyboardInputEntity = KeyboardInputEntity;
+KeyboardInputEntity.type = "KeyboardInputEntity";
+function makeKeyboardInput(appObject) {
+    return new KeyboardInputImp(appObject);
+}
+exports.makeKeyboardInput = makeKeyboardInput;
+class KeyboardInputImp extends KeyboardInputEntity {
+    constructor(appObject) {
+        super(appObject, KeyboardInputEntity.type);
+        this.controllers = [];
+        this._eventElement = undefined;
+        this._pressedKeyCodes = [];
+        this.setEventElement = (element) => {
+            this.clearInputElement();
+            element.addEventListener("keydown", this.submitKeyDown, false);
+            element.addEventListener("keyup", this.submitKeyUp, false);
+            this._eventElement = element;
+        };
+        this.clearInputElement = () => {
+            if (!this._eventElement)
+                return;
+            this._eventElement.removeEventListener("keydown", this.submitKeyDown);
+            this._eventElement.removeEventListener("keyup", this.submitKeyUp);
+            this._eventElement = undefined;
+        };
+        this.submitKeyDown = (e) => {
+            this._pressedKeyCodes.push(e.code);
+            this.controllers.forEach((c) => {
+                if (c.onKeyDown) {
+                    c.onKeyDown(e);
+                }
+            });
+        };
+        this.submitKeyUp = (e) => {
+            this._pressedKeyCodes = this._pressedKeyCodes.filter((keyCode) => {
+                if (keyCode === e.code) {
+                    return false;
+                }
+                return true;
+            });
+            this.controllers.forEach((c) => {
+                if (c.onKeyUp) {
+                    c.onKeyUp(e);
+                }
+            });
+        };
+        this.registerController = (controller) => {
+            this.controllers.push(controller);
+        };
+        this.removeController = (controller) => {
+            const index = this.controllers.indexOf(controller);
+            if (index >= 0) {
+                this.controllers.splice(index, 1);
+            }
+        };
+        this.isKeyPressed = (keyCode) => {
+            for (const code of this._pressedKeyCodes) {
+                if (code === keyCode) {
+                    return true;
+                }
+            }
+            return false;
+        };
+    }
+    get eventElement() {
+        return this._eventElement;
+    }
+}

package/lib/AppObjectComponents/KeyboardInput/Mocks/MockKeyboardInput.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="jest" />
+import { AppObject } from "../../../AppObject/AppObject";
+import { KeyboardInputEntity } from "../Entities/KeyboardInput";
+export declare class MockKeyboardInput extends KeyboardInputEntity {
+    get eventElement(): HTMLElement | undefined;
+    setEventElement: jest.Mock<any, any>;
+    clearInputElement: jest.Mock<any, any>;
+    registerController: jest.Mock<any, any>;
+    removeController: jest.Mock<any, any>;
+    isKeyPressed: jest.Mock<any, any>;
+    constructor(appObject: AppObject);
+}

package/lib/AppObjectComponents/KeyboardInput/Mocks/MockKeyboardInput.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockKeyboardInput = void 0;
+const KeyboardInput_1 = require("../Entities/KeyboardInput");
+class MockKeyboardInput extends KeyboardInput_1.KeyboardInputEntity {
+    constructor(appObject) {
+        super(appObject, KeyboardInput_1.KeyboardInputEntity.type);
+        this.setEventElement = jest.fn();
+        this.clearInputElement = jest.fn();
+        this.registerController = jest.fn();
+        this.removeController = jest.fn();
+        this.isKeyPressed = jest.fn();
+    }
+    get eventElement() {
+        throw new Error("Method not implemented.");
+    }
+}
+exports.MockKeyboardInput = MockKeyboardInput;

package/lib/AppObjectComponents/KeyboardInput/index.d.ts

@@ -0,0 +1 @@
+export * from "./Entities/KeyboardInput";

package/lib/{UseCases/SceneRoot → AppObjectComponents/KeyboardInput}/index.js

@@ -10,5 +10,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./SerializeSceneRoot"), exports);
-__exportStar(require("./setupSceneRoot"), exports);
+__exportStar(require("./Entities/KeyboardInput"), exports);

package/lib/AppObjectComponents/MouseInput/Entities/MouseInput.d.ts

@@ -0,0 +1,31 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectEntity } from "../../../AppObject/AppObjectEntity";
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+import { Vector2 } from "../../../ValueObjects";
+export interface MouseInputEvent {
+    position: Vector2;
+    button: number;
+    event: MouseEvent;
+}
+export interface MouseWheelEvent {
+    position: Vector2;
+    event: WheelEvent;
+}
+export interface MouseController {
+    onClick?: (e: MouseInputEvent) => void;
+    onDoubleClick?: (e: MouseInputEvent) => void;
+    onDown?: (e: MouseInputEvent) => void;
+    onUp?: (e: MouseInputEvent) => void;
+    onMove?: (e: MouseInputEvent) => void;
+    onWheel?: (e: MouseWheelEvent) => void;
+}
+export declare abstract class MouseInputEntity extends AppObjectEntity {
+    static readonly type = "MouseInputEntity";
+    abstract get eventElement(): HTMLElement | undefined;
+    abstract setEventElement(eventElement: HTMLElement): void;
+    abstract clearInputElement(): void;
+    abstract registerController(controller: MouseController): void;
+    abstract removeController(controller: MouseController): void;
+    static get(appObjects: AppObjectRepo): MouseInputEntity | undefined;
+}
+export declare function makeMouseInput(appObject: AppObject): MouseInputEntity;

package/lib/AppObjectComponents/MouseInput/Entities/MouseInput.js

@@ -0,0 +1,196 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMouseInput = exports.MouseInputEntity = void 0;
+const AppObjectEntity_1 = require("../../../AppObject/AppObjectEntity");
+const ValueObjects_1 = require("../../../ValueObjects");
+class MouseInputEntity extends AppObjectEntity_1.AppObjectEntity {
+    static get(appObjects) {
+        const components = appObjects.getAllComponents(MouseInputEntity.type);
+        if (components.length === 0) {
+            console.warn(`Unable to find component ${MouseInputEntity.type}. Add one on Mount`);
+            return undefined;
+        }
+        else if (components.length > 1) {
+            console.warn(`Multiple ${MouseInputEntity.type} found. There should only be one. Using the first one`);
+        }
+        return components[0];
+    }
+}
+exports.MouseInputEntity = MouseInputEntity;
+MouseInputEntity.type = "MouseInputEntity";
+function makeMouseInput(appObject) {
+    return new MouseInputEntityImp(appObject);
+}
+exports.makeMouseInput = makeMouseInput;
+class MouseInputEntityImp extends MouseInputEntity {
+    constructor(appObject) {
+        super(appObject, MouseInputEntity.type);
+        this.controllers = [];
+        this.maxClickMovement = 5; // pixels
+        this.isPressed = false;
+        this.initialClickTime = 0;
+        this.initialClickPos = ValueObjects_1.Vector2.Zero();
+        this.clickCount = 0;
+        this.maxDoubleClickTimeMS = 300;
+        this.maxDoubleClickDistancePx = 5;
+        this._eventElement = undefined;
+        this.setEventElement = (eventElement) => {
+            if (this._eventElement)
+                this.clearInputElement();
+            eventElement.addEventListener("mousedown", this.onMouseDown, false);
+            eventElement.addEventListener("mouseup", this.onMouseUp, false);
+            eventElement.addEventListener("mousemove", this.onMouseMove, false);
+            eventElement.addEventListener("mouseout", this.onMouseOut, false);
+            eventElement.addEventListener("wheel", this.onWheel, false);
+            this._eventElement = eventElement;
+        };
+        this.clearInputElement = () => {
+            if (!this._eventElement)
+                return;
+            this._eventElement.removeEventListener("mousedown", this.onMouseDown);
+            this._eventElement.removeEventListener("mouseup", this.onMouseUp);
+            this._eventElement.removeEventListener("mousemove", this.onMouseMove);
+            this._eventElement.removeEventListener("mouseout", this.onMouseOut);
+            this._eventElement.removeEventListener("wheel", this.onWheel);
+            this._eventElement = undefined;
+        };
+        this.registerController = (controller) => {
+            this.controllers.push(controller);
+        };
+        this.removeController = (controller) => {
+            const index = this.controllers.indexOf(controller);
+            if (index >= 0) {
+                this.controllers.splice(index, 1);
+            }
+        };
+        this.onMouseDown = (e) => {
+            const inputEvt = this.makeMouseInputEvent(e);
+            this.controllers.forEach((c) => {
+                if (c.onDown) {
+                    c.onDown(inputEvt);
+                }
+            });
+            this.isPressed = true;
+            this.pressEvent = e;
+            if (this.clickCount === 0)
+                return;
+            const movement = ValueObjects_1.Vector2.Subtract(this.initialClickPos, inputEvt.position)
+                .magnitued;
+            const passedTime = Date.now() - this.initialClickTime;
+            if (passedTime > this.maxDoubleClickTimeMS ||
+                movement > this.maxDoubleClickDistancePx) {
+                this.clickCount = 0;
+            }
+        };
+        this.onMouseUp = (e) => {
+            const inputEvt = this.makeMouseInputEvent(e);
+            this.controllers.forEach((c) => {
+                if (c.onUp) {
+                    c.onUp(inputEvt);
+                }
+            });
+            this.isPressed = false;
+            if (!this.pressEvent)
+                return;
+            const deltaX = this.pressEvent.screenX - e.screenX;
+            const deltaY = this.pressEvent.screenY - e.screenY;
+            const delta = new ValueObjects_1.Vector2(deltaX, deltaY);
+            if (delta.magnitued < this.maxClickMovement) {
+                this.controllers.forEach((c) => {
+                    if (c.onClick) {
+                        c.onClick(inputEvt);
+                    }
+                });
+                this.clickCount += 1;
+            }
+            else {
+                this.cancelDoubleClick();
+                return;
+            }
+            if (this.clickCount === 1) {
+                this.initialClickTime = Date.now();
+                this.initialClickPos = new ValueObjects_1.Vector2(this.pressEvent.screenX, this.pressEvent.screenY);
+            }
+            else if (this.clickCount === 2) {
+                const currentPos = new ValueObjects_1.Vector2(this.pressEvent.screenX, this.pressEvent.screenY);
+                let movement = ValueObjects_1.Vector2.Subtract(this.initialClickPos, currentPos)
+                    .magnitued;
+                if (movement === NaN)
+                    movement = 0;
+                const passedTime = Date.now() - this.initialClickTime;
+                if (passedTime <= this.maxDoubleClickTimeMS &&
+                    movement <= this.maxDoubleClickDistancePx) {
+                    this.controllers.forEach((c) => {
+                        if (c.onDoubleClick) {
+                            c.onDoubleClick(inputEvt);
+                        }
+                    });
+                    this.cancelDoubleClick();
+                }
+            }
+            this.pressEvent = undefined;
+        };
+        this.cancelDoubleClick = () => {
+            this.initialClickPos = ValueObjects_1.Vector2.Zero();
+            this.initialClickTime = 0;
+            this.clickCount = 0;
+        };
+        this.onMouseMove = (e) => {
+            const inputEvt = this.makeMouseInputEvent(e);
+            this.controllers.forEach((c) => {
+                if (c.onMove) {
+                    c.onMove(inputEvt);
+                }
+            });
+            if (!this.pressEvent)
+                return;
+            const deltaX = this.pressEvent.screenX - e.screenX;
+            const deltaY = this.pressEvent.screenY - e.screenY;
+            const delta = new ValueObjects_1.Vector2(deltaX, deltaY);
+            if (delta.magnitued > this.maxClickMovement) {
+                this.pressEvent = undefined;
+            }
+        };
+        this.onMouseOut = (e) => {
+            this.cancelDoubleClick();
+            if (!this.isPressed)
+                return;
+            const inputEvt = this.makeMouseInputEvent(e);
+            this.controllers.forEach((c) => {
+                if (c.onUp) {
+                    c.onUp(inputEvt);
+                }
+            });
+            this.pressEvent = undefined;
+            this.isPressed = false;
+        };
+        this.onWheel = (e) => {
+            e.preventDefault();
+            const px = e.offsetX;
+            const py = e.offsetY;
+            const button = e.button;
+            const inputEvt = {
+                position: new ValueObjects_1.Vector2(px, py),
+                event: e,
+            };
+            this.controllers.forEach((c) => {
+                if (c.onWheel) {
+                    c.onWheel(inputEvt);
+                }
+            });
+        };
+    }
+    get eventElement() {
+        return this._eventElement;
+    }
+    makeMouseInputEvent(event) {
+        const px = event.offsetX;
+        const py = event.offsetY;
+        const button = event.button;
+        return {
+            position: new ValueObjects_1.Vector2(px, py),
+            button,
+            event,
+        };
+    }
+}

package/lib/AppObjectComponents/MouseInput/Mocks/MockMouseInput.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="jest" />
+import { AppObject } from "../../../AppObject/AppObject";
+import { MouseInputEntity } from "../Entities/MouseInput";
+export declare class MockMouseInput extends MouseInputEntity {
+    get eventElement(): HTMLElement | undefined;
+    setEventElement: jest.Mock<any, any>;
+    clearInputElement: jest.Mock<any, any>;
+    registerController: jest.Mock<any, any>;
+    removeController: jest.Mock<any, any>;
+    isKeyPressed: jest.Mock<any, any>;
+    constructor(appObject: AppObject);
+}

package/lib/AppObjectComponents/MouseInput/Mocks/MockMouseInput.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockMouseInput = void 0;
+const MouseInput_1 = require("../Entities/MouseInput");
+class MockMouseInput extends MouseInput_1.MouseInputEntity {
+    constructor(appObject) {
+        super(appObject, MouseInput_1.MouseInputEntity.type);
+        this.setEventElement = jest.fn();
+        this.clearInputElement = jest.fn();
+        this.registerController = jest.fn();
+        this.removeController = jest.fn();
+        this.isKeyPressed = jest.fn();
+    }
+    get eventElement() {
+        throw new Error("Method not implemented.");
+    }
+}
+exports.MockMouseInput = MockMouseInput;

package/lib/AppObjectComponents/MouseInput/index.d.ts

@@ -0,0 +1 @@
+export * from "./Entities/MouseInput";

package/lib/{UseCases/SceneObjects → AppObjectComponents/MouseInput}/index.js

@@ -10,4 +10,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./PeelSceneObject"), exports);
+__exportStar(require("./Entities/MouseInput"), exports);

package/lib/AppObjectComponents/Question/Controllers/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./setAnswerFeedback";
+export * from "./setAnswerText";
+export * from "./submitQuestionAnswer";
+export * from "./toggleAnswerIsCorrect";

package/lib/{UseCases/SceneModel → AppObjectComponents/Question/Controllers}/index.js

@@ -10,8 +10,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./modelDataLoader"), exports);
-__exportStar(require("./loadNewModel"), exports);
-__exportStar(require("./SerializeActiveModel"), exports);
-__exportStar(require("./SetMeshesEnabledHook"), exports);
-__exportStar(require("./SetSceneModelMeshOverlayColor"), exports);
+__exportStar(require("./setAnswerFeedback"), exports);
+__exportStar(require("./setAnswerText"), exports);
+__exportStar(require("./submitQuestionAnswer"), exports);
+__exportStar(require("./toggleAnswerIsCorrect"), exports);

package/lib/AppObjectComponents/Question/Controllers/setAnswerFeedback.d.ts

@@ -0,0 +1,2 @@
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+export declare function setAnswerFeedback(answerID: string, feedback: string, appObjects: AppObjectRepo): void;

package/lib/AppObjectComponents/Question/Controllers/setAnswerFeedback.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setAnswerFeedback = void 0;
+const App_1 = require("../../App");
+const QuestionEntity_1 = require("../Entities/QuestionEntity");
+const SetAnswerFeedbackUC_1 = require("../UseCases/SetAnswerFeedbackUC");
+function setAnswerFeedback(answerID, feedback, appObjects) {
+    const questionEntity = QuestionEntity_1.QuestionEntity.get(appObjects);
+    if (!questionEntity) {
+        App_1.submitWarning("setAnswerFeedback", "Can't find QuestionEntity", appObjects);
+        return;
+    }
+    const answer = questionEntity.getAnswer(answerID);
+    if (!answer) {
+        App_1.submitWarning("setAnswerFeedback", "Can't find Answer by ID", appObjects);
+        return;
+    }
+    const uc = answer.appObject.getComponent(SetAnswerFeedbackUC_1.SetAnswerFeedbackUC.type);
+    if (!uc) {
+        App_1.submitWarning("setAnswerFeedback", "Can't find SetAnswerFeedbackUC on Answer", appObjects);
+        return;
+    }
+    uc.setFeedback(feedback);
+}
+exports.setAnswerFeedback = setAnswerFeedback;