@vived/app 3.9.1 → 4.0.0

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

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuestionChallengePM = exports.defaultQuestionChallengeVM = void 0;
+const AppObject_1 = require("../../../AppObject");
+const AppObjectPM_1 = require("../../../AppObject/AppObjectPM");
+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 {
+            this.warn("QuestionChallengePM has been added to an app object that does not have QuestionEntity");
+        }
+    }
+    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";
+QuestionChallengePM.get = (appObjects) => AppObject_1.getSingletonComponent(QuestionChallengePM.type, appObjects);

package/lib/Components/Question/UC/AddAnswerUndoRedo.d.ts

@@ -0,0 +1,10 @@
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+import { UndoRedoAction } from "../../UndoRedo/Entities/UndoRedoEntity";
+export declare class AddAnswerUndoRedo implements UndoRedoAction {
+    private answerID;
+    private dispatchStateChange?;
+    private questionEntity?;
+    undoAction: () => void;
+    redoAction: () => void;
+    constructor(answerID: string, appObjects: AppObjectRepo);
+}

package/lib/Components/Question/UC/AddAnswerUndoRedo.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AddAnswerUndoRedo = void 0;
+const DispatchStateChangeUC_1 = require("../../Dispatcher/UC/DispatchStateChangeUC");
+const UndoRedoEntity_1 = require("../../UndoRedo/Entities/UndoRedoEntity");
+const Entities_1 = require("../Entities");
+class AddAnswerUndoRedo {
+    constructor(answerID, appObjects) {
+        this.answerID = answerID;
+        this.undoAction = () => {
+            if (!this.questionEntity || !this.dispatchStateChange)
+                return;
+            this.questionEntity.removeAnswer(this.answerID);
+            this.dispatchStateChange.doDispatch();
+        };
+        this.redoAction = () => {
+            if (!this.questionEntity || !this.dispatchStateChange)
+                return;
+            const answer = this.questionEntity.answerFactory(this.answerID);
+            this.questionEntity.addAnswer(answer);
+            this.dispatchStateChange.doDispatch();
+        };
+        this.questionEntity = Entities_1.QuestionEntity.get(appObjects);
+        if (!this.questionEntity) {
+            appObjects.submitWarning("AddAnswerUndoRedo", "Unable to find QuestionEntity");
+            return;
+        }
+        this.dispatchStateChange = DispatchStateChangeUC_1.DispatchStateChangeUC.get(appObjects);
+        if (!this.dispatchStateChange) {
+            appObjects.submitWarning("AddAnswerUndoRedo", "Unable to find DispatchStateChangeUC");
+            return;
+        }
+        const undoRedo = UndoRedoEntity_1.UndoRedoEntity.get(appObjects);
+        if (!undoRedo) {
+            appObjects.submitWarning("AddAnswerUndoRedo", "Unable to find UndoRedoEntity");
+            return;
+        }
+        undoRedo.submitAction(this);
+    }
+}
+exports.AddAnswerUndoRedo = AddAnswerUndoRedo;

package/lib/Components/Question/UC/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/Components/Question/UC/AddQuestionAnswerUC.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addQuestionAnswer = exports.makeAddQuestionAnswerUC = exports.AddQuestionAnswerUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const Dispatcher_1 = require("../../Dispatcher");
+const QuestionEntity_1 = require("../Entities/QuestionEntity");
+const AddAnswerUndoRedo_1 = require("./AddAnswerUndoRedo");
+class AddQuestionAnswerUC extends AppObjectUC_1.AppObjectUC {
+}
+exports.AddQuestionAnswerUC = AddQuestionAnswerUC;
+AddQuestionAnswerUC.type = "AddQuestionAnswerUC";
+AddQuestionAnswerUC.get = (appObjects) => AppObject_1.getSingletonComponent(AddQuestionAnswerUC.type, appObjects);
+function makeAddQuestionAnswerUC(appObject) {
+    return new AddQuestionAnswerUCImp(appObject);
+}
+exports.makeAddQuestionAnswerUC = makeAddQuestionAnswerUC;
+function addQuestionAnswer(appObjects) {
+    const uc = AddQuestionAnswerUC.get(appObjects);
+    if (uc) {
+        uc.addAnswer();
+    }
+    else {
+        appObjects.submitWarning("addQuestionAnswer", "Can't find AddQuestionAnswerUC");
+    }
+}
+exports.addQuestionAnswer = addQuestionAnswer;
+class AddQuestionAnswerUCImp extends AddQuestionAnswerUC {
+    constructor(appObject) {
+        super(appObject, AddQuestionAnswerUC.type);
+        this.questionEntity = appObject.getComponent(QuestionEntity_1.QuestionEntity.type);
+        if (!this.questionEntity) {
+            this.warn("AddAnswerUC has been added to an app object that does not have QuestionEntity");
+        }
+    }
+    addAnswer() {
+        var _a;
+        if (!this.questionEntity)
+            return;
+        const ans = this.questionEntity.createNewAnswer();
+        (_a = Dispatcher_1.DispatchStateChangeUC.get(this.appObject.appObjectRepo)) === null || _a === void 0 ? void 0 : _a.doDispatch();
+        new AddAnswerUndoRedo_1.AddAnswerUndoRedo(ans.id, this.appObject.appObjectRepo);
+    }
+}

package/lib/Components/Question/UC/DeleteAnswerUndoRedo.d.ts

@@ -0,0 +1,14 @@
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+import { UndoRedoAction } from "../../UndoRedo/Entities/UndoRedoEntity";
+import { QuestionAnswerEntity } from "../Entities";
+export declare class DeleteAnswerUndoRedo implements UndoRedoAction {
+    private dispatchStateChange?;
+    private questionEntity?;
+    private id;
+    private isCorrect;
+    private text;
+    private feedback;
+    undoAction: () => void;
+    redoAction: () => void;
+    constructor(answer: QuestionAnswerEntity, appObjects: AppObjectRepo);
+}

package/lib/Components/Question/UC/DeleteAnswerUndoRedo.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeleteAnswerUndoRedo = void 0;
+const DispatchStateChangeUC_1 = require("../../Dispatcher/UC/DispatchStateChangeUC");
+const UndoRedoEntity_1 = require("../../UndoRedo/Entities/UndoRedoEntity");
+const Entities_1 = require("../Entities");
+class DeleteAnswerUndoRedo {
+    constructor(answer, appObjects) {
+        this.undoAction = () => {
+            if (!this.questionEntity || !this.dispatchStateChange)
+                return;
+            const answer = this.questionEntity.answerFactory(this.id);
+            answer.feedbackText = this.feedback;
+            answer.text = this.text;
+            answer.isCorrect = this.isCorrect;
+            this.questionEntity.addAnswer(answer);
+            this.dispatchStateChange.doDispatch();
+        };
+        this.redoAction = () => {
+            if (!this.questionEntity || !this.dispatchStateChange)
+                return;
+            this.questionEntity.removeAnswer(this.id);
+            this.dispatchStateChange.doDispatch();
+        };
+        const { id, feedbackText, text, isCorrect } = answer;
+        this.id = id;
+        this.text = text;
+        this.feedback = feedbackText;
+        this.isCorrect = isCorrect;
+        this.questionEntity = Entities_1.QuestionEntity.get(appObjects);
+        if (!this.questionEntity) {
+            appObjects.submitWarning("DeleteAnswerUndoRedo", "Unable to find QuestionEntity");
+            return;
+        }
+        this.dispatchStateChange = DispatchStateChangeUC_1.DispatchStateChangeUC.get(appObjects);
+        if (!this.dispatchStateChange) {
+            appObjects.submitWarning("DeleteAnswerUndoRedo", "Unable to find DispatchStateChangeUC");
+            return;
+        }
+        const undoRedo = UndoRedoEntity_1.UndoRedoEntity.get(appObjects);
+        if (!undoRedo) {
+            appObjects.submitWarning("DeleteAnswerUndoRedo", "Unable to find UndoRedoEntity");
+            return;
+        }
+        undoRedo.submitAction(this);
+    }
+}
+exports.DeleteAnswerUndoRedo = DeleteAnswerUndoRedo;

package/lib/Components/Question/UC/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/Components/Question/UC/DeleteQuestionAnswerUC.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteQuestionAnswer = exports.makeDeleteQuestionAnswerUC = exports.DeleteQuestionAnswerUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const Dispatcher_1 = require("../../Dispatcher");
+const QuestionEntity_1 = require("../Entities/QuestionEntity");
+const DeleteAnswerUndoRedo_1 = require("./DeleteAnswerUndoRedo");
+class DeleteQuestionAnswerUC extends AppObjectUC_1.AppObjectUC {
+}
+exports.DeleteQuestionAnswerUC = DeleteQuestionAnswerUC;
+DeleteQuestionAnswerUC.type = "DeleteQuestionAnswerUC";
+DeleteQuestionAnswerUC.get = (appObjects) => AppObject_1.getSingletonComponent(DeleteQuestionAnswerUC.type, appObjects);
+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 {
+        appObjects.submitWarning("deleteQuestionAnswer", "Can't find AddQuestionAnswerUC");
+    }
+}
+exports.deleteQuestionAnswer = deleteQuestionAnswer;
+class DeleteQuestionAnswerUCImp extends DeleteQuestionAnswerUC {
+    constructor(appObject) {
+        super(appObject, DeleteQuestionAnswerUC.type);
+        this.questionEntity = appObject.getComponent(QuestionEntity_1.QuestionEntity.type);
+        if (!this.questionEntity) {
+            this.warn("DeleteQuestionAnswerUCImp has been added to an app object that does not have QuestionEntity");
+        }
+    }
+    deleteAnswer(id) {
+        var _a;
+        if (!this.questionEntity)
+            return;
+        const ans = this.questionEntity.getAnswer(id);
+        if (!ans)
+            return;
+        this.questionEntity.removeAnswer(id);
+        (_a = Dispatcher_1.DispatchStateChangeUC.get(this.appObject.appObjectRepo)) === null || _a === void 0 ? void 0 : _a.doDispatch();
+        new DeleteAnswerUndoRedo_1.DeleteAnswerUndoRedo(ans, this.appObject.appObjectRepo);
+    }
+}

package/lib/Components/Question/UC/SerializeQuestionChallenge.d.ts

@@ -0,0 +1,32 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+import { SerializedSystem } from "../../StateMachine";
+export declare class SerializeQuestionChallenge extends AppObjectUC implements SerializedSystem {
+    static readonly type = "SerializeQuestionChallenge";
+    name: string;
+    seriliziationVersion: number;
+    private questionEntity?;
+    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/Components/Question/UC/SerializeQuestionChallenge.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SerializeQuestionChallenge = void 0;
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+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.questionEntity = appObject.getComponent(QuestionEntity_1.QuestionEntity.type);
+        if (!this.questionEntity) {
+            this.warn("SerializeQuestionChallenge has been added to an app object that does not have QuestionEntity");
+        }
+        const stateMachine = StateMachine_1.StateMachineEntity.get(this.appObject.appObjectRepo);
+        if (stateMachine) {
+            stateMachine.registerSerializedSystem(this);
+        }
+        else {
+            this.warn("Unable to find StateMachineEntity");
+        }
+    }
+    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
+            this.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;
+        const stateAnswerIDs = [];
+        data.answers.forEach((answerData) => {
+            var _a;
+            let answer = this.questionEntity.getAnswer(answerData.id);
+            if (!answer) {
+                answer = this.questionEntity.answerFactory(answerData.id);
+                (_a = this.questionEntity) === null || _a === void 0 ? void 0 : _a.addAnswer(answer);
+            }
+            answer.text = answerData.text;
+            answer.isCorrect = answerData.isCorrect;
+            answer.feedbackText = answerData.feedback;
+            stateAnswerIDs.push(answerData.id);
+        });
+        const allAnswers = Array.from(this.questionEntity.getAllAnswers());
+        allAnswers.forEach((ans) => {
+            if (!stateAnswerIDs.includes(ans.id)) {
+                this.questionEntity.removeAnswer(ans.id);
+            }
+        });
+    }
+}
+exports.SerializeQuestionChallenge = SerializeQuestionChallenge;
+SerializeQuestionChallenge.type = "SerializeQuestionChallenge";

package/lib/Components/Question/UC/SetAnswerFeedbackUC.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSetAnswerFeedbackUC = exports.SetAnswerFeedbackUC = void 0;
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const Dispatcher_1 = require("../../Dispatcher");
+const QuestionAnswerEntity_1 = require("../Entities/QuestionAnswerEntity");
+const SetAnswerFeedbackUndoRedo_1 = require("./SetAnswerFeedbackUndoRedo");
+class SetAnswerFeedbackUC extends AppObjectUC_1.AppObjectUC {
+}
+exports.SetAnswerFeedbackUC = SetAnswerFeedbackUC;
+SetAnswerFeedbackUC.type = "SetAnswerFeedbackUC";
+function makeSetAnswerFeedbackUC(appObject) {
+    return new SetAnswerFeedbackUCImp(appObject);
+}
+exports.makeSetAnswerFeedbackUC = makeSetAnswerFeedbackUC;
+class SetAnswerFeedbackUCImp extends SetAnswerFeedbackUC {
+    constructor(appObject) {
+        super(appObject, SetAnswerFeedbackUC.type);
+        this.answer = appObject.getComponent(QuestionAnswerEntity_1.QuestionAnswerEntity.type);
+        if (!this.answer) {
+            this.warn("SetAnswerFeedbackUC has been added to an app object that does not have QuestionAnswerEntity");
+        }
+    }
+    setFeedback(feedback) {
+        var _a;
+        if (!this.answer)
+            return;
+        if (this.answer.feedbackText === feedback)
+            return;
+        const previousFeedback = this.answer.feedbackText;
+        this.answer.feedbackText = feedback;
+        (_a = Dispatcher_1.DispatchStateChangeUC.get(this.appObject.appObjectRepo)) === null || _a === void 0 ? void 0 : _a.doDispatch();
+        new SetAnswerFeedbackUndoRedo_1.SetAnswerFeedbackUndoRedo(previousFeedback, this.answer.id, this.appObject.appObjectRepo);
+    }
+}

package/lib/Components/Question/UC/SetAnswerFeedbackUndoRedo.d.ts

@@ -0,0 +1,13 @@
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+import { UndoRedoAction } from "../../UndoRedo/Entities/UndoRedoEntity";
+export declare class SetAnswerFeedbackUndoRedo implements UndoRedoAction {
+    private initialText;
+    private answerID;
+    private dispatchStateChange?;
+    private questionEntity?;
+    private finalFeedback;
+    private answer?;
+    undoAction: () => void;
+    redoAction: () => void;
+    constructor(initialText: string, answerID: string, appObjects: AppObjectRepo);
+}

package/lib/Components/Question/UC/SetAnswerFeedbackUndoRedo.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetAnswerFeedbackUndoRedo = void 0;
+const DispatchStateChangeUC_1 = require("../../Dispatcher/UC/DispatchStateChangeUC");
+const UndoRedoEntity_1 = require("../../UndoRedo/Entities/UndoRedoEntity");
+const Entities_1 = require("../Entities");
+class SetAnswerFeedbackUndoRedo {
+    constructor(initialText, answerID, appObjects) {
+        this.initialText = initialText;
+        this.answerID = answerID;
+        this.finalFeedback = "";
+        this.undoAction = () => {
+            if (!this.questionEntity || !this.dispatchStateChange)
+                return;
+            if (!this.answer)
+                return;
+            this.answer.feedbackText = this.initialText;
+            this.dispatchStateChange.doDispatch();
+        };
+        this.redoAction = () => {
+            if (!this.questionEntity || !this.dispatchStateChange)
+                return;
+            if (!this.answer)
+                return;
+            this.answer.feedbackText = this.finalFeedback;
+            this.dispatchStateChange.doDispatch();
+        };
+        this.questionEntity = Entities_1.QuestionEntity.get(appObjects);
+        if (!this.questionEntity) {
+            appObjects.submitWarning("SetAnswerFeedbackUndoRedo", "Unable to find QuestionEntity");
+            return;
+        }
+        this.answer = this.questionEntity.getAnswer(this.answerID);
+        if (!this.answer) {
+            appObjects.submitWarning("SetAnswerFeedbackUndoRedo", "Unable to get answer by ID");
+            return;
+        }
+        this.finalFeedback = this.answer.feedbackText;
+        this.dispatchStateChange = DispatchStateChangeUC_1.DispatchStateChangeUC.get(appObjects);
+        if (!this.dispatchStateChange) {
+            appObjects.submitWarning("SetAnswerFeedbackUndoRedo", "Unable to find DispatchStateChangeUC");
+            return;
+        }
+        const undoRedo = UndoRedoEntity_1.UndoRedoEntity.get(appObjects);
+        if (!undoRedo) {
+            appObjects.submitWarning("SetAnswerFeedbackUndoRedo", "Unable to find UndoRedoEntity");
+            return;
+        }
+        undoRedo.submitAction(this);
+    }
+}
+exports.SetAnswerFeedbackUndoRedo = SetAnswerFeedbackUndoRedo;

package/lib/Components/Question/UC/SetAnswerTextUC.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSetAnswerTextUC = exports.SetAnswerTextUC = void 0;
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const Dispatcher_1 = require("../../Dispatcher");
+const QuestionAnswerEntity_1 = require("../Entities/QuestionAnswerEntity");
+const SetAnswerTextUndoRedo_1 = require("./SetAnswerTextUndoRedo");
+class SetAnswerTextUC extends AppObjectUC_1.AppObjectUC {
+}
+exports.SetAnswerTextUC = SetAnswerTextUC;
+SetAnswerTextUC.type = "SetAnswerTextUC";
+function makeSetAnswerTextUC(appObject) {
+    return new SetAnswerTextUCImp(appObject);
+}
+exports.makeSetAnswerTextUC = makeSetAnswerTextUC;
+class SetAnswerTextUCImp extends SetAnswerTextUC {
+    constructor(appObject) {
+        super(appObject, SetAnswerTextUC.type);
+        this.answer = appObject.getComponent(QuestionAnswerEntity_1.QuestionAnswerEntity.type);
+        if (!this.answer) {
+            this.warn("SetAnswerTextUC has been added to an app object that does not have QuestionAnswerEntity");
+        }
+    }
+    setText(text) {
+        var _a;
+        if (!this.answer)
+            return;
+        if (this.answer.text === text)
+            return;
+        const previousText = this.answer.text;
+        this.answer.text = text;
+        (_a = Dispatcher_1.DispatchStateChangeUC.get(this.appObject.appObjectRepo)) === null || _a === void 0 ? void 0 : _a.doDispatch();
+        new SetAnswerTextUndoRedo_1.SetAnswerTextUndoRedo(previousText, this.answer.id, this.appObject.appObjectRepo);
+    }
+}

package/lib/Components/Question/UC/SetAnswerTextUndoRedo.d.ts

@@ -0,0 +1,13 @@
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+import { UndoRedoAction } from "../../UndoRedo/Entities/UndoRedoEntity";
+export declare class SetAnswerTextUndoRedo implements UndoRedoAction {
+    private initialText;
+    private answerID;
+    private dispatchStateChange?;
+    private questionEntity?;
+    private finalText;
+    private answer?;
+    undoAction: () => void;
+    redoAction: () => void;
+    constructor(initialText: string, answerID: string, appObjects: AppObjectRepo);
+}

package/lib/Components/Question/UC/SetAnswerTextUndoRedo.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetAnswerTextUndoRedo = void 0;
+const DispatchStateChangeUC_1 = require("../../Dispatcher/UC/DispatchStateChangeUC");
+const UndoRedoEntity_1 = require("../../UndoRedo/Entities/UndoRedoEntity");
+const Entities_1 = require("../Entities");
+class SetAnswerTextUndoRedo {
+    constructor(initialText, answerID, appObjects) {
+        this.initialText = initialText;
+        this.answerID = answerID;
+        this.finalText = "";
+        this.undoAction = () => {
+            if (!this.questionEntity || !this.dispatchStateChange)
+                return;
+            if (!this.answer)
+                return;
+            this.answer.text = this.initialText;
+            this.dispatchStateChange.doDispatch();
+        };
+        this.redoAction = () => {
+            if (!this.questionEntity || !this.dispatchStateChange)
+                return;
+            if (!this.answer)
+                return;
+            this.answer.text = this.finalText;
+            this.dispatchStateChange.doDispatch();
+        };
+        this.questionEntity = Entities_1.QuestionEntity.get(appObjects);
+        if (!this.questionEntity) {
+            appObjects.submitWarning("SetAnswerTextUndoRedo", "Unable to find QuestionEntity");
+            return;
+        }
+        this.answer = this.questionEntity.getAnswer(this.answerID);
+        if (!this.answer) {
+            appObjects.submitWarning("SetAnswerTextUndoRedo", "Unable to get answer by ID");
+            return;
+        }
+        this.finalText = this.answer.text;
+        this.dispatchStateChange = DispatchStateChangeUC_1.DispatchStateChangeUC.get(appObjects);
+        if (!this.dispatchStateChange) {
+            appObjects.submitWarning("SetAnswerTextUndoRedo", "Unable to find DispatchStateChangeUC");
+            return;
+        }
+        const undoRedo = UndoRedoEntity_1.UndoRedoEntity.get(appObjects);
+        if (!undoRedo) {
+            appObjects.submitWarning("SetAnswerTextUndoRedo", "Unable to find UndoRedoEntity");
+            return;
+        }
+        undoRedo.submitAction(this);
+    }
+}
+exports.SetAnswerTextUndoRedo = SetAnswerTextUndoRedo;

package/lib/Components/Question/UC/SubmitQuestionAnswerUC.d.ts

@@ -0,0 +1,9 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+export declare abstract class SubmitQuestionAnswerUC extends AppObjectUC {
+    static readonly type = "SubmitQuestionAnswerUC";
+    abstract submitAnswer(id: string): void;
+    static get: (appObjects: AppObjectRepo) => SubmitQuestionAnswerUC | undefined;
+}
+export declare function makeSubmitQuestionAnswerUC(appObject: AppObject): SubmitQuestionAnswerUC;