@vived/app 3.8.0 → 3.9.1

package/lib/AppObjectComponents/Question/Factories/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("./setupQuestionAnswer"), exports);
+__exportStar(require("./setupQuestionChallenge"), exports);

package/lib/AppObjectComponents/Question/Factories/setupQuestionAnswer.d.ts

@@ -0,0 +1,3 @@
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+import { QuestionAnswerEntity } from "../Entities/QuestionAnswerEntity";
+export declare function setupQuestionAnswer(appObjects: AppObjectRepo, id?: string): QuestionAnswerEntity;

package/lib/AppObjectComponents/Question/Factories/setupQuestionAnswer.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupQuestionAnswer = void 0;
+const Utilities_1 = require("../../../Utilities");
+const QuestionAnswerEntity_1 = require("../Entities/QuestionAnswerEntity");
+const QuestionAnswerPM_1 = require("../PresentationManagers/QuestionAnswerPM");
+const SetAnswerFeedbackUC_1 = require("../UseCases/SetAnswerFeedbackUC");
+const SetAnswerTextUC_1 = require("../UseCases/SetAnswerTextUC");
+const ToggleQuestionAnswerIsCorrect_1 = require("../UseCases/ToggleQuestionAnswerIsCorrect");
+function setupQuestionAnswer(appObjects, id) {
+    let idToUse = id !== null && id !== void 0 ? id : Utilities_1.generateUniqueID();
+    const ao = appObjects.getOrCreate(idToUse);
+    const answerEntity = QuestionAnswerEntity_1.makeQuestionAnswerEntity(ao);
+    SetAnswerFeedbackUC_1.makeSetAnswerFeedbackUC(ao);
+    SetAnswerTextUC_1.makeSetAnswerTextUC(ao);
+    ToggleQuestionAnswerIsCorrect_1.makeToggleQuesionChallengeAnswerIsCorrectUC(ao);
+    new QuestionAnswerPM_1.QuestionAnswerPM(ao);
+    return answerEntity;
+}
+exports.setupQuestionAnswer = setupQuestionAnswer;

package/lib/AppObjectComponents/Question/Factories/setupQuestionChallenge.d.ts

@@ -0,0 +1,3 @@
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+import { QuestionEntity } from "../Entities/QuestionEntity";
+export declare function setupQuestionChallenge(appObjects: AppObjectRepo): QuestionEntity;

package/lib/AppObjectComponents/Question/Factories/setupQuestionChallenge.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupQuestionChallenge = void 0;
+const QuestionEntity_1 = require("../Entities/QuestionEntity");
+const QuestionChallengePM_1 = require("../PresentationManagers/QuestionChallengePM");
+const UseCases_1 = require("../UseCases");
+const AddQuestionAnswerUC_1 = require("../UseCases/AddQuestionAnswerUC");
+const DeleteQuestionAnswerUC_1 = require("../UseCases/DeleteQuestionAnswerUC");
+const SerializeQuestionChallenge_1 = require("../UseCases/SerializeQuestionChallenge");
+const setupQuestionAnswer_1 = require("./setupQuestionAnswer");
+function setupQuestionChallenge(appObjects) {
+    const ao = appObjects.getOrCreate("QuestionChallenge");
+    const questionEntity = QuestionEntity_1.makeQuestionEntity(ao);
+    AddQuestionAnswerUC_1.makeAddQuestionAnswerUC(ao);
+    DeleteQuestionAnswerUC_1.makeDeleteQuestionAnswerUC(ao);
+    UseCases_1.makeSubmitQuestionAnswerUC(ao);
+    const serializer = new SerializeQuestionChallenge_1.SerializeQuestionChallenge(ao);
+    serializer.setupQuestionAnswer = setupQuestionAnswer_1.setupQuestionAnswer;
+    new QuestionChallengePM_1.QuestionChallengePM(ao);
+    return questionEntity;
+}
+exports.setupQuestionChallenge = setupQuestionChallenge;

package/lib/AppObjectComponents/Question/Mocks/MockQuestionAnswerEntity.d.ts

@@ -0,0 +1,12 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { QuestionAnswerEntity } from "../Entities/QuestionAnswerEntity";
+export declare class MockQuestionAnswerEntity extends QuestionAnswerEntity {
+    id: string;
+    text: string;
+    get textValidationMessage(): undefined;
+    isCorrect: boolean;
+    feedbackText: string;
+    showFeedback: boolean;
+    get feedbackValidationMessage(): undefined;
+    constructor(appObject: AppObject);
+}

package/lib/AppObjectComponents/Question/Mocks/MockQuestionAnswerEntity.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockQuestionAnswerEntity = void 0;
+const QuestionAnswerEntity_1 = require("../Entities/QuestionAnswerEntity");
+class MockQuestionAnswerEntity extends QuestionAnswerEntity_1.QuestionAnswerEntity {
+    constructor(appObject) {
+        super(appObject, QuestionAnswerEntity_1.QuestionAnswerEntity.type);
+        this.id = "answerID";
+        this.text = "Answer Text";
+        this.isCorrect = true;
+        this.feedbackText = "Answer Feedback";
+        this.showFeedback = false;
+    }
+    get textValidationMessage() {
+        return undefined;
+    }
+    get feedbackValidationMessage() {
+        return undefined;
+    }
+}
+exports.MockQuestionAnswerEntity = MockQuestionAnswerEntity;

package/lib/AppObjectComponents/Question/PresentationManagers/QuestionAnswerPM.d.ts

@@ -0,0 +1,19 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectPM } from "../../../AppObject/AppObjectPM";
+export declare const defaultQuestionChallengeAnswerVM: QuestionAnswerVM;
+export interface QuestionAnswerVM {
+    answerText: string;
+    feedbackText: string;
+    isCorrect: boolean;
+    textValidation?: string;
+    feedbackValidation?: string;
+}
+export declare class QuestionAnswerPM extends AppObjectPM<QuestionAnswerVM> {
+    static readonly type = "QuestionAnswerPM";
+    static get(appObject: AppObject): QuestionAnswerPM | undefined;
+    private answer?;
+    vmsAreEqual(a: QuestionAnswerVM, b: QuestionAnswerVM): boolean;
+    dispose: () => void;
+    private onAnswerChange;
+    constructor(appObject: AppObject);
+}

package/lib/AppObjectComponents/Question/PresentationManagers/QuestionAnswerPM.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuestionAnswerPM = exports.defaultQuestionChallengeAnswerVM = void 0;
+const AppObjectPM_1 = require("../../../AppObject/AppObjectPM");
+const App_1 = require("../../App");
+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: 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 {
+            App_1.submitWarning("QuestionAnswerPM", "QuestionAnswerPM has been added to an app object that does not have QuestionAnswerEntity", appObject.appObjectRepo);
+        }
+    }
+    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/AppObjectComponents/Question/PresentationManagers/QuestionChallengeAnswerPM.d.ts

@@ -0,0 +1,20 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectPM } from "../../../AppObject/AppObjectPM";
+export declare const defaultQestionChallengeAnswerVM: QuestionAnswerVM;
+export interface QuestionAnswerVM {
+    answerText: string;
+    feedbackText: string;
+    feedbackToShow: string;
+    isCorrect: boolean;
+    textValidation: string | null;
+    feedbackValidation: string | null;
+}
+export declare class QuestionAnswerPM extends AppObjectPM<QuestionAnswerVM> {
+    static readonly type = "QuestionAnswerPM";
+    static get(appObject: AppObject): QuestionAnswerPM | undefined;
+    private answer?;
+    vmsAreEqual(a: QuestionAnswerVM, b: QuestionAnswerVM): boolean;
+    dispose: () => void;
+    private onAnswerChange;
+    constructor(appObject: AppObject);
+}

package/lib/AppObjectComponents/Question/PresentationManagers/QuestionChallengeAnswerPM.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuestionAnswerPM = exports.defaultQestionChallengeAnswerVM = void 0;
+const AppObjectPM_1 = require("../../../AppObject/AppObjectPM");
+const App_1 = require("../../App");
+const QuestionAnswerEntity_1 = require("../Entities/QuestionAnswerEntity");
+exports.defaultQestionChallengeAnswerVM = {
+    answerText: "",
+    feedbackToShow: "",
+    feedbackText: "",
+    isCorrect: false,
+    feedbackValidation: null,
+    textValidation: null,
+};
+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;
+            let feedbackToShow = feedbackText;
+            if (!feedbackText) {
+                feedbackToShow = isCorrect ? "Correct" : "Incorrect";
+            }
+            const vm = {
+                answerText: text,
+                feedbackText: feedbackText,
+                feedbackToShow,
+                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 {
+            App_1.submitWarning("QuestionAnswerPM", "QuestionAnswerPM has been added to an app object that does not have QuestionAnswerEntity", appObject.appObjectRepo);
+        }
+    }
+    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.feedbackToShow !== b.feedbackToShow)
+            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/AppObjectComponents/Question/PresentationManagers/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);
+}

package/lib/AppObjectComponents/Question/PresentationManagers/QuestionChallengePM.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuestionChallengePM = exports.defaultQuestionChallengeVM = void 0;
+const AppObjectPM_1 = require("../../../AppObject/AppObjectPM");
+const App_1 = require("../../App");
+const QuestionEntity_1 = require("../Entities/QuestionEntity");
+exports.defaultQuestionChallengeVM = {
+    answerIds: [],
+    gotItRight: false,
+    reviewFeedback: "",
+};
+class QuestionChallengePM extends AppObjectPM_1.AppObjectPM {
+    constructor(appObject) {
+        super(appObject, QuestionChallengePM.type);
+        this.onEntityChange = () => {
+            if (!this.questionEntity)
+                return;
+            const { gotItRight } = this.questionEntity;
+            const answerIds = this.questionEntity.getAllAnswers().map((ans) => ans.id);
+            const vm = {
+                gotItRight,
+                answerIds,
+                reviewFeedback: this.questionEntity.reviewFeedback,
+                validationMessage: this.questionEntity.validationMessage,
+            };
+            this.doUpdateView(vm);
+        };
+        this.dispose = () => {
+            var _a;
+            super.dispose();
+            (_a = this.questionEntity) === null || _a === void 0 ? void 0 : _a.removeChangeObserver(this.onEntityChange);
+        };
+        this.questionEntity = appObject.getComponent(QuestionEntity_1.QuestionEntity.type);
+        if (this.questionEntity) {
+            this.questionEntity.addChangeObserver(this.onEntityChange);
+            this.onEntityChange();
+        }
+        else {
+            App_1.submitWarning("QuestionChallengePM", "QuestionChallengePM has been added to an app object that does not have QuestionEntity", appObject.appObjectRepo);
+        }
+    }
+    static get(appObjects) {
+        const components = appObjects.getAllComponents(QuestionChallengePM.type);
+        if (components.length === 0) {
+            App_1.submitWarning("QuestionChallengePM", `Unable to find component ${QuestionChallengePM.type}. Add one on Mount`, appObjects);
+            return undefined;
+        }
+        else if (components.length > 1) {
+            App_1.submitWarning("QuestionChallengePM", `Multiple ${QuestionChallengePM.type} found. There should only be one. Using the first one`, appObjects);
+        }
+        return components[0];
+    }
+    vmsAreEqual(a, b) {
+        if (a.gotItRight !== b.gotItRight)
+            return false;
+        if (a.validationMessage !== b.validationMessage)
+            return false;
+        if (a.reviewFeedback !== b.reviewFeedback)
+            return false;
+        if (a.answerIds.length !== b.answerIds.length)
+            return false;
+        let idsMatch = true;
+        a.answerIds.forEach((_, i) => {
+            if (a.answerIds[i] !== b.answerIds[i])
+                idsMatch = false;
+        });
+        return idsMatch;
+    }
+}
+exports.QuestionChallengePM = QuestionChallengePM;
+QuestionChallengePM.type = "QuestionChallengePM";

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

@@ -0,0 +1,2 @@
+export * from "./QuestionAnswerPM";
+export * from "./QuestionChallengePM";

package/lib/AppObjectComponents/Question/PresentationManagers/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("./QuestionAnswerPM"), exports);
+__exportStar(require("./QuestionChallengePM"), exports);

package/lib/AppObjectComponents/Question/UseCases/AddQuestionAnswerUC.d.ts

@@ -0,0 +1,10 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+export declare abstract class AddQuestionAnswerUC extends AppObjectUC {
+    static readonly type = "AddQuestionAnswerUC";
+    abstract addAnswer(): void;
+    static get(appObjects: AppObjectRepo): AddQuestionAnswerUC | undefined;
+}
+export declare function makeAddQuestionAnswerUC(appObject: AppObject): AddQuestionAnswerUC;
+export declare function addQuestionAnswer(appObjects: AppObjectRepo): void;

package/lib/AppObjectComponents/Question/UseCases/AddQuestionAnswerUC.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addQuestionAnswer = exports.makeAddQuestionAnswerUC = exports.AddQuestionAnswerUC = void 0;
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const App_1 = require("../../App");
+const Dispatcher_1 = require("../../Dispatcher");
+const QuestionEntity_1 = require("../Entities/QuestionEntity");
+class AddQuestionAnswerUC extends AppObjectUC_1.AppObjectUC {
+    static get(appObjects) {
+        const components = appObjects.getAllComponents(AddQuestionAnswerUC.type);
+        if (components.length === 0) {
+            App_1.submitWarning("AddQuestionAnswerUC", `Unable to find component ${AddQuestionAnswerUC.type}. Add one on Mount`, appObjects);
+            return undefined;
+        }
+        else if (components.length > 1) {
+            App_1.submitWarning("AddQuestionAnswerUC", `Multiple ${AddQuestionAnswerUC.type} found. There should only be one. Using the first one`, appObjects);
+        }
+        return components[0];
+    }
+}
+exports.AddQuestionAnswerUC = AddQuestionAnswerUC;
+AddQuestionAnswerUC.type = "AddQuestionAnswerUC";
+function makeAddQuestionAnswerUC(appObject) {
+    return new AddQuestionAnswerUCImp(appObject);
+}
+exports.makeAddQuestionAnswerUC = makeAddQuestionAnswerUC;
+function addQuestionAnswer(appObjects) {
+    const uc = AddQuestionAnswerUC.get(appObjects);
+    if (uc) {
+        uc.addAnswer();
+    }
+    else {
+        App_1.submitWarning("addQuestionAnswer", "Can't find AddQuestionAnswerUC", appObjects);
+    }
+}
+exports.addQuestionAnswer = addQuestionAnswer;
+class AddQuestionAnswerUCImp extends AddQuestionAnswerUC {
+    constructor(appObject) {
+        super(appObject, AddQuestionAnswerUC.type);
+        this.questionEntity = appObject.getComponent(QuestionEntity_1.QuestionEntity.type);
+        if (!this.questionEntity) {
+            App_1.submitWarning("AddAnswerUC", "AddAnswerUC has been added to an app object that does not have QuestionEntity", appObject.appObjectRepo);
+        }
+    }
+    addAnswer() {
+        var _a;
+        if (!this.questionEntity)
+            return;
+        this.questionEntity.createNewAnswer();
+        (_a = Dispatcher_1.DispatchStateChangeUC.get(this.appObject.appObjectRepo)) === null || _a === void 0 ? void 0 : _a.doDispatch();
+    }
+}

package/lib/AppObjectComponents/Question/UseCases/DeleteQuestionAnswerUC.d.ts

@@ -0,0 +1,10 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+export declare abstract class DeleteQuestionAnswerUC extends AppObjectUC {
+    static readonly type = "DeleteQuestionAnswerUC";
+    abstract deleteAnswer(id: string): void;
+    static get(appObjects: AppObjectRepo): DeleteQuestionAnswerUC | undefined;
+}
+export declare function makeDeleteQuestionAnswerUC(appObject: AppObject): DeleteQuestionAnswerUC;
+export declare function deleteQuestionAnswer(answerID: string, appObjects: AppObjectRepo): void;

package/lib/AppObjectComponents/Question/UseCases/DeleteQuestionAnswerUC.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteQuestionAnswer = exports.makeDeleteQuestionAnswerUC = exports.DeleteQuestionAnswerUC = void 0;
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const App_1 = require("../../App");
+const Dispatcher_1 = require("../../Dispatcher");
+const QuestionEntity_1 = require("../Entities/QuestionEntity");
+class DeleteQuestionAnswerUC extends AppObjectUC_1.AppObjectUC {
+    static get(appObjects) {
+        const components = appObjects.getAllComponents(DeleteQuestionAnswerUC.type);
+        if (components.length === 0) {
+            App_1.submitWarning("DeleteQuestionAnswerUC", `Unable to find component ${DeleteQuestionAnswerUC.type}. Add one on Mount`, appObjects);
+            return undefined;
+        }
+        else if (components.length > 1) {
+            App_1.submitWarning("DeleteQuestionAnswerUC", `Multiple ${DeleteQuestionAnswerUC.type} found. There should only be one. Using the first one`, appObjects);
+        }
+        return components[0];
+    }
+}
+exports.DeleteQuestionAnswerUC = DeleteQuestionAnswerUC;
+DeleteQuestionAnswerUC.type = "DeleteQuestionAnswerUC";
+function makeDeleteQuestionAnswerUC(appObject) {
+    return new DeleteQuestionAnswerUCImp(appObject);
+}
+exports.makeDeleteQuestionAnswerUC = makeDeleteQuestionAnswerUC;
+function deleteQuestionAnswer(answerID, appObjects) {
+    const uc = DeleteQuestionAnswerUC.get(appObjects);
+    if (uc) {
+        uc.deleteAnswer(answerID);
+    }
+    else {
+        App_1.submitWarning("deleteQuestionAnswer", "Can't find AddQuestionAnswerUC", appObjects);
+    }
+}
+exports.deleteQuestionAnswer = deleteQuestionAnswer;
+class DeleteQuestionAnswerUCImp extends DeleteQuestionAnswerUC {
+    constructor(appObject) {
+        super(appObject, DeleteQuestionAnswerUC.type);
+        this.questionEntity = appObject.getComponent(QuestionEntity_1.QuestionEntity.type);
+        if (!this.questionEntity) {
+            App_1.submitWarning("DeleteQuestionAnswerUCImp", "DeleteQuestionAnswerUCImp has been added to an app object that does not have QuestionEntity", appObject.appObjectRepo);
+        }
+    }
+    deleteAnswer(id) {
+        var _a;
+        if (!this.questionEntity)
+            return;
+        if (!this.questionEntity.hasAnswer(id))
+            return;
+        this.questionEntity.removeAnswer(id);
+        (_a = Dispatcher_1.DispatchStateChangeUC.get(this.appObject.appObjectRepo)) === null || _a === void 0 ? void 0 : _a.doDispatch();
+    }
+}

package/lib/AppObjectComponents/Question/UseCases/SerializeQuestionChallenge.d.ts

@@ -0,0 +1,35 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+import { SerializedSystem } from "../../StateMachine";
+import { QuestionAnswerEntity } from "../Entities/QuestionAnswerEntity";
+export declare class SerializeQuestionChallenge extends AppObjectUC implements SerializedSystem {
+    static readonly type = "SerializeQuestionChallenge";
+    name: string;
+    seriliziationVersion: number;
+    private questionEntity?;
+    setupQuestionAnswer: (appObjects: AppObjectRepo, id: string) => QuestionAnswerEntity;
+    getSystemState(): object;
+    applySystemState(state: object, version: number): void;
+    applyDefaultState(): void;
+    private mapV1ToV3;
+    private mapV2ToV3;
+    private applyDataV3;
+    constructor(appObject: AppObject);
+}
+export interface ChallengeDataV3 {
+    answers: AnswerDataV1[];
+}
+export interface ChallengeDataV2 {
+    questionText: string;
+    answers: AnswerDataV1[];
+}
+export interface ChallengeDataV1 {
+    answers: AnswerDataV1[];
+}
+export interface AnswerDataV1 {
+    id: string;
+    text: string;
+    feedback: string;
+    isCorrect: boolean;
+}

package/lib/AppObjectComponents/Question/UseCases/SerializeQuestionChallenge.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SerializeQuestionChallenge = void 0;
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const App_1 = require("../../App");
+const StateMachine_1 = require("../../StateMachine");
+const QuestionEntity_1 = require("../Entities/QuestionEntity");
+class SerializeQuestionChallenge extends AppObjectUC_1.AppObjectUC {
+    constructor(appObject) {
+        super(appObject, SerializeQuestionChallenge.type);
+        this.name = "question";
+        this.seriliziationVersion = 3;
+        this.setupQuestionAnswer = () => {
+            throw new Error("setupQuestionAnswer as not been injected");
+        };
+        this.questionEntity = appObject.getComponent(QuestionEntity_1.QuestionEntity.type);
+        if (!this.questionEntity) {
+            App_1.submitWarning("SerializeQuestionChallenge", "SerializeQuestionChallenge has been added to an app object that does not have QuestionEntity", this.appObject.appObjectRepo);
+        }
+        const stateMachine = StateMachine_1.StateMachineEntity.get(this.appObject.appObjectRepo);
+        if (stateMachine) {
+            stateMachine.registerSerializedSystem(this);
+        }
+        else {
+            App_1.submitWarning("SerializeQuestionChallenge", "Unable to find StateMachineEntity", this.appObject.appObjectRepo);
+        }
+    }
+    getSystemState() {
+        if (!this.questionEntity) {
+            return {};
+        }
+        const answers = this.questionEntity
+            .getAllAnswers()
+            .map((answer) => {
+            return {
+                id: answer.id,
+                feedback: answer.feedbackText,
+                isCorrect: answer.isCorrect,
+                text: answer.text,
+            };
+        });
+        const state = {
+            answers,
+        };
+        return state;
+    }
+    applySystemState(state, version) {
+        if (version === 1) {
+            const mappedState = this.mapV1ToV3(state);
+            this.applyDataV3(mappedState);
+        }
+        else if (version === 2) {
+            const mappedState = this.mapV2ToV3(state);
+            this.applyDataV3(mappedState);
+        }
+        else if (version === 3) {
+            this.applyDataV3(state);
+        }
+        else {
+            // Unsupported version
+            console.warn(`Unsupported data version ${version} for serialized system ${this.name}. Reverting to default state`);
+            this.applyDefaultState();
+        }
+    }
+    applyDefaultState() {
+        var _a;
+        (_a = this.questionEntity) === null || _a === void 0 ? void 0 : _a.setDefaultState();
+    }
+    mapV1ToV3(data) {
+        //Easy!
+        return data;
+    }
+    mapV2ToV3(data) {
+        const { answers } = data;
+        return {
+            answers,
+        };
+    }
+    applyDataV3(data) {
+        if (!this.questionEntity)
+            return;
+        this.questionEntity.removeAllAnswers();
+        data.answers.forEach((answerData) => {
+            var _a;
+            const answer = this.setupQuestionAnswer(this.appObject.appObjectRepo, answerData.id);
+            answer.text = answerData.text;
+            answer.isCorrect = answerData.isCorrect;
+            answer.feedbackText = answerData.feedback;
+            (_a = this.questionEntity) === null || _a === void 0 ? void 0 : _a.addAnswer(answer);
+        });
+    }
+}
+exports.SerializeQuestionChallenge = SerializeQuestionChallenge;
+SerializeQuestionChallenge.type = "SerializeQuestionChallenge";

package/lib/AppObjectComponents/Question/UseCases/SetAnswerFeedbackUC.d.ts

@@ -0,0 +1,7 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+export declare abstract class SetAnswerFeedbackUC extends AppObjectUC {
+    static readonly type = "SetAnswerFeedbackUC";
+    abstract setFeedback(feedback: string): void;
+}
+export declare function makeSetAnswerFeedbackUC(appObject: AppObject): SetAnswerFeedbackUC;