@vived/app 2.11.1 → 2.15.0

package/lib/Entities/ParametricPlane.js

@@ -1,34 +1,34 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ParametricPlane = void 0;
-const Vector3_1 = require("./Vector3");
+const Vector3_1 = require("../ValueObjects/Vector3");
 class ParametricPlane {
     constructor(point, normal) {
-        this.point = point.copy();
-        this.normal = normal.copy();
+        this.point = point;
+        this.normal = normal;
     }
     static FromPointNormal(point, normal) {
         return new ParametricPlane(point, normal);
     }
     static FromThreePoints(A, B, C) {
         const point = A;
-        const AB = B.subtract(A);
-        const AC = C.subtract(A);
-        const normal = AB.cross(AC);
+        const AB = Vector3_1.Vector3.subtract(B, A);
+        const AC = Vector3_1.Vector3.subtract(C, A);
+        const normal = Vector3_1.Vector3.cross(AB, AC);
         return new ParametricPlane(point, normal);
     }
     static XY() {
-        const p = Vector3_1.Vector3.Zero();
+        const p = Vector3_1.Vector3.zero();
         const n = new Vector3_1.Vector3(0, 0, 1);
         return new ParametricPlane(p, n);
     }
     static ZX() {
-        const p = Vector3_1.Vector3.Zero();
+        const p = Vector3_1.Vector3.zero();
         const n = new Vector3_1.Vector3(0, 1, 0);
         return new ParametricPlane(p, n);
     }
     static YZ() {
-        const p = Vector3_1.Vector3.Zero();
+        const p = Vector3_1.Vector3.zero();
         const n = new Vector3_1.Vector3(1, 0, 0);
         return new ParametricPlane(p, n);
     }
@@ -36,7 +36,7 @@ class ParametricPlane {
         const a = this.normal.x;
         const b = this.normal.y;
         const c = this.normal.z;
-        let d = this.point.dot(this.normal);
+        let d = Vector3_1.Vector3.dot(this.point, this.normal);
         if (d !== 0) {
             d *= -1;
         }

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/TouchInput.d.ts

@@ -1,9 +1,20 @@
-import { Vector2 } from ".";
+import { Vector2 } from "../ValueObjects";
+export interface TouchInputEvent {
+    touchCount: number;
+    touchCenter: Vector2;
+    touches: TouchData[];
+    event: TouchEvent;
+}
+export interface TouchData {
+    id: number;
+    position: Vector2;
+    touch?: Touch;
+}
 export interface TouchController {
-    onTouchStart?: (e: TouchEvent) => void;
-    onTouchMove?: (e: TouchEvent) => void;
-    onTouchEnd?: (e: TouchEvent) => void;
-    onTouchCancel?: (e: TouchEvent) => void;
+    onTouchStart?: (e: TouchInputEvent) => void;
+    onTouchMove?: (e: TouchInputEvent) => void;
+    onTouchEnd?: (e: TouchInputEvent) => void;
+    onTouchCancel?: (e: TouchInputEvent) => void;
 }
 export interface TouchInput {
     eventElement: HTMLElement | undefined;
@@ -11,9 +22,6 @@ export interface TouchInput {
     setEventElement: (eventElement: HTMLElement) => void;
     clearInputElement: () => void;
     updateInputElementBounds: () => void;
-    getTouchOffsetPosition: (touch: Touch) => Vector2;
-    getDistatnceBetweenTouches: (touch1: Touch, touch2: Touch) => number;
-    getTouchsCenter: (touches: TouchList) => Vector2;
     registerController: (controller: TouchController) => void;
     removeController: (controller: TouchController) => void;
 }

package/lib/Entities/TouchInput.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeTouchInput = void 0;
-const _1 = require(".");
+const ValueObjects_1 = require("../ValueObjects");
 function makeTouchInput() {
     return new TouchInputImp();
 }
@@ -18,31 +18,11 @@ class TouchInputImp {
         this.getTouchOffsetPosition = (touch) => {
             if (!this.eventElementBounds) {
                 console.warn("No target bounds");
-                return _1.Vector2.Zero();
+                return ValueObjects_1.Vector2.zero();
             }
             const x = touch.clientX - this.eventElementBounds.x;
             const y = touch.clientY - this.eventElementBounds.y;
-            return new _1.Vector2(x, y);
-        };
-        this.getDistatnceBetweenTouches = (touch1, touch2) => {
-            const t1 = this.getTouchOffsetPosition(touch1);
-            const t2 = this.getTouchOffsetPosition(touch2);
-            const delta = t2.subtract(t1);
-            return delta.magnitued;
-        };
-        this.getTouchsCenter = (touches) => {
-            const touchCount = touches.length;
-            if (touchCount === 0)
-                return _1.Vector2.Zero();
-            let sumX = 0;
-            let sumY = 0;
-            for (let i = 0; i < touchCount; i++) {
-                const touch = touches[i];
-                const touchPos = this.getTouchOffsetPosition(touch);
-                sumX += touchPos.x;
-                sumY += touchPos.y;
-            }
-            return new _1.Vector2(sumX / touches.length, sumY / touches.length);
+            return new ValueObjects_1.Vector2(x, y);
         };
         this.setEventElement = (eventElement) => {
             if (this._eventElement)
@@ -56,33 +36,37 @@ class TouchInputImp {
         };
         this.onTouchStart = (e) => {
             e.preventDefault();
+            const touchInput = this.createTouchInputEvent(e);
             this.controllers.forEach((c) => {
                 if (c.onTouchStart) {
-                    c.onTouchStart(e);
+                    c.onTouchStart(touchInput);
                 }
             });
         };
         this.onTouchMove = (e) => {
             e.preventDefault();
+            const touchInput = this.createTouchInputEvent(e);
             this.controllers.forEach((c) => {
                 if (c.onTouchMove) {
-                    c.onTouchMove(e);
+                    c.onTouchMove(touchInput);
                 }
             });
         };
         this.onTouchEnd = (e) => {
             e.preventDefault();
+            const touchInput = this.createTouchInputEvent(e);
             this.controllers.forEach((c) => {
                 if (c.onTouchEnd) {
-                    c.onTouchEnd(e);
+                    c.onTouchEnd(touchInput);
                 }
             });
         };
         this.onTouchCancel = (e) => {
             e.preventDefault();
+            const touchInput = this.createTouchInputEvent(e);
             this.controllers.forEach((c) => {
                 if (c.onTouchCancel) {
-                    c.onTouchCancel(e);
+                    c.onTouchCancel(touchInput);
                 }
             });
         };
@@ -108,4 +92,49 @@ class TouchInputImp {
     get eventElement() {
         return this._eventElement;
     }
+    createTouchInputEvent(event) {
+        const touches = [];
+        const touchCount = event.touches.length;
+        let minX = 0;
+        let maxX = 0;
+        let minY = 0;
+        let maxY = 0;
+        for (let i = 0; i < touchCount; i++) {
+            const touch = event.touches[i];
+            const position = this.getTouchOffsetPosition(touch);
+            touches.push({
+                id: touch.identifier,
+                touch,
+                position,
+            });
+            if (i === 0) {
+                minX = position.x;
+                maxX = position.x;
+                minY = position.y;
+                maxY = position.y;
+            }
+            else {
+                minX = Math.min(minX, position.x);
+                maxX = Math.max(maxX, position.x);
+                minY = Math.min(minY, position.y);
+                maxY = Math.max(maxY, position.y);
+            }
+        }
+        let cntX = 0;
+        let cntY = 0;
+        if (touchCount === 1) {
+            cntX = maxX;
+            cntY = maxY;
+        }
+        else {
+            cntX = minX + (maxX - minX) / 2;
+            cntY = minY + (maxY - minY) / 2;
+        }
+        return {
+            touchCenter: new ValueObjects_1.Vector2(cntX, cntY),
+            touchCount,
+            touches,
+            event,
+        };
+    }
 }

package/lib/Entities/index.d.ts

@@ -1,9 +1,7 @@
 export * from "./Babylon";
 export * from "./BaseApp";
-export * from "./Color";
 export * from "./DevicePreview";
 export * from "./KeyboardInput";
-export * from "./LineSegment2D";
 export * from "./MemoizedBoolean";
 export * from "./MemoizedNumber";
 export * from "./MemoizedString";
@@ -11,11 +9,9 @@ export * from "./MemoizedVector2";
 export * from "./MemoizedVector3";
 export * from "./ObserverList";
 export * from "./FocusCamera";
-export * from "./ParametricLine";
-export * from "./ParametricPlane";
 export * from "./StateMachine";
 export * from "./UndoRedo";
-export * from "./Vector2";
-export * from "./Vector3";
 export * from "./MouseInput";
 export * from "./TouchInput";
+export * from "./QuestionChallengeAnswer";
+export * from "./QuestionChallenge";

package/lib/Entities/index.js

@@ -12,10 +12,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./Babylon"), exports);
 __exportStar(require("./BaseApp"), exports);
-__exportStar(require("./Color"), exports);
 __exportStar(require("./DevicePreview"), exports);
 __exportStar(require("./KeyboardInput"), exports);
-__exportStar(require("./LineSegment2D"), exports);
 __exportStar(require("./MemoizedBoolean"), exports);
 __exportStar(require("./MemoizedNumber"), exports);
 __exportStar(require("./MemoizedString"), exports);
@@ -23,11 +21,9 @@ __exportStar(require("./MemoizedVector2"), exports);
 __exportStar(require("./MemoizedVector3"), exports);
 __exportStar(require("./ObserverList"), exports);
 __exportStar(require("./FocusCamera"), exports);
-__exportStar(require("./ParametricLine"), exports);
-__exportStar(require("./ParametricPlane"), exports);
 __exportStar(require("./StateMachine"), exports);
 __exportStar(require("./UndoRedo"), exports);
-__exportStar(require("./Vector2"), exports);
-__exportStar(require("./Vector3"), exports);
 __exportStar(require("./MouseInput"), exports);
 __exportStar(require("./TouchInput"), exports);
+__exportStar(require("./QuestionChallengeAnswer"), exports);
+__exportStar(require("./QuestionChallenge"), exports);

package/lib/PresentationManagers/FocusCameraPM.d.ts

@@ -1,4 +1,5 @@
-import { FocusCamera, Vector3 } from "../Entities";
+import { FocusCamera } from "../Entities";
+import { Vector3 } from "../ValueObjects";
 export interface FocusCameraVM {
     alphaEuler: Vector3;
     betaEuler: Vector3;

package/lib/PresentationManagers/FocusCameraPM.js

@@ -1,17 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FocusCameraPM = void 0;
-const Entities_1 = require("../Entities");
 const Utilities_1 = require("../Utilities");
+const ValueObjects_1 = require("../ValueObjects");
 class FocusCameraPM {
     constructor(orbitCamera, view) {
         this.doUpdateView = () => {
             const { alpha, beta, radius, target } = this.orbitCam;
             const alphaRadians = Utilities_1.degreesToRadians(alpha);
-            const alphaEuler = new Entities_1.Vector3(0, alphaRadians, 0);
+            const alphaEuler = new ValueObjects_1.Vector3(0, alphaRadians, 0);
             const betaRadians = Utilities_1.degreesToRadians(beta);
-            const betaEuler = new Entities_1.Vector3(betaRadians, 0, 0);
-            const cameraLocalPosition = new Entities_1.Vector3(0, 0, -radius);
+            const betaEuler = new ValueObjects_1.Vector3(betaRadians, 0, 0);
+            const cameraLocalPosition = new ValueObjects_1.Vector3(0, 0, -radius);
             this.view({
                 alphaEuler,
                 betaEuler,

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;