@vived/app 3.8.0 → 3.9.0

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;

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSetAnswerFeedbackUC = exports.SetAnswerFeedbackUC = void 0;
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const App_1 = require("../../App");
+const Dispatcher_1 = require("../../Dispatcher");
+const QuestionAnswerEntity_1 = require("../Entities/QuestionAnswerEntity");
+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) {
+            App_1.submitWarning("SetAnswerFeedbackUC", "SetAnswerFeedbackUC has been added to an app object that does not have QuestionAnswerEntity", appObject.appObjectRepo);
+        }
+    }
+    setFeedback(feedback) {
+        var _a;
+        if (!this.answer)
+            return;
+        if (this.answer.feedbackText === feedback)
+            return;
+        this.answer.feedbackText = feedback;
+        (_a = Dispatcher_1.DispatchStateChangeUC.get(this.appObject.appObjectRepo)) === null || _a === void 0 ? void 0 : _a.doDispatch();
+    }
+}

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

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

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSetAnswerTextUC = exports.SetAnswerTextUC = void 0;
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const App_1 = require("../../App");
+const Dispatcher_1 = require("../../Dispatcher");
+const QuestionAnswerEntity_1 = require("../Entities/QuestionAnswerEntity");
+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) {
+            App_1.submitWarning("SetAnswerTextUC", "SetAnswerTextUC has been added to an app object that does not have QuestionAnswerEntity", appObject.appObjectRepo);
+        }
+    }
+    setText(text) {
+        var _a;
+        if (!this.answer)
+            return;
+        if (this.answer.text === text)
+            return;
+        this.answer.text = text;
+        (_a = Dispatcher_1.DispatchStateChangeUC.get(this.appObject.appObjectRepo)) === null || _a === void 0 ? void 0 : _a.doDispatch();
+    }
+}

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

@@ -0,0 +1,2 @@
+import { QuestionChallenge } from "../../Entities";
+export declare function makeSetQuestionChallengeAnswerFeedback(answerID: string, questionChallenge: QuestionChallenge): (feedback: string) => void;

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSetQuestionChallengeAnswerFeedback = void 0;
+function makeSetQuestionChallengeAnswerFeedback(answerID, questionChallenge) {
+    return function setQuestionChallengeAnswerFeedback(feedback) {
+        const answer = questionChallenge.getAnswer(answerID);
+        if (answer) {
+            answer.feedbackText = feedback;
+        }
+        else {
+            console.warn("[setQuestionChallengeAnswerFeedback] Unable to find question by id " +
+                answerID);
+        }
+    };
+}
+exports.makeSetQuestionChallengeAnswerFeedback = makeSetQuestionChallengeAnswerFeedback;

package/lib/AppObjectComponents/Question/UseCases/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;

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

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSubmitQuestionAnswerUC = exports.SubmitQuestionAnswerUC = void 0;
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const App_1 = require("../../App");
+const Dispatcher_1 = require("../../Dispatcher");
+const Entities_1 = require("../Entities");
+class SubmitQuestionAnswerUC extends AppObjectUC_1.AppObjectUC {
+    static get(appObjects) {
+        const components = appObjects.getAllComponents(SubmitQuestionAnswerUC.type);
+        if (components.length === 0) {
+            App_1.submitWarning("SubmitQuestionAnswerUC", `Unable to find component ${SubmitQuestionAnswerUC.type}. Add one on Mount`, appObjects);
+            return undefined;
+        }
+        else if (components.length > 1) {
+            App_1.submitWarning("SubmitQuestionAnswerUC", `Multiple ${SubmitQuestionAnswerUC.type} found. There should only be one. Using the first one`, appObjects);
+        }
+        return components[0];
+    }
+}
+exports.SubmitQuestionAnswerUC = SubmitQuestionAnswerUC;
+SubmitQuestionAnswerUC.type = "SubmitQuestionAnswerUC";
+function makeSubmitQuestionAnswerUC(appObject) {
+    return new SubmitQuestionAnswerUCImp(appObject);
+}
+exports.makeSubmitQuestionAnswerUC = makeSubmitQuestionAnswerUC;
+class SubmitQuestionAnswerUCImp extends SubmitQuestionAnswerUC {
+    constructor(appObject) {
+        super(appObject, SubmitQuestionAnswerUC.type);
+        this.questionEntity = appObject.getComponent(Entities_1.QuestionEntity.type);
+        if (!this.questionEntity) {
+            App_1.submitWarning("SubmitQuestionAnswerUCImp", "SubmitQuestionAnswerUCImp has been added to an app object that does not have QuestionEntity", appObject.appObjectRepo);
+        }
+    }
+    submitAnswer(id) {
+        if (!this.questionEntity)
+            return;
+        if (!this.questionEntity.hasAnswer(id)) {
+            App_1.submitWarning("SubmitQuestionAnswerUCImp", "Unable to find answer by ID", this.appObject.appObjectRepo);
+            return;
+        }
+        const baseApp = App_1.BaseAppState.get(this.appObject.appObjectRepo);
+        if (!baseApp) {
+            App_1.submitWarning("SubmitQuestionAnswerUCImp", "Unable to find Base App", this.appObject.appObjectRepo);
+            return;
+        }
+        if (baseApp.isAuthoring)
+            return;
+        this.questionEntity.submitAnswer(id);
+        const submitResult = Dispatcher_1.SubmitResultResultUC.get(this.appObject.appObjectRepo);
+        if (submitResult) {
+            submitResult.submitHitResult({
+                success: this.questionEntity.gotItRight,
+                description: baseApp.slideText,
+            });
+        }
+        baseApp.isReviewing = true;
+    }
+}

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

@@ -0,0 +1,7 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+export declare abstract class ToggleQuesionChallengeAnswerIsCorrectUC extends AppObjectUC {
+    static readonly type = "ToggleQuesionChallengeAnswerIsCorrect";
+    abstract toggleIsCorrect(): void;
+}
+export declare function makeToggleQuesionChallengeAnswerIsCorrectUC(appObject: AppObject): ToggleQuesionChallengeAnswerIsCorrectUC;

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeToggleQuesionChallengeAnswerIsCorrectUC = exports.ToggleQuesionChallengeAnswerIsCorrectUC = void 0;
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const App_1 = require("../../App");
+const Dispatcher_1 = require("../../Dispatcher");
+const QuestionAnswerEntity_1 = require("../Entities/QuestionAnswerEntity");
+class ToggleQuesionChallengeAnswerIsCorrectUC extends AppObjectUC_1.AppObjectUC {
+}
+exports.ToggleQuesionChallengeAnswerIsCorrectUC = ToggleQuesionChallengeAnswerIsCorrectUC;
+ToggleQuesionChallengeAnswerIsCorrectUC.type = "ToggleQuesionChallengeAnswerIsCorrect";
+function makeToggleQuesionChallengeAnswerIsCorrectUC(appObject) {
+    return new ToggleQuesionChallengeAnswerIsCorrectImp(appObject);
+}
+exports.makeToggleQuesionChallengeAnswerIsCorrectUC = makeToggleQuesionChallengeAnswerIsCorrectUC;
+class ToggleQuesionChallengeAnswerIsCorrectImp extends ToggleQuesionChallengeAnswerIsCorrectUC {
+    constructor(appObject) {
+        super(appObject, ToggleQuesionChallengeAnswerIsCorrectUC.type);
+        this.answer = appObject.getComponent(QuestionAnswerEntity_1.QuestionAnswerEntity.type);
+        if (!this.answer) {
+            App_1.submitWarning("ToggleQuesionChallengeAnswerIsCorrectUC", "ToggleQuesionChallengeAnswerIsCorrectUC has been added to an app object that does not have QuestionAnswerEntity", appObject.appObjectRepo);
+        }
+    }
+    toggleIsCorrect() {
+        var _a;
+        if (!this.answer)
+            return;
+        this.answer.isCorrect = !this.answer.isCorrect;
+        (_a = Dispatcher_1.DispatchStateChangeUC.get(this.appObject.appObjectRepo)) === null || _a === void 0 ? void 0 : _a.doDispatch();
+    }
+}

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

@@ -0,0 +1,7 @@
+export * from "./AddQuestionAnswerUC";
+export * from "./DeleteQuestionAnswerUC";
+export * from "./SerializeQuestionChallenge";
+export * from "./SetAnswerFeedbackUC";
+export * from "./SetAnswerTextUC";
+export * from "./SubmitQuestionAnswerUC";
+export * from "./ToggleQuestionAnswerIsCorrect";

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

@@ -0,0 +1,19 @@
+"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("./AddQuestionAnswerUC"), exports);
+__exportStar(require("./DeleteQuestionAnswerUC"), exports);
+__exportStar(require("./SerializeQuestionChallenge"), exports);
+__exportStar(require("./SetAnswerFeedbackUC"), exports);
+__exportStar(require("./SetAnswerTextUC"), exports);
+__exportStar(require("./SubmitQuestionAnswerUC"), exports);
+__exportStar(require("./ToggleQuestionAnswerIsCorrect"), exports);

package/lib/AppObjectComponents/SceneRoot/Controllers/DoubleTapToFocus.d.ts

@@ -0,0 +1,20 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectController } from "../../../AppObject/AppObjectController";
+import { TouchController, TouchInputEvent } from "../../TouchController";
+export declare class DoubleTapToFocus extends AppObjectController implements TouchController {
+    static readonly type = "DoubleTapToFocus";
+    readonly focusDurationMS = 500;
+    readonly tapTimeMS = 300;
+    readonly maxTapDistancePx = 30;
+    private initialTouchPos;
+    private initialTouchTime;
+    private tapCount;
+    private focusOnPixelUC?;
+    allow: (e: TouchInputEvent) => boolean;
+    onTouchStart: (e: TouchInputEvent) => void;
+    onTouchMove: (e: TouchInputEvent) => void;
+    onTouchEnd: () => void;
+    private cancelDoubleTap;
+    private checkForMovement;
+    constructor(appObject: AppObject);
+}