@vived/app 4.6.0 → 4.6.1

package/lib/UseCases/Handlers/SetDevicePreviewBase.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetDevicePreviewBase = void 0;
+const Entities_1 = require("../../Entities");
+class SetDevicePreviewBase extends Entities_1.RequestHandler {
+    constructor(handler) {
+        super();
+        this.requestType = "SET_DEVICE_PREVIEW";
+        this.payloadVersion = 1;
+        this.action = (px, py) => {
+            throw new Entities_1.ActionNotImplemented(this.requestType);
+        };
+        this.handleRequest = (version, payload) => {
+            if (version === this.payloadVersion) {
+                const { x, y } = this.castPayloadV1(payload);
+                this.action(x, y);
+            }
+            else {
+                throw new Entities_1.UnsupportedRequestVerion(this.requestType, version);
+            }
+        };
+        handler.registerRequestHandler(this);
+    }
+    castPayloadV1(payload) {
+        const castPayload = payload;
+        if (castPayload.x === undefined || castPayload.y === undefined) {
+            throw new Entities_1.UnableToParsePayload(this.requestType, 1, JSON.stringify(payload));
+        }
+        return castPayload;
+    }
+}
+exports.SetDevicePreviewBase = SetDevicePreviewBase;

package/lib/UseCases/Handlers/SetIsAuthoringBase.d.ts

@@ -0,0 +1,10 @@
+import { AppHandler, RequestHandler } from "../../Entities";
+export declare type SetIsAuthoringAction = (isAuthoring: boolean) => void;
+export declare class SetIsAuthoringBase extends RequestHandler {
+    readonly requestType = "SET_IS_AUTHORING";
+    readonly payloadVersion = 1;
+    action: SetIsAuthoringAction;
+    handleRequest: (version: number, payload: unknown) => void;
+    private castPayloadV1;
+    constructor(handler: AppHandler);
+}

package/lib/UseCases/Handlers/SetIsAuthoringBase.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetIsAuthoringBase = void 0;
+const Entities_1 = require("../../Entities");
+class SetIsAuthoringBase extends Entities_1.RequestHandler {
+    constructor(handler) {
+        super();
+        this.requestType = "SET_IS_AUTHORING";
+        this.payloadVersion = 1;
+        this.action = (show) => {
+            throw new Entities_1.ActionNotImplemented(this.requestType);
+        };
+        this.handleRequest = (version, payload) => {
+            if (version === this.payloadVersion) {
+                const { isAuthoring: setIsAuthoring } = this.castPayloadV1(payload);
+                this.action(setIsAuthoring);
+            }
+            else {
+                throw new Entities_1.UnsupportedRequestVerion(this.requestType, version);
+            }
+        };
+        handler.registerRequestHandler(this);
+    }
+    castPayloadV1(payload) {
+        const castPayload = payload;
+        if (castPayload.isAuthoring === undefined) {
+            throw new Entities_1.UnableToParsePayload(this.requestType, 1, JSON.stringify(payload));
+        }
+        return castPayload;
+    }
+}
+exports.SetIsAuthoringBase = SetIsAuthoringBase;

package/lib/UseCases/Handlers/ShowBabylonInspectorBase.d.ts

@@ -0,0 +1,10 @@
+import { AppHandler, RequestHandler } from "../../Entities";
+export declare type ShowBabylonInspectorAction = (show: boolean) => void;
+export declare class ShowBabylonInspectorBase extends RequestHandler {
+    readonly requestType = "SHOW_BABYLON_INSPECTOR";
+    readonly payloadVersion = 1;
+    action: ShowBabylonInspectorAction;
+    handleRequest: (version: number, payload: unknown) => void;
+    private castPayloadV1;
+    constructor(handler: AppHandler);
+}

package/lib/UseCases/Handlers/ShowBabylonInspectorBase.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShowBabylonInspectorBase = void 0;
+const Entities_1 = require("../../Entities");
+class ShowBabylonInspectorBase extends Entities_1.RequestHandler {
+    constructor(handler) {
+        super();
+        this.requestType = "SHOW_BABYLON_INSPECTOR";
+        this.payloadVersion = 1;
+        this.action = (show) => {
+            throw new Entities_1.ActionNotImplemented(this.requestType);
+        };
+        this.handleRequest = (version, payload) => {
+            if (version === this.payloadVersion) {
+                const { showBabylonInspector } = this.castPayloadV1(payload);
+                this.action(showBabylonInspector);
+            }
+            else {
+                throw new Entities_1.UnsupportedRequestVerion(this.requestType, version);
+            }
+        };
+        handler.registerRequestHandler(this);
+    }
+    castPayloadV1(payload) {
+        const castPayload = payload;
+        if (castPayload.showBabylonInspector === undefined) {
+            throw new Entities_1.UnableToParsePayload(this.requestType, 1, JSON.stringify(payload));
+        }
+        return castPayload;
+    }
+}
+exports.ShowBabylonInspectorBase = ShowBabylonInspectorBase;

package/lib/UseCases/Handlers/StartAppBase.d.ts

@@ -0,0 +1,10 @@
+import { AppHandler, RequestHandler } from "../../Entities";
+export declare type StartAppAction = (container: HTMLElement) => void;
+export declare class StartAppBase extends RequestHandler {
+    readonly requestType = "START_APP";
+    readonly payloadVersion = 2;
+    action: StartAppAction;
+    handleRequest: (version: number, payload: unknown) => void;
+    private castPayloadV2;
+    constructor(handler: AppHandler);
+}

package/lib/UseCases/Handlers/StartAppBase.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StartAppBase = void 0;
+const Entities_1 = require("../../Entities");
+class StartAppBase extends Entities_1.RequestHandler {
+    constructor(handler) {
+        super();
+        this.requestType = "START_APP";
+        this.payloadVersion = 2;
+        this.action = (container) => {
+            throw new Entities_1.ActionNotImplemented(this.requestType);
+        };
+        this.handleRequest = (version, payload) => {
+            if (version === this.payloadVersion) {
+                const { container } = this.castPayloadV2(payload);
+                this.action(container);
+            }
+            else {
+                throw new Entities_1.UnsupportedRequestVerion(this.requestType, version);
+            }
+        };
+        handler.registerRequestHandler(this);
+    }
+    castPayloadV2(payload) {
+        const castPayload = payload;
+        if (castPayload.container === undefined) {
+            throw new Entities_1.UnableToParsePayload(this.requestType, 1, JSON.stringify(payload));
+        }
+        return castPayload;
+    }
+}
+exports.StartAppBase = StartAppBase;

package/lib/UseCases/Handlers/StartZSpaceBase.d.ts

@@ -0,0 +1,10 @@
+import { AppHandler, RequestHandler } from "../../Entities";
+export declare type StartZSpaceAction = (session: any, emulate: boolean) => void;
+export declare class StartZSpaceBase extends RequestHandler {
+    readonly requestType = "START_ZSPACE";
+    readonly payloadVersion = 3;
+    action: StartZSpaceAction;
+    handleRequest: (version: number, payload: unknown) => void;
+    private castPayloadV3;
+    constructor(handler: AppHandler);
+}

package/lib/UseCases/Handlers/StartZSpaceBase.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StartZSpaceBase = void 0;
+const Entities_1 = require("../../Entities");
+class StartZSpaceBase extends Entities_1.RequestHandler {
+    constructor(handler) {
+        super();
+        this.requestType = "START_ZSPACE";
+        this.payloadVersion = 3;
+        this.action = () => {
+            throw new Entities_1.ActionNotImplemented(this.requestType);
+        };
+        this.handleRequest = (version, payload) => {
+            if (version === this.payloadVersion) {
+                const { session, emulate } = this.castPayloadV3(payload);
+                this.action(session, emulate);
+            }
+            else {
+                throw new Entities_1.UnsupportedRequestVerion(this.requestType, version);
+            }
+        };
+        handler.registerRequestHandler(this);
+    }
+    castPayloadV3(payload) {
+        const castPayload = payload;
+        if (castPayload.session === undefined) {
+            throw new Entities_1.UnableToParsePayload(this.requestType, 1, JSON.stringify(payload));
+        }
+        if (castPayload.emulate === undefined) {
+            castPayload.emulate = false;
+        }
+        return castPayload;
+    }
+}
+exports.StartZSpaceBase = StartZSpaceBase;

package/lib/UseCases/Handlers/StopAppBase.d.ts

@@ -0,0 +1,8 @@
+import { AppHandler, RequestHandler } from "../../Entities";
+export declare class StopAppBase extends RequestHandler {
+    readonly requestType = "STOP_APP";
+    readonly payloadVersion = 1;
+    action: () => void;
+    handleRequest: (version: number) => void;
+    constructor(handler: AppHandler);
+}

package/lib/UseCases/Handlers/StopAppBase.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StopAppBase = void 0;
+const Entities_1 = require("../../Entities");
+class StopAppBase extends Entities_1.RequestHandler {
+    constructor(handler) {
+        super();
+        this.requestType = "STOP_APP";
+        this.payloadVersion = 1;
+        this.action = () => {
+            throw new Entities_1.ActionNotImplemented(this.requestType);
+        };
+        this.handleRequest = (version) => {
+            if (version === this.payloadVersion) {
+                this.action();
+            }
+            else {
+                throw new Entities_1.UnsupportedRequestVerion(this.requestType, version);
+            }
+        };
+        handler.registerRequestHandler(this);
+    }
+}
+exports.StopAppBase = StopAppBase;

package/lib/UseCases/Handlers/StopZSpaceBase.d.ts

@@ -0,0 +1,8 @@
+import { AppHandler, RequestHandler } from "../../Entities";
+export declare class StopZSpaceBase extends RequestHandler {
+    readonly requestType = "STOP_ZSPACE";
+    readonly payloadVersion = 1;
+    action: () => void;
+    handleRequest: (version: number) => void;
+    constructor(handler: AppHandler);
+}

package/lib/UseCases/Handlers/StopZSpaceBase.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StopZSpaceBase = void 0;
+const Entities_1 = require("../../Entities");
+class StopZSpaceBase extends Entities_1.RequestHandler {
+    constructor(handler) {
+        super();
+        this.requestType = "STOP_ZSPACE";
+        this.payloadVersion = 1;
+        this.action = () => {
+            throw new Entities_1.ActionNotImplemented(this.requestType);
+        };
+        this.handleRequest = (version) => {
+            if (version === this.payloadVersion) {
+                this.action();
+            }
+            else {
+                throw new Entities_1.UnsupportedRequestVerion(this.requestType, version);
+            }
+        };
+        handler.registerRequestHandler(this);
+    }
+}
+exports.StopZSpaceBase = StopZSpaceBase;

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

@@ -0,0 +1,9 @@
+export * from "./DisposeAppBase";
+export * from "./SetAppStateBase";
+export * from "./SetDevicePreviewBase";
+export * from "./SetIsAuthoringBase";
+export * from "./StartZSpaceBase";
+export * from "./ShowBabylonInspectorBase";
+export * from "./StartAppBase";
+export * from "./StopAppBase";
+export * from "./StopZSpaceBase";

package/lib/UseCases/Handlers/index.js

@@ -0,0 +1,21 @@
+"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("./DisposeAppBase"), exports);
+__exportStar(require("./SetAppStateBase"), exports);
+__exportStar(require("./SetDevicePreviewBase"), exports);
+__exportStar(require("./SetIsAuthoringBase"), exports);
+__exportStar(require("./StartZSpaceBase"), exports);
+__exportStar(require("./ShowBabylonInspectorBase"), exports);
+__exportStar(require("./StartAppBase"), exports);
+__exportStar(require("./StopAppBase"), exports);
+__exportStar(require("./StopZSpaceBase"), exports);

package/lib/UseCases/HoverLabels/SerializeAllowHoverLabel.d.ts

@@ -0,0 +1,14 @@
+import { HoverLabels, SerializedSystem, StateMachine } from "../../Entities";
+export declare class SerializeAllowHoverLabel implements SerializedSystem {
+    private hoverLabels;
+    name: string;
+    seriliziationVersion: number;
+    getSystemState(): object;
+    applySystemState(state: object, version: number): void;
+    applyDefaultState(): void;
+    private applyDataV1;
+    constructor(hoverLabels: HoverLabels, stateMachine: StateMachine);
+}
+export interface AllowHoverLabelV1 {
+    allow: boolean;
+}

package/lib/UseCases/HoverLabels/SerializeAllowHoverLabel.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SerializeAllowHoverLabel = void 0;
+class SerializeAllowHoverLabel {
+    constructor(hoverLabels, stateMachine) {
+        this.hoverLabels = hoverLabels;
+        this.name = "allowHoverLabel";
+        this.seriliziationVersion = 1;
+        stateMachine.registerSerializedSystem(this);
+    }
+    getSystemState() {
+        const state = {
+            allow: this.hoverLabels.allowHoverLabels
+        };
+        return state;
+    }
+    applySystemState(state, version) {
+        if (state && version === 1) {
+            const castState = state;
+            this.applyDataV1(castState);
+        }
+        else {
+            // Unsupported version
+            console.warn(`Unsupported data version ${version} for serialized system ${this.name}. Reverting to default state`);
+            this.applyDefaultState();
+        }
+    }
+    applyDefaultState() {
+        this.hoverLabels.allowHoverLabels = true;
+    }
+    applyDataV1(data) {
+        this.hoverLabels.allowHoverLabels = data.allow;
+    }
+}
+exports.SerializeAllowHoverLabel = SerializeAllowHoverLabel;

package/lib/UseCases/HoverLabels/trySetHoverLabel.d.ts

@@ -0,0 +1,3 @@
+import { Babylon, HoverLabels } from "../../Entities";
+import { Vector2 } from "../../ValueObjects";
+export declare function makeTrySetHoverLabel(hoverLabels: HoverLabels, babylon: Babylon): (position: Vector2) => void;

package/lib/UseCases/HoverLabels/trySetHoverLabel.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeTrySetHoverLabel = void 0;
+function makeTrySetHoverLabel(hoverLabels, babylon) {
+    return function trySetHoverLabel(position) {
+        const sceneObjectID = babylon.sceneObjectPixelPick(position);
+        if (sceneObjectID) {
+            hoverLabels.showLabelForSceneObject(sceneObjectID, position);
+        }
+    };
+}
+exports.makeTrySetHoverLabel = makeTrySetHoverLabel;

package/lib/UseCases/LerpVector3.d.ts

@@ -0,0 +1,26 @@
+import { Vector3 } from "../ValueObjects";
+export interface LerpVector3DTO {
+    initial: Vector3;
+    final: Vector3;
+    durationMS: number;
+    tickInterval?: number;
+    ease?: (percent: number) => number;
+    onTick?: (v: Vector3) => void;
+    onComplete?: () => void;
+    onCanceled?: () => void;
+}
+export declare class LerpVector3 {
+    private initial;
+    private final;
+    private durationMS;
+    private tickInterval;
+    private ease;
+    private onTick;
+    private onComplete;
+    private onCanceled;
+    private interval?;
+    private chrono;
+    cancel: () => void;
+    private tick;
+    constructor(lerpParams: LerpVector3DTO);
+}

package/lib/UseCases/LerpVector3.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LerpVector3 = void 0;
+const ValueObjects_1 = require("../ValueObjects");
+class LerpVector3 {
+    constructor(lerpParams) {
+        this.tickInterval = 10;
+        this.ease = (p) => p;
+        this.onTick = () => {
+            // Override as needed
+        };
+        this.onComplete = () => {
+            // Override as needed
+        };
+        this.onCanceled = () => {
+            // Override as needed
+        };
+        this.chrono = 0;
+        this.cancel = () => {
+            if (this.interval) {
+                clearInterval(this.interval);
+                this.onCanceled();
+                this.interval = undefined;
+            }
+        };
+        this.tick = () => {
+            this.chrono = this.chrono + this.tickInterval;
+            let nomralizedTime = this.chrono / this.durationMS;
+            if (nomralizedTime > 1) {
+                nomralizedTime = 1;
+            }
+            const percent = this.ease(nomralizedTime);
+            const lerpedVec = ValueObjects_1.Vector3.Lerp(this.initial, this.final, percent);
+            this.onTick(lerpedVec);
+            if (nomralizedTime >= 1 && this.interval) {
+                clearInterval(this.interval);
+                this.interval = undefined;
+                if (this.onComplete) {
+                    this.onComplete();
+                }
+            }
+        };
+        this.initial = lerpParams.initial;
+        this.final = lerpParams.final;
+        this.durationMS = lerpParams.durationMS;
+        if (lerpParams.onTick) {
+            this.onTick = lerpParams.onTick;
+        }
+        if (lerpParams.tickInterval) {
+            this.tickInterval = lerpParams.tickInterval;
+        }
+        if (lerpParams.onComplete) {
+            this.onComplete = lerpParams.onComplete;
+        }
+        if (lerpParams.ease) {
+            this.ease = lerpParams.ease;
+        }
+        if (lerpParams.onCanceled) {
+            this.onCanceled = lerpParams.onCanceled;
+        }
+        this.interval = setInterval(() => {
+            this.tick();
+        }, this.tickInterval);
+    }
+}
+exports.LerpVector3 = LerpVector3;

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;