@vived/app 2.12.0 → 2.15.2

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/FocusCamera/BumpDollyFocusCamera.js

@@ -26,10 +26,10 @@ class BumpDollyFocusCamera {
             this.focusCamera.radius = this.initialRadius + range * percent;
             if (this.pickPoint !== undefined) {
                 const percentChange = this.focusCamera.radius / currentRadius;
-                let pickToTarget = ValueObjects_1.Vector3.subtract(this.focusCamera.target, this.pickPoint);
+                let pickToTarget = ValueObjects_1.Vector3.Subtract(this.focusCamera.target, this.pickPoint);
                 const newLength = pickToTarget.magnitued * percentChange;
-                pickToTarget = ValueObjects_1.Vector3.newVectorOfLength(pickToTarget, newLength);
-                const newTargetPos = ValueObjects_1.Vector3.add(this.pickPoint, pickToTarget);
+                pickToTarget = ValueObjects_1.Vector3.NewVectorOfLength(pickToTarget, newLength);
+                const newTargetPos = ValueObjects_1.Vector3.Add(this.pickPoint, pickToTarget);
                 this.focusCamera.target = newTargetPos;
             }
             if (nomralizedTime >= 1 && this.interval) {

package/lib/UseCases/FocusCamera/PinchDollyFocusCamera.js

@@ -14,10 +14,10 @@ class PinchDollyFocusCamera {
             this.focusCamera.radius = currentRadius - deltaRadius;
             if (this.pickPoint !== undefined) {
                 const percentChange = this.focusCamera.radius / currentRadius;
-                let pickToTarget = ValueObjects_1.Vector3.subtract(this.focusCamera.target, this.pickPoint);
+                let pickToTarget = ValueObjects_1.Vector3.Subtract(this.focusCamera.target, this.pickPoint);
                 const newLength = pickToTarget.magnitued * percentChange;
-                pickToTarget = ValueObjects_1.Vector3.newVectorOfLength(pickToTarget, newLength);
-                const newTargetPos = ValueObjects_1.Vector3.add(this.pickPoint, pickToTarget);
+                pickToTarget = ValueObjects_1.Vector3.NewVectorOfLength(pickToTarget, newLength);
+                const newTargetPos = ValueObjects_1.Vector3.Add(this.pickPoint, pickToTarget);
                 this.focusCamera.target = newTargetPos;
             }
             this.previousDistanceBetweenTouches = distanceBetweenTouches;

package/lib/UseCases/FocusCamera/PixelDollyFocusCamera.js

@@ -14,10 +14,10 @@ class PixelDollyFocusCamera {
             this.focusCamera.radius = currentRadius - deltaRadius;
             if (this.pickPoint !== undefined) {
                 const percentChange = this.focusCamera.radius / currentRadius;
-                let pickToTarget = ValueObjects_1.Vector3.subtract(this.focusCamera.target, this.pickPoint);
+                let pickToTarget = ValueObjects_1.Vector3.Subtract(this.focusCamera.target, this.pickPoint);
                 const newLength = pickToTarget.magnitued * percentChange;
-                pickToTarget = ValueObjects_1.Vector3.newVectorOfLength(pickToTarget, newLength);
-                const newTargetPos = ValueObjects_1.Vector3.add(this.pickPoint, pickToTarget);
+                pickToTarget = ValueObjects_1.Vector3.NewVectorOfLength(pickToTarget, newLength);
+                const newTargetPos = ValueObjects_1.Vector3.Add(this.pickPoint, pickToTarget);
                 this.focusCamera.target = newTargetPos;
             }
             this.previousPixelPosition = pixelPosition;

package/lib/UseCases/FocusCamera/PixelOrbitFocusCamera.js

@@ -10,7 +10,7 @@ class PixelOrbitFocusCamera {
             if (!this.previousPixelPos) {
                 throw new Error("[PixelOrbitFocusCamera] You must initialize first!");
             }
-            const pixelChange = ValueObjects_1.Vector2.subtract(pixelPosition, this.previousPixelPos);
+            const pixelChange = ValueObjects_1.Vector2.Subtract(pixelPosition, this.previousPixelPos);
             this.focusCamera.alpha += pixelChange.x * this.sensitivity;
             this.focusCamera.beta += pixelChange.y * this.sensitivity;
             this.previousPixelPos = pixelPosition;

package/lib/UseCases/FocusCamera/PixelPlanePanFocusCamera.js

@@ -16,7 +16,7 @@ class PixelPlanePanFocusCamera {
             const p2 = this.plane.intersectLine(finalRay);
             if (!p1 || !p2)
                 return;
-            const delta = ValueObjects_1.Vector3.subtract(p2, p1);
+            const delta = ValueObjects_1.Vector3.Subtract(p2, p1);
             const currentTarget = this.focusCamera.target;
             const newTarget = new ValueObjects_1.Vector3(currentTarget.x - delta.x, currentTarget.y - delta.y, currentTarget.z - delta.z);
             this.focusCamera.target = new ValueObjects_1.Vector3(newTarget.x, newTarget.y, newTarget.z);

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/lib/ValueObjects/Angle.d.ts

@@ -1,6 +1,6 @@
 export declare class Angle {
-    static fromDegrees(degrees: number): Angle;
-    static fromRadians(radians: number): Angle;
+    static FromDegrees(degrees: number): Angle;
+    static FromRadians(radians: number): Angle;
     private _degrees;
     get degrees(): number;
     get radians(): number;

package/lib/ValueObjects/Angle.js

@@ -6,10 +6,10 @@ class Angle {
         this._degrees = 0;
         this._degrees = degrees;
     }
-    static fromDegrees(degrees) {
+    static FromDegrees(degrees) {
         return new Angle(degrees);
     }
-    static fromRadians(radians) {
+    static FromRadians(radians) {
         return new Angle(radians * 180 / Math.PI);
     }
     get degrees() {

package/lib/ValueObjects/Color.d.ts

@@ -5,14 +5,10 @@ export declare class Color {
     static Hex(hex: string): Color;
     static X11(name: string): Color;
     static Equal(a: Color, b: Color): boolean;
-    private _r;
-    private _g;
-    private _b;
-    private _a;
-    get r(): number;
-    get g(): number;
-    get b(): number;
-    get a(): number;
+    readonly r: number;
+    readonly g: number;
+    readonly b: number;
+    readonly a: number;
     get rPercent(): number;
     get gPercent(): number;
     get bPercent(): number;