@vived/app 2.14.0 → 2.15.0

package/lib/Entities/MemoizedBoolean.d.ts

@@ -2,6 +2,7 @@ export declare class MemoizedBoolean {
     private _val;
     get val(): boolean;
     set val(b: boolean);
+    setValQuietly(val: boolean): void;
     private onChangeCallback;
     constructor(initialValue: boolean, onChangeCallback: () => void);
 }

package/lib/Entities/MemoizedBoolean.js

@@ -15,5 +15,8 @@ class MemoizedBoolean {
         this._val = b;
         this.onChangeCallback();
     }
+    setValQuietly(val) {
+        this._val = val;
+    }
 }
 exports.MemoizedBoolean = MemoizedBoolean;

package/lib/Entities/MemoizedNumber.d.ts

@@ -2,6 +2,7 @@ export declare class MemoizedNumber {
     private _val;
     get val(): number;
     set val(b: number);
+    setValQuietly(val: number): void;
     private onChangeCallback;
     constructor(initialValue: number, onChangeCallback: () => void);
 }

package/lib/Entities/MemoizedNumber.js

@@ -15,5 +15,8 @@ class MemoizedNumber {
         this._val = b;
         this.onChangeCallback();
     }
+    setValQuietly(val) {
+        this._val = val;
+    }
 }
 exports.MemoizedNumber = MemoizedNumber;

package/lib/Entities/MemoizedString.d.ts

@@ -2,6 +2,7 @@ export declare class MemoizedString {
     private _val;
     get val(): string;
     set val(b: string);
+    setValQuietly(val: string): void;
     private onChangeCallback;
     constructor(initialValue: string, onChangeCallback: () => void);
 }

package/lib/Entities/MemoizedString.js

@@ -15,5 +15,8 @@ class MemoizedString {
         this._val = b;
         this.onChangeCallback();
     }
+    setValQuietly(val) {
+        this._val = val;
+    }
 }
 exports.MemoizedString = MemoizedString;

package/lib/Entities/MemoizedVector2.d.ts

@@ -3,6 +3,7 @@ export declare class MemoizedVector2 {
     private _val;
     get val(): Vector2;
     set val(v: Vector2);
+    setValQuietly(val: Vector2): void;
     private onChangeCallback;
     constructor(initialValue: Vector2, onChangeCallback: () => void);
 }

package/lib/Entities/MemoizedVector2.js

@@ -16,5 +16,8 @@ class MemoizedVector2 {
         this._val = v;
         this.onChangeCallback();
     }
+    setValQuietly(val) {
+        this._val = val;
+    }
 }
 exports.MemoizedVector2 = MemoizedVector2;

package/lib/Entities/MemoizedVector3.d.ts

@@ -3,6 +3,7 @@ export declare class MemoizedVector3 {
     private _val;
     get val(): Vector3;
     set val(v: Vector3);
+    setValQuietly(val: Vector3): void;
     private onChangeCallback;
     constructor(initialValue: Vector3, onChangeCallback: () => void);
 }

package/lib/Entities/MemoizedVector3.js

@@ -16,5 +16,8 @@ class MemoizedVector3 {
         this._val = v;
         this.onChangeCallback();
     }
+    setValQuietly(val) {
+        this._val = val;
+    }
 }
 exports.MemoizedVector3 = MemoizedVector3;

package/lib/Entities/QuestionChallenge.d.ts

@@ -0,0 +1,21 @@
+import { QuestionChallengeAnswer } from "./QuestionChallengeAnswer";
+export declare type OnQuestionChallengeChange = () => void;
+export interface QuestionChallenge {
+    gotItRight: boolean;
+    tries: number;
+    text: string;
+    addAnswer: (answer: QuestionChallengeAnswer) => void;
+    removeAnswer: (id: string) => void;
+    getAnswer: (id: string) => QuestionChallengeAnswer | undefined;
+    getAllAnswers: () => QuestionChallengeAnswer[];
+    hasAnswer: (id: string) => boolean;
+    createAnswer: (text: string) => QuestionChallengeAnswer;
+    removeAllAnswers: () => void;
+    setDefaultState: () => void;
+    reset: () => void;
+    submitAnswer: (id: string) => void;
+    setIDGenerator: (generator: () => string) => void;
+    addObserver: (observer: OnQuestionChallengeChange) => void;
+    removeObserver: (observer: OnQuestionChallengeChange) => void;
+}
+export declare function makeQuestionChallenge(): QuestionChallenge;

package/lib/Entities/QuestionChallenge.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeQuestionChallenge = void 0;
+const _1 = require(".");
+const QuestionChallengeAnswer_1 = require("./QuestionChallengeAnswer");
+function makeQuestionChallenge() {
+    return new QuestionChallengeImp();
+}
+exports.makeQuestionChallenge = makeQuestionChallenge;
+class QuestionChallengeImp {
+    constructor() {
+        this.answerLookup = new Map();
+        this.observers = new _1.ObserverList();
+        this._tries = 0;
+        this._gotItRight = false;
+        this.memoizedText = new _1.MemoizedString("", this.observers.notify);
+        this.generateID = () => {
+            const randomNumber = Math.random() * Date.now();
+            return `${randomNumber}`;
+        };
+        this.setIDGenerator = (generator) => {
+            this.generateID = generator;
+        };
+        this.getAllAnswers = () => {
+            return Array.from(this.answerLookup.values());
+        };
+        this.addAnswer = (answer) => {
+            if (this.answerLookup.has(answer.id)) {
+                throw new Error(`Answer with ID ${answer.id} already exists`);
+            }
+            this.answerLookup.set(answer.id, answer);
+            this.reset();
+        };
+        this.removeAnswer = (id) => {
+            const answer = this.answerLookup.get(id);
+            if (!answer)
+                return;
+            this.answerLookup.delete(id);
+            this.reset();
+        };
+        this.getAnswer = (id) => {
+            return this.answerLookup.get(id);
+        };
+        this.hasAnswer = (id) => {
+            return this.answerLookup.has(id);
+        };
+        this.reset = () => {
+            this._gotItRight = false;
+            this._tries = 0;
+            this.answerLookup.forEach((ans) => (ans.showFeedback = false));
+            this.observers.notify();
+        };
+        this.submitAnswer = (id) => {
+            const ans = this.getAnswer(id);
+            if (!ans) {
+                console.warn(`[Question Challenge] Unable to find answer by ID:  ${id}`);
+                return;
+            }
+            this._tries++;
+            ans.showFeedback = true;
+            this._gotItRight = ans.isCorrect;
+            this.observers.notify();
+        };
+        this.createAnswer = (text) => {
+            const id = this.generateID();
+            const answer = QuestionChallengeAnswer_1.makeQuestionChallengeAnswer(id);
+            answer.text = text;
+            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.createAnswer("True");
+            trueAnswer.isCorrect = true;
+            this.createAnswer("False");
+            this.memoizedText.setValQuietly("True / False question text");
+            this.reset();
+        };
+        this.addObserver = (observer) => {
+            this.observers.add(observer);
+        };
+        this.removeObserver = (observer) => {
+            this.observers.remove(observer);
+        };
+    }
+    get tries() {
+        return this._tries;
+    }
+    get gotItRight() {
+        return this._gotItRight;
+    }
+    get text() {
+        return this.memoizedText.val;
+    }
+    set text(val) {
+        this.memoizedText.val = val;
+    }
+}

package/lib/Entities/QuestionChallengeAnswer.d.ts

@@ -0,0 +1,32 @@
+export declare type OnQuestionAnswerChange = () => void;
+export interface QuestionChallengeAnswer {
+    id: string;
+    text: string;
+    isCorrect: boolean;
+    feedbackText: string;
+    showFeedback: boolean;
+    addObserver(observer: OnQuestionAnswerChange): void;
+    removeObserver(observer: OnQuestionAnswerChange): void;
+}
+export declare function makeQuestionChallengeAnswer(id: string): QuestionChallengeAnswerImp;
+declare class QuestionChallengeAnswerImp implements QuestionChallengeAnswer {
+    private observers;
+    private _id;
+    get id(): string;
+    private memoizedText;
+    get text(): string;
+    set text(val: string);
+    private memoizedFeedback;
+    get feedbackText(): string;
+    set feedbackText(val: string);
+    private memoizedIsCorrect;
+    get isCorrect(): boolean;
+    set isCorrect(val: boolean);
+    private memoizedShowFeedback;
+    get showFeedback(): boolean;
+    set showFeedback(val: boolean);
+    addObserver(observer: OnQuestionAnswerChange): void;
+    removeObserver(observer: OnQuestionAnswerChange): void;
+    constructor(id: string);
+}
+export {};

package/lib/Entities/QuestionChallengeAnswer.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeQuestionChallengeAnswer = void 0;
+const _1 = require(".");
+function makeQuestionChallengeAnswer(id) {
+    return new QuestionChallengeAnswerImp(id);
+}
+exports.makeQuestionChallengeAnswer = makeQuestionChallengeAnswer;
+class QuestionChallengeAnswerImp {
+    constructor(id) {
+        this.observers = new _1.ObserverList();
+        this.memoizedText = new _1.MemoizedString("Answer", this.observers.notify);
+        this.memoizedFeedback = new _1.MemoizedString("", this.observers.notify);
+        this.memoizedIsCorrect = new _1.MemoizedBoolean(false, this.observers.notify);
+        this.memoizedShowFeedback = new _1.MemoizedBoolean(false, this.observers.notify);
+        this._id = id;
+    }
+    get id() {
+        return this._id;
+    }
+    get text() {
+        return this.memoizedText.val;
+    }
+    set text(val) {
+        this.memoizedText.val = val;
+    }
+    get feedbackText() {
+        return this.memoizedFeedback.val;
+    }
+    set feedbackText(val) {
+        this.memoizedFeedback.val = val;
+    }
+    get isCorrect() {
+        return this.memoizedIsCorrect.val;
+    }
+    set isCorrect(val) {
+        this.memoizedIsCorrect.val = val;
+    }
+    get showFeedback() {
+        return this.memoizedShowFeedback.val;
+    }
+    set showFeedback(val) {
+        this.memoizedShowFeedback.val = val;
+    }
+    addObserver(observer) {
+        this.observers.add(observer);
+    }
+    removeObserver(observer) {
+        this.observers.remove(observer);
+    }
+}

package/lib/Entities/index.d.ts

@@ -13,3 +13,5 @@ export * from "./StateMachine";
 export * from "./UndoRedo";
 export * from "./MouseInput";
 export * from "./TouchInput";
+export * from "./QuestionChallengeAnswer";
+export * from "./QuestionChallenge";

package/lib/Entities/index.js

@@ -25,3 +25,5 @@ __exportStar(require("./StateMachine"), exports);
 __exportStar(require("./UndoRedo"), exports);
 __exportStar(require("./MouseInput"), exports);
 __exportStar(require("./TouchInput"), exports);
+__exportStar(require("./QuestionChallengeAnswer"), exports);
+__exportStar(require("./QuestionChallenge"), exports);

package/lib/PresentationManagers/QuestionChallenge/AuthorQuestionChallengeAnswerPM.d.ts

@@ -0,0 +1,24 @@
+import { QuestionChallenge } from "../../Entities";
+export declare const defaultAuthorQuestionChallengeAnswerVM: AuthorQuestionChallengeAnswerVM;
+export interface AuthorQuestionChallengeAnswerVM {
+    answerText: string;
+    feedbackText: string;
+    isCorrect: boolean;
+    allowDelete: boolean;
+    setAnswerText: (text: string) => void;
+    setFeedbackText: (text: string) => void;
+    toggleIsCorrect: () => void;
+    deleteAnswer: () => void;
+}
+export declare class AuthorQuestionChallengeAnswerPM {
+    private answerID;
+    private questionChallengeEntity;
+    private updateView;
+    private answer?;
+    setTextUC: (text: string) => void;
+    setFeedbackUC: (text: string) => void;
+    toggleIsCorrectUC: () => void;
+    dispose: () => void;
+    private doUpdateView;
+    constructor(answerID: string, questionChallengeEntity: QuestionChallenge, updateView: (vm: AuthorQuestionChallengeAnswerVM) => void);
+}

package/lib/PresentationManagers/QuestionChallenge/AuthorQuestionChallengeAnswerPM.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthorQuestionChallengeAnswerPM = exports.defaultAuthorQuestionChallengeAnswerVM = void 0;
+const setQuesionChallengeAnswerFeedback_1 = require("../../UseCases/QuestionChallenge/setQuesionChallengeAnswerFeedback");
+const setQuesionChallengeAnswerText_1 = require("../../UseCases/QuestionChallenge/setQuesionChallengeAnswerText");
+const toggleQuesionChallengeAnswerIsCorrect_1 = require("../../UseCases/QuestionChallenge/toggleQuesionChallengeAnswerIsCorrect");
+exports.defaultAuthorQuestionChallengeAnswerVM = {
+    answerText: "",
+    feedbackText: "",
+    isCorrect: false,
+    allowDelete: false,
+    setAnswerText: (text) => {
+        console.log("Default setAnswerText: " + text);
+    },
+    setFeedbackText: (text) => {
+        console.log("Default setFeedbackText: " + text);
+    },
+    toggleIsCorrect: () => {
+        console.log("Default toggleIsCorrect");
+    },
+    deleteAnswer: () => {
+        console.log("Default deleteAnswer");
+    },
+};
+class AuthorQuestionChallengeAnswerPM {
+    constructor(answerID, questionChallengeEntity, updateView) {
+        this.answerID = answerID;
+        this.questionChallengeEntity = questionChallengeEntity;
+        this.updateView = updateView;
+        this.dispose = () => {
+            var _a;
+            (_a = this.answer) === null || _a === void 0 ? void 0 : _a.removeObserver(this.doUpdateView);
+            this.questionChallengeEntity.removeObserver(this.doUpdateView);
+        };
+        this.doUpdateView = () => {
+            if (this.answer === undefined)
+                return;
+            const { feedbackText, text, isCorrect } = this.answer;
+            const allowDelete = this.questionChallengeEntity.getAllAnswers().length > 2 ? true : false;
+            const vm = {
+                answerText: text,
+                isCorrect,
+                feedbackText,
+                allowDelete,
+                setAnswerText: this.setTextUC,
+                setFeedbackText: this.setFeedbackUC,
+                toggleIsCorrect: this.toggleIsCorrectUC,
+                deleteAnswer: () => {
+                    this.questionChallengeEntity.removeAnswer(this.answerID);
+                },
+            };
+            this.updateView(vm);
+        };
+        this.answer = questionChallengeEntity.getAnswer(answerID);
+        this.setTextUC = setQuesionChallengeAnswerText_1.makeSetQuestionChallengeAnswerText(answerID, questionChallengeEntity);
+        this.setFeedbackUC = setQuesionChallengeAnswerFeedback_1.makeSetQuestionChallengeAnswerFeedback(answerID, questionChallengeEntity);
+        this.toggleIsCorrectUC = toggleQuesionChallengeAnswerIsCorrect_1.makeToggleQuesionChallengeAnswerIsCorrect(answerID, questionChallengeEntity);
+        if (this.answer) {
+            this.doUpdateView();
+            this.answer.addObserver(this.doUpdateView);
+            this.questionChallengeEntity.addObserver(this.doUpdateView);
+        }
+    }
+}
+exports.AuthorQuestionChallengeAnswerPM = AuthorQuestionChallengeAnswerPM;

package/lib/PresentationManagers/QuestionChallenge/AuthorQuestionChallengePM.d.ts

@@ -0,0 +1,17 @@
+import { QuestionChallenge } from "../../Entities";
+export declare const defaultAuthorQuestionChallengeVM: AuthorQuestionChallengeVM;
+export interface AuthorQuestionChallengeVM {
+    text: string;
+    answers: string[];
+    enableResetButton: boolean;
+    setQuestionText: (text: string) => void;
+    reset: () => void;
+    createAnswer: () => void;
+}
+export declare class AuthorQuestionChallengePM {
+    private questionChallengeEntity;
+    private updateView;
+    dispose: () => void;
+    private doUpdateView;
+    constructor(questionChallengeEntity: QuestionChallenge, updateView: (vm: AuthorQuestionChallengeVM) => void);
+}

package/lib/PresentationManagers/QuestionChallenge/AuthorQuestionChallengePM.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthorQuestionChallengePM = exports.defaultAuthorQuestionChallengeVM = void 0;
+exports.defaultAuthorQuestionChallengeVM = {
+    text: "",
+    answers: [],
+    enableResetButton: false,
+    setQuestionText: (text) => {
+        console.log("Default setQuestionText: " + text);
+    },
+    reset: () => {
+        console.log("Default reset");
+    },
+    createAnswer: () => {
+        console.log("Default reset");
+    },
+};
+class AuthorQuestionChallengePM {
+    constructor(questionChallengeEntity, updateView) {
+        this.questionChallengeEntity = questionChallengeEntity;
+        this.updateView = updateView;
+        this.dispose = () => {
+            this.questionChallengeEntity.removeObserver(this.doUpdateView);
+        };
+        this.doUpdateView = () => {
+            const { text, tries } = this.questionChallengeEntity;
+            const answers = this.questionChallengeEntity
+                .getAllAnswers()
+                .map((ans) => ans.id);
+            const vm = {
+                text,
+                answers,
+                enableResetButton: tries > 0,
+                setQuestionText: (txt) => {
+                    this.questionChallengeEntity.text = txt;
+                },
+                reset: () => this.questionChallengeEntity.reset(),
+                createAnswer: () => this.questionChallengeEntity.createAnswer(""),
+            };
+            this.updateView(vm);
+        };
+        this.doUpdateView();
+        this.questionChallengeEntity.addObserver(this.doUpdateView);
+    }
+}
+exports.AuthorQuestionChallengePM = AuthorQuestionChallengePM;

package/lib/PresentationManagers/QuestionChallenge/QuestionChallengeAnswerPM.d.ts

@@ -0,0 +1,17 @@
+import { QuestionChallenge } from "../../Entities";
+export declare const defaultQestionChallengeAnswerVM: QuestionChallengeAnswerVM;
+export interface QuestionChallengeAnswerVM {
+    displayText: string;
+    isShowingFeedback: boolean;
+    isCorrect: boolean;
+    submitAnswer: () => void;
+}
+export declare class QuestionChallengeAnswerPM {
+    private answerID;
+    private questionChallengeEntity;
+    private updateView;
+    private answer?;
+    dispose: () => void;
+    private doUpdateView;
+    constructor(answerID: string, questionChallengeEntity: QuestionChallenge, updateView: (vm: QuestionChallengeAnswerVM) => void);
+}

package/lib/PresentationManagers/QuestionChallenge/QuestionChallengeAnswerPM.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuestionChallengeAnswerPM = exports.defaultQestionChallengeAnswerVM = void 0;
+exports.defaultQestionChallengeAnswerVM = {
+    displayText: "",
+    isShowingFeedback: false,
+    isCorrect: false,
+    submitAnswer: () => {
+        console.log("Default submitAnswer");
+    },
+};
+class QuestionChallengeAnswerPM {
+    constructor(answerID, questionChallengeEntity, updateView) {
+        this.answerID = answerID;
+        this.questionChallengeEntity = questionChallengeEntity;
+        this.updateView = updateView;
+        this.dispose = () => {
+            var _a;
+            (_a = this.answer) === null || _a === void 0 ? void 0 : _a.removeObserver(this.doUpdateView);
+        };
+        this.doUpdateView = () => {
+            if (!this.answer)
+                return;
+            const { feedbackText, showFeedback, text, isCorrect } = this.answer;
+            let displayText = text ? text : `Answer`;
+            if (showFeedback) {
+                if (feedbackText) {
+                    displayText = feedbackText;
+                }
+                else {
+                    displayText = isCorrect ? "Correct" : "Incorrect";
+                }
+            }
+            const vm = {
+                displayText,
+                isCorrect,
+                isShowingFeedback: showFeedback,
+                submitAnswer: () => {
+                    this.questionChallengeEntity.submitAnswer(this.answerID);
+                },
+            };
+            this.updateView(vm);
+        };
+        this.answer = questionChallengeEntity.getAnswer(answerID);
+        if (this.answer) {
+            this.doUpdateView();
+            this.answer.addObserver(this.doUpdateView);
+        }
+    }
+}
+exports.QuestionChallengeAnswerPM = QuestionChallengeAnswerPM;

package/lib/PresentationManagers/QuestionChallenge/QuestionChallengePM.d.ts

@@ -0,0 +1,15 @@
+import { QuestionChallenge } from "../../Entities";
+export declare const defaultQuestionChallengeVM: QuestionChallengeVM;
+export interface QuestionChallengeVM {
+    text: string;
+    tries: number;
+    gotItRight: boolean;
+    answers: string[];
+}
+export declare class QuestionChallengePM {
+    private questionChallengeEntity;
+    private updateView;
+    dispose: () => void;
+    private doUpdateView;
+    constructor(questionChallengeEntity: QuestionChallenge, updateView: (vm: QuestionChallengeVM) => void);
+}

package/lib/PresentationManagers/QuestionChallenge/QuestionChallengePM.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuestionChallengePM = exports.defaultQuestionChallengeVM = void 0;
+exports.defaultQuestionChallengeVM = {
+    text: "",
+    answers: [],
+    gotItRight: false,
+    tries: 0,
+};
+class QuestionChallengePM {
+    constructor(questionChallengeEntity, updateView) {
+        this.questionChallengeEntity = questionChallengeEntity;
+        this.updateView = updateView;
+        this.dispose = () => {
+            this.questionChallengeEntity.removeObserver(this.doUpdateView);
+        };
+        this.doUpdateView = () => {
+            const { tries, text } = this.questionChallengeEntity;
+            const answers = this.questionChallengeEntity
+                .getAllAnswers()
+                .map((ans) => ans.id);
+            const vm = {
+                text,
+                tries,
+                gotItRight: this.questionChallengeEntity.gotItRight,
+                answers,
+            };
+            this.updateView(vm);
+        };
+        this.doUpdateView();
+        this.questionChallengeEntity.addObserver(this.doUpdateView);
+    }
+}
+exports.QuestionChallengePM = QuestionChallengePM;

package/lib/PresentationManagers/QuestionChallenge/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./QuestionChallengePM";
+export * from "./QuestionChallengeAnswerPM";
+export * from "./AuthorQuestionChallengeAnswerPM";
+export * from "./AuthorQuestionChallengePM";

package/lib/PresentationManagers/QuestionChallenge/index.js

@@ -0,0 +1,16 @@
+"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("./QuestionChallengePM"), exports);
+__exportStar(require("./QuestionChallengeAnswerPM"), exports);
+__exportStar(require("./AuthorQuestionChallengeAnswerPM"), exports);
+__exportStar(require("./AuthorQuestionChallengePM"), exports);

package/lib/PresentationManagers/index.d.ts

@@ -4,3 +4,4 @@ export * from "./ShowBabylonInspectorPM";
 export * from "./HasRedoPM";
 export * from "./HasUndoPM";
 export * from "./FocusCameraPM";
+export * from "./QuestionChallenge";

package/lib/PresentationManagers/index.js

@@ -16,3 +16,4 @@ __exportStar(require("./ShowBabylonInspectorPM"), exports);
 __exportStar(require("./HasRedoPM"), exports);
 __exportStar(require("./HasUndoPM"), exports);
 __exportStar(require("./FocusCameraPM"), exports);
+__exportStar(require("./QuestionChallenge"), exports);

package/lib/UseCases/QuestionChallenge/SerializeQuestionChallenge.d.ts

@@ -0,0 +1,25 @@
+import { QuestionChallenge, SerializedSystem, StateMachine } from "../../Entities";
+export declare class SerializeQuestionChallenge implements SerializedSystem {
+    private questionChallenge;
+    name: string;
+    seriliziationVersion: number;
+    getSystemState(): object;
+    applySystemState(state: object, version: number): void;
+    applyDefaultState(): void;
+    private applyDataV1;
+    private applyDataV2;
+    constructor(questionChallenge: QuestionChallenge, stateMachine: StateMachine);
+}
+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/UseCases/QuestionChallenge/SerializeQuestionChallenge.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SerializeQuestionChallenge = void 0;
+const Entities_1 = require("../../Entities");
+class SerializeQuestionChallenge {
+    constructor(questionChallenge, stateMachine) {
+        this.questionChallenge = questionChallenge;
+        this.name = "question";
+        this.seriliziationVersion = 2;
+        stateMachine.registerSerializedSystem(this);
+    }
+    getSystemState() {
+        const answers = this.questionChallenge
+            .getAllAnswers()
+            .map((answer) => {
+            return {
+                id: answer.id,
+                feedback: answer.feedbackText,
+                isCorrect: answer.isCorrect,
+                text: answer.text,
+            };
+        });
+        const state = {
+            questionText: this.questionChallenge.text,
+            answers,
+        };
+        return state;
+    }
+    applySystemState(state, version) {
+        if (state && version === 1) {
+            const castState = state;
+            this.applyDataV1(castState);
+        }
+        else if (state && version === 2) {
+            const castState = state;
+            this.applyDataV2(castState);
+        }
+        else {
+            // Unsupported version
+            console.warn(`Unsupported data version ${version} for serialized system ${this.name}. Reverting to default state`);
+            this.applyDefaultState();
+        }
+    }
+    applyDefaultState() {
+        this.questionChallenge.setDefaultState();
+    }
+    applyDataV1(data) {
+        this.questionChallenge.removeAllAnswers();
+        this.questionChallenge.text = "";
+        data.answers.forEach((answerData) => {
+            const answer = Entities_1.makeQuestionChallengeAnswer(answerData.id);
+            answer.text = answerData.text;
+            answer.isCorrect = answerData.isCorrect;
+            answer.feedbackText = answerData.feedback;
+            this.questionChallenge.addAnswer(answer);
+        });
+    }
+    applyDataV2(data) {
+        this.questionChallenge.removeAllAnswers();
+        this.questionChallenge.text = data.questionText;
+        data.answers.forEach((answerData) => {
+            const answer = Entities_1.makeQuestionChallengeAnswer(answerData.id);
+            answer.text = answerData.text;
+            answer.isCorrect = answerData.isCorrect;
+            answer.feedbackText = answerData.feedback;
+            this.questionChallenge.addAnswer(answer);
+        });
+    }
+}
+exports.SerializeQuestionChallenge = SerializeQuestionChallenge;

package/lib/UseCases/QuestionChallenge/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./SerializeQuestionChallenge";
+export * from "./setQuesionChallengeAnswerFeedback";
+export * from "./setQuesionChallengeAnswerText";
+export * from "./toggleQuesionChallengeAnswerIsCorrect";

package/lib/UseCases/QuestionChallenge/index.js

@@ -0,0 +1,16 @@
+"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("./SerializeQuestionChallenge"), exports);
+__exportStar(require("./setQuesionChallengeAnswerFeedback"), exports);
+__exportStar(require("./setQuesionChallengeAnswerText"), exports);
+__exportStar(require("./toggleQuesionChallengeAnswerIsCorrect"), exports);

package/lib/UseCases/QuestionChallenge/setQuesionChallengeAnswerFeedback.d.ts

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

package/lib/UseCases/QuestionChallenge/setQuesionChallengeAnswerFeedback.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/UseCases/QuestionChallenge/setQuesionChallengeAnswerText.d.ts

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

package/lib/UseCases/QuestionChallenge/setQuesionChallengeAnswerText.js

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

package/lib/UseCases/QuestionChallenge/toggleQuesionChallengeAnswerIsCorrect.d.ts

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

package/lib/UseCases/QuestionChallenge/toggleQuesionChallengeAnswerIsCorrect.js

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

package/lib/UseCases/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./setDevicePreview";
 export * from "./FocusCamera";
+export * from "./QuestionChallenge";

package/lib/UseCases/index.js

@@ -12,3 +12,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./setDevicePreview"), exports);
 __exportStar(require("./FocusCamera"), exports);
+__exportStar(require("./QuestionChallenge"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vived/app",
-  "version": "2.14.0",
+  "version": "2.15.0",
   "description": "Public package for the VIVED Learning App system",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",