@vived/app 3.9.1 → 4.0.0

package/lib/Components/MouseInput/Entities/MouseInput.js

@@ -0,0 +1,188 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMouseInput = exports.MouseInputEntity = void 0;
+const AppObject_1 = require("../../../AppObject");
+const AppObjectEntity_1 = require("../../../AppObject/AppObjectEntity");
+const ValueObjects_1 = require("../../../ValueObjects");
+class MouseInputEntity extends AppObjectEntity_1.AppObjectEntity {
+}
+exports.MouseInputEntity = MouseInputEntity;
+MouseInputEntity.type = "MouseInputEntity";
+MouseInputEntity.get = (appObjects) => AppObject_1.getSingletonComponent(MouseInputEntity.type, appObjects);
+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 (isNaN(movement)) {
+                    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/Components/MouseInput/Entities/index.d.ts

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

package/lib/Components/MouseInput/Entities/index.js

@@ -0,0 +1,13 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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("./MouseInput"), exports);

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

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

package/lib/Components/MouseInput/index.js

@@ -0,0 +1,13 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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("./Entities"), exports);

package/lib/Components/OverlayColor/Entities/index.d.ts

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

package/lib/Components/OverlayColor/Entities/index.js

@@ -0,0 +1,13 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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("./OverlayColor"), exports);

package/lib/Components/OverlayColor/PM/OverlayColorPM.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OverlayColorPM = void 0;
+const AppObjectPM_1 = require("../../../AppObject/AppObjectPM");
+const OverlayColor_1 = require("../Entities/OverlayColor");
+class OverlayColorPM extends AppObjectPM_1.AppObjectPM {
+    constructor(appObject) {
+        super(appObject, OverlayColorPM.type);
+        this.onColorChange = () => {
+            if (!this.overlayColor)
+                return;
+            this.doUpdateView(this.overlayColor.overlayColor);
+        };
+        this.dispose = () => {
+            var _a, _b;
+            super.dispose();
+            (_a = this.overlayColor) === null || _a === void 0 ? void 0 : _a.removeChangeObserver(this.onColorChange);
+            (_b = this.overlayColor) === null || _b === void 0 ? void 0 : _b.removeOnDisposeObserver(this.dispose);
+        };
+        this.overlayColor = OverlayColor_1.OverlayColor.get(appObject);
+        if (!this.overlayColor) {
+            this.warn("[OverlayColorPM] Unable to find OverlayColor Entity");
+            return;
+        }
+        else {
+            this.overlayColor.addChangeObserver(this.onColorChange);
+            this.overlayColor.addOnDisposeObserver(this.dispose);
+            this.onColorChange();
+        }
+    }
+    vmsAreEqual(a, b) {
+        return a === b;
+    }
+    static getForID(appObjID, appObjects) {
+        const appObj = appObjects.get(appObjID);
+        if (appObj === undefined) {
+            return undefined;
+        }
+        return appObj.getComponent(OverlayColorPM.type);
+    }
+}
+exports.OverlayColorPM = OverlayColorPM;
+OverlayColorPM.type = "OverlayColorPM";

package/lib/Components/OverlayColor/PM/index.d.ts

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

package/lib/Components/OverlayColor/PM/index.js

@@ -0,0 +1,13 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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("./OverlayColorPM"), exports);

package/lib/Components/OverlayColor/index.d.ts

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

package/lib/Components/OverlayColor/index.js

@@ -0,0 +1,14 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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("./Entities"), exports);
+__exportStar(require("./PM"), exports);

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

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

package/lib/Components/Question/Controllers/setAnswerText.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setAnswerText = void 0;
+const QuestionEntity_1 = require("../Entities/QuestionEntity");
+const SetAnswerTextUC_1 = require("../UC/SetAnswerTextUC");
+function setAnswerText(answerID, text, appObjects) {
+    const questionEntity = QuestionEntity_1.QuestionEntity.get(appObjects);
+    if (!questionEntity) {
+        appObjects.submitWarning("setAnswerText", "Can't find QuestionEntity");
+        return;
+    }
+    const answer = questionEntity.getAnswer(answerID);
+    if (!answer) {
+        appObjects.submitWarning("setAnswerText", "Can't find Answer by ID");
+        return;
+    }
+    const uc = answer.appObject.getComponent(SetAnswerTextUC_1.SetAnswerTextUC.type);
+    if (!uc) {
+        appObjects.submitWarning("setAnswerText", "Can't find SetAnswerTextUC on Answer");
+        return;
+    }
+    uc.setText(text);
+}
+exports.setAnswerText = setAnswerText;

package/lib/Components/Question/Controllers/submitQuestionAnswer.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.submitQuestionAnswer = void 0;
+const UC_1 = require("../UC");
+function submitQuestionAnswer(answerID, appObjects) {
+    const submitUC = UC_1.SubmitQuestionAnswerUC.get(appObjects);
+    if (!submitUC) {
+        appObjects.submitWarning("submitQuestionAnswer", "Can't find SubmitQuestionAnswerUC");
+        return;
+    }
+    submitUC.submitAnswer(answerID);
+}
+exports.submitQuestionAnswer = submitQuestionAnswer;

package/lib/Components/Question/Controllers/toggleAnswerIsCorrect.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toggleAnswerIsCorrect = void 0;
+const QuestionEntity_1 = require("../Entities/QuestionEntity");
+const ToggleQuestionAnswerIsCorrect_1 = require("../UC/ToggleQuestionAnswerIsCorrect");
+function toggleAnswerIsCorrect(answerID, appObjects) {
+    const questionEntity = QuestionEntity_1.QuestionEntity.get(appObjects);
+    if (!questionEntity) {
+        appObjects.submitWarning("toggleAnswerIsCorrect", "Can't find QuestionEntity");
+        return;
+    }
+    const answer = questionEntity.getAnswer(answerID);
+    if (!answer) {
+        appObjects.submitWarning("toggleAnswerIsCorrect", "Can't find Answer by ID");
+        return;
+    }
+    const uc = answer.appObject.getComponent(ToggleQuestionAnswerIsCorrect_1.ToggleQuestionChallengeAnswerIsCorrectUC.type);
+    if (!uc) {
+        appObjects.submitWarning("toggleAnswerIsCorrect", "Can't find ToggleQuestionChallengeAnswerIsCorrectUC on Answer");
+        return;
+    }
+    uc.toggleIsCorrect();
+}
+exports.toggleAnswerIsCorrect = toggleAnswerIsCorrect;

package/lib/Components/Question/Entities/QuestionEntity.d.ts

@@ -0,0 +1,25 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectEntity } from "../../../AppObject/AppObjectEntity";
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+import { QuestionAnswerEntity } from "./QuestionAnswerEntity";
+export declare const VALIDATION_NO_CORRECT = "At least one answer must be marked as correct";
+export declare const VALIDATION_NOT_ENOUGH_ANSWERS = "Question must have at least two answers";
+export declare abstract class QuestionEntity extends AppObjectEntity {
+    static readonly type = "QuestionEntity";
+    abstract get gotItRight(): boolean;
+    abstract get reviewFeedback(): string;
+    abstract addAnswer: (answer: QuestionAnswerEntity) => void;
+    abstract removeAnswer: (id: string) => void;
+    abstract getAnswer: (id: string) => QuestionAnswerEntity | undefined;
+    abstract getAllAnswers: () => QuestionAnswerEntity[];
+    abstract hasAnswer: (id: string) => boolean;
+    abstract createNewAnswer: () => QuestionAnswerEntity;
+    abstract removeAllAnswers: () => void;
+    abstract reset: () => void;
+    abstract submitAnswer: (id: string) => void;
+    abstract setDefaultState: () => void;
+    abstract answerFactory: (id?: string) => QuestionAnswerEntity;
+    abstract get validationMessage(): string | undefined;
+    static get: (appObjects: AppObjectRepo) => QuestionEntity | undefined;
+}
+export declare function makeQuestionEntity(appObject: AppObject): QuestionEntity;

package/lib/Components/Question/Entities/QuestionEntity.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeQuestionEntity = exports.QuestionEntity = exports.VALIDATION_NOT_ENOUGH_ANSWERS = exports.VALIDATION_NO_CORRECT = void 0;
+const AppObject_1 = require("../../../AppObject");
+const AppObjectEntity_1 = require("../../../AppObject/AppObjectEntity");
+exports.VALIDATION_NO_CORRECT = "At least one answer must be marked as correct";
+exports.VALIDATION_NOT_ENOUGH_ANSWERS = "Question must have at least two answers";
+class QuestionEntity extends AppObjectEntity_1.AppObjectEntity {
+}
+exports.QuestionEntity = QuestionEntity;
+QuestionEntity.type = "QuestionEntity";
+QuestionEntity.get = (appObjects) => AppObject_1.getSingletonComponent(QuestionEntity.type, appObjects);
+function makeQuestionEntity(appObject) {
+    return new QuestionChallengeImp(appObject);
+}
+exports.makeQuestionEntity = makeQuestionEntity;
+class QuestionChallengeImp extends QuestionEntity {
+    constructor(appObject) {
+        super(appObject, QuestionEntity.type);
+        this.answerLookup = new Map();
+        this._gotItRight = false;
+        this._reviewFeedback = "";
+        this.addAnswer = (answer) => {
+            this.answerLookup.set(answer.id, answer);
+            this.reset();
+            answer.addChangeObserver(this.notifyOnChange);
+        };
+        this.removeAnswer = (id) => {
+            const ans = this.answerLookup.get(id);
+            if (!ans)
+                return;
+            ans.removeChangeObserver(this.notifyOnChange);
+            this.answerLookup.delete(id);
+            ans.appObject.dispose();
+            this.reset();
+        };
+        this.getAnswer = (id) => {
+            return this.answerLookup.get(id);
+        };
+        this.getAllAnswers = () => {
+            return Array.from(this.answerLookup.values());
+        };
+        this.hasAnswer = (id) => {
+            return this.answerLookup.has(id);
+        };
+        this.reset = () => {
+            this._gotItRight = false;
+            this._reviewFeedback = "";
+            this.notifyOnChange();
+        };
+        this.submitAnswer = (id) => {
+            const ans = this.getAnswer(id);
+            if (!ans) {
+                this.warn(`Unable to find answer by ID:  ${id}`);
+                return;
+            }
+            this._gotItRight = ans.isCorrect;
+            if (ans.feedbackText) {
+                this._reviewFeedback = ans.feedbackText;
+            }
+            else {
+                this._reviewFeedback = ans.isCorrect ? "Correct" : "Incorrect";
+            }
+            this.notifyOnChange();
+        };
+        this.createNewAnswer = () => {
+            const answer = this.answerFactory();
+            this.addAnswer(answer);
+            return answer;
+        };
+        this.removeAllAnswers = () => {
+            const allAnswers = Array.from(this.answerLookup.keys());
+            allAnswers.forEach((id) => this.removeAnswer(id));
+            this.reset();
+        };
+        this.setDefaultState = () => {
+            this.removeAllAnswers();
+            const trueAnswer = this.createNewAnswer();
+            trueAnswer.isCorrect = true;
+            trueAnswer.text = "True";
+            const falseAnswer = this.createNewAnswer();
+            falseAnswer.text = "False";
+            this.reset();
+        };
+        this.answerFactory = (id) => {
+            throw new Error("Factory has not been injected");
+        };
+    }
+    get gotItRight() {
+        return this._gotItRight;
+    }
+    get reviewFeedback() {
+        return this._reviewFeedback;
+    }
+    get validationMessage() {
+        if (this.answerLookup.size < 2) {
+            return exports.VALIDATION_NOT_ENOUGH_ANSWERS;
+        }
+        let hasCorrect = false;
+        let answerValidationMsg;
+        this.answerLookup.forEach((ans) => {
+            if (ans.isCorrect) {
+                hasCorrect = true;
+            }
+            if (ans.textValidationMessage) {
+                answerValidationMsg = ans.textValidationMessage;
+            }
+            if (ans.feedbackValidationMessage) {
+                answerValidationMsg = ans.feedbackValidationMessage;
+            }
+        });
+        if (!hasCorrect) {
+            return exports.VALIDATION_NO_CORRECT;
+        }
+        return answerValidationMsg;
+    }
+}

package/lib/Components/Question/PM/QuestionAnswerPM.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuestionAnswerPM = exports.defaultQuestionChallengeAnswerVM = void 0;
+const AppObjectPM_1 = require("../../../AppObject/AppObjectPM");
+const QuestionAnswerEntity_1 = require("../Entities/QuestionAnswerEntity");
+exports.defaultQuestionChallengeAnswerVM = {
+    answerText: "",
+    feedbackText: "",
+    isCorrect: false,
+};
+class QuestionAnswerPM extends AppObjectPM_1.AppObjectPM {
+    constructor(appObject) {
+        super(appObject, QuestionAnswerPM.type);
+        this.dispose = () => {
+            var _a;
+            super.dispose();
+            (_a = this.answer) === null || _a === void 0 ? void 0 : _a.removeChangeObserver(this.onAnswerChange);
+        };
+        this.onAnswerChange = () => {
+            if (!this.answer)
+                return;
+            const { feedbackText, text, isCorrect, feedbackValidationMessage, textValidationMessage, } = this.answer;
+            const vm = {
+                answerText: text,
+                feedbackText,
+                isCorrect,
+                feedbackValidation: feedbackValidationMessage,
+                textValidation: textValidationMessage,
+            };
+            this.doUpdateView(vm);
+        };
+        this.answer = appObject.getComponent(QuestionAnswerEntity_1.QuestionAnswerEntity.type);
+        if (this.answer) {
+            this.answer.addChangeObserver(this.onAnswerChange);
+            this.onAnswerChange();
+        }
+        else {
+            this.warn("QuestionAnswerPM has been added to an app object that does not have QuestionAnswerEntity");
+        }
+    }
+    static get(appObject) {
+        return appObject.getComponent(QuestionAnswerPM.type);
+    }
+    vmsAreEqual(a, b) {
+        if (a.answerText !== b.answerText)
+            return false;
+        if (a.feedbackText !== b.feedbackText)
+            return false;
+        if (a.isCorrect !== b.isCorrect)
+            return false;
+        if (a.textValidation !== b.textValidation)
+            return false;
+        if (a.feedbackValidation !== b.feedbackValidation)
+            return false;
+        return true;
+    }
+}
+exports.QuestionAnswerPM = QuestionAnswerPM;
+QuestionAnswerPM.type = "QuestionAnswerPM";

package/lib/Components/Question/PM/QuestionChallengePM.d.ts

@@ -0,0 +1,19 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectPM } from "../../../AppObject/AppObjectPM";
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+export declare const defaultQuestionChallengeVM: QuestionChallengeVM;
+export interface QuestionChallengeVM {
+    gotItRight: boolean;
+    answerIds: string[];
+    reviewFeedback: string;
+    validationMessage?: string;
+}
+export declare class QuestionChallengePM extends AppObjectPM<QuestionChallengeVM> {
+    static readonly type = "QuestionChallengePM";
+    static get: (appObjects: AppObjectRepo) => QuestionChallengePM | undefined;
+    private questionEntity?;
+    private onEntityChange;
+    vmsAreEqual(a: QuestionChallengeVM, b: QuestionChallengeVM): boolean;
+    dispose: () => void;
+    constructor(appObject: AppObject);
+}