@vived/app 4.1.0 → 4.3.0

package/lib/PresentationManagers/FramedScreenContainerPM.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultFramedContainerVM = exports.FramedContainerPM = void 0;
+class FramedContainerPM {
+    constructor(containerID, framedScreen, updateView) {
+        this.updateView = updateView;
+        this.doUpdateView = () => {
+            const vm = Object.assign({}, exports.defaultFramedContainerVM);
+            if (!this.container) {
+                this.updateView(vm);
+                return;
+            }
+            vm.height = this.container.size.y;
+            vm.width = this.container.size.x;
+            vm.top = this.container.position.y;
+            vm.left = this.container.position.x;
+            vm.show = this.container.show;
+            if (!this.vmHadChanged(vm))
+                return;
+            this.updateView(vm);
+            this.lastVM = vm;
+        };
+        this.vmHadChanged = (newVM) => {
+            if (this.lastVM === undefined)
+                return true;
+            if (this.lastVM.height === newVM.height &&
+                this.lastVM.width === newVM.width &&
+                this.lastVM.top === newVM.top &&
+                this.lastVM.left === newVM.left &&
+                this.lastVM.show === newVM.show) {
+                return false;
+            }
+            else {
+                return true;
+            }
+        };
+        this.dispose = () => {
+            var _a;
+            (_a = this.container) === null || _a === void 0 ? void 0 : _a.removeObserver(this.doUpdateView);
+        };
+        this.container = framedScreen.getContainerByID(containerID);
+        if (this.container) {
+            this.container.addObserver(this.doUpdateView);
+        }
+        this.doUpdateView();
+    }
+}
+exports.FramedContainerPM = FramedContainerPM;
+exports.defaultFramedContainerVM = {
+    height: 0,
+    left: 0,
+    top: 0,
+    width: 0,
+    show: false
+};

package/lib/PresentationManagers/HasRedoPM.d.ts

@@ -0,0 +1,9 @@
+import { UndoRedo } from "../Entities";
+export declare class HasRedoPM {
+    updateView: (hasRedo: boolean) => void;
+    private undoRedo;
+    private lastValue?;
+    private onChange;
+    dispose(): void;
+    constructor(undoRedo: UndoRedo, updateView: (hasRedo: boolean) => void);
+}

package/lib/PresentationManagers/HasRedoPM.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HasRedoPM = void 0;
+class HasRedoPM {
+    constructor(undoRedo, updateView) {
+        this.updateView = updateView;
+        this.onChange = () => {
+            const currentVal = this.undoRedo.hasRedo;
+            if (this.lastValue === currentVal)
+                return;
+            this.updateView(currentVal);
+            this.lastValue = currentVal;
+        };
+        this.undoRedo = undoRedo;
+        this.onChange();
+        this.undoRedo.addObserver(this.onChange);
+    }
+    dispose() {
+        this.undoRedo.removeObserver(this.onChange);
+    }
+}
+exports.HasRedoPM = HasRedoPM;

package/lib/PresentationManagers/HasUndoPM.d.ts

@@ -0,0 +1,9 @@
+import { UndoRedo } from "../Entities";
+export declare class HasUndoPM {
+    updateView: (hasUndo: boolean) => void;
+    private undoRedo;
+    private lastValue?;
+    private onChange;
+    dispose(): void;
+    constructor(undoRedo: UndoRedo, updateView: (hasUndo: boolean) => void);
+}

package/lib/PresentationManagers/HasUndoPM.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HasUndoPM = void 0;
+class HasUndoPM {
+    constructor(undoRedo, updateView) {
+        this.updateView = updateView;
+        this.onChange = () => {
+            const currentVal = this.undoRedo.hasUndo;
+            if (this.lastValue === currentVal)
+                return;
+            this.updateView(currentVal);
+            this.lastValue = currentVal;
+        };
+        this.undoRedo = undoRedo;
+        this.onChange();
+        this.undoRedo.addObserver(this.onChange);
+    }
+    dispose() {
+        this.undoRedo.removeObserver(this.onChange);
+    }
+}
+exports.HasUndoPM = HasUndoPM;

package/lib/PresentationManagers/HoverLabels/AllowHoverLabelPM.d.ts

@@ -0,0 +1,9 @@
+import { HoverLabels } from "../../Entities";
+import { PresentionManager } from "../PresentationManager";
+export declare class AllowHoverLabelPM extends PresentionManager {
+    private hoverLabel;
+    private updateView;
+    private lastState?;
+    doUpdateView: () => void;
+    constructor(hoverLabel: HoverLabels, updateView: (allow: boolean) => void);
+}

package/lib/PresentationManagers/HoverLabels/AllowHoverLabelPM.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AllowHoverLabelPM = void 0;
+const PresentationManager_1 = require("../PresentationManager");
+class AllowHoverLabelPM extends PresentationManager_1.PresentionManager {
+    constructor(hoverLabel, updateView) {
+        super(hoverLabel);
+        this.hoverLabel = hoverLabel;
+        this.updateView = updateView;
+        this.doUpdateView = () => {
+            if (this.lastState === this.hoverLabel.allowHoverLabels)
+                return;
+            this.updateView(this.hoverLabel.allowHoverLabels);
+            this.lastState = this.hoverLabel.allowHoverLabels;
+        };
+        this.doUpdateView();
+    }
+}
+exports.AllowHoverLabelPM = AllowHoverLabelPM;

package/lib/PresentationManagers/HoverLabels/HoverLabelPM.d.ts

@@ -0,0 +1,17 @@
+import { HoverLabels } from "../../Entities";
+import { PresentionManager } from "../PresentationManager";
+export interface HoverLabelVM {
+    show: boolean;
+    text: string;
+    position: {
+        x: number;
+        y: number;
+    };
+}
+export declare class HoverLabelPM extends PresentionManager {
+    private hoverLabel;
+    private updateView;
+    doUpdateView: () => void;
+    constructor(hoverLabel: HoverLabels, updateView: (vm: HoverLabelVM) => void);
+    static defaultHoverLabelVM: HoverLabelVM;
+}

package/lib/PresentationManagers/HoverLabels/HoverLabelPM.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HoverLabelPM = void 0;
+const PresentationManager_1 = require("../PresentationManager");
+class HoverLabelPM extends PresentationManager_1.PresentionManager {
+    constructor(hoverLabel, updateView) {
+        super(hoverLabel);
+        this.hoverLabel = hoverLabel;
+        this.updateView = updateView;
+        this.doUpdateView = () => {
+            const vm = {
+                show: false,
+                text: "",
+                position: { x: 0, y: 0 },
+            };
+            if (this.hoverLabel.show) {
+                vm.show = true;
+                vm.text = this.hoverLabel.label;
+                vm.position.x = this.hoverLabel.position.x;
+                vm.position.y = this.hoverLabel.position.y;
+            }
+            this.updateView(vm);
+        };
+        this.doUpdateView();
+    }
+}
+exports.HoverLabelPM = HoverLabelPM;
+HoverLabelPM.defaultHoverLabelVM = {
+    show: false,
+    text: "",
+    position: { x: 0, y: 0 },
+};

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

@@ -0,0 +1,2 @@
+export * from "./HoverLabelPM";
+export * from "./AllowHoverLabelPM";

package/lib/PresentationManagers/HoverLabels/index.js

@@ -0,0 +1,14 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./HoverLabelPM"), exports);
+__exportStar(require("./AllowHoverLabelPM"), exports);

package/lib/PresentationManagers/IsAuthoringPM.d.ts

@@ -0,0 +1,9 @@
+import { BaseApp } from "../Entities";
+import { PresentionManager } from "./PresentationManager";
+export declare class IsAuthoringPM extends PresentionManager {
+    private baseApp;
+    private updateView;
+    private lastSetState?;
+    doUpdateView: () => void;
+    constructor(baseApp: BaseApp, updateView: (isAuthoring: boolean) => void);
+}

package/lib/PresentationManagers/IsAuthoringPM.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsAuthoringPM = void 0;
+const PresentationManager_1 = require("./PresentationManager");
+class IsAuthoringPM extends PresentationManager_1.PresentionManager {
+    constructor(baseApp, updateView) {
+        super(baseApp);
+        this.baseApp = baseApp;
+        this.updateView = updateView;
+        this.doUpdateView = () => {
+            const isAuthoring = this.baseApp.isAuthoring;
+            if (isAuthoring === this.lastSetState)
+                return;
+            this.updateView(isAuthoring);
+            this.lastSetState = isAuthoring;
+        };
+        this.doUpdateView();
+    }
+}
+exports.IsAuthoringPM = IsAuthoringPM;

package/lib/PresentationManagers/PresentationManager.d.ts

@@ -0,0 +1,8 @@
+import { EntityObserver, ObservableEntity } from "../Entities";
+export declare abstract class PresentionManager {
+    private observableEntity;
+    abstract doUpdateView: EntityObserver;
+    private internalDoUodateView;
+    dispose: () => void;
+    constructor(observableEntity: ObservableEntity);
+}

package/lib/PresentationManagers/PresentationManager.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PresentionManager = void 0;
+class PresentionManager {
+    constructor(observableEntity) {
+        this.observableEntity = observableEntity;
+        this.internalDoUodateView = () => {
+            this.doUpdateView();
+        };
+        this.dispose = () => {
+            this.observableEntity.removeObserver(this.internalDoUodateView);
+        };
+        observableEntity.addObserver(this.internalDoUodateView);
+    }
+}
+exports.PresentionManager = PresentionManager;

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

@@ -0,0 +1,15 @@
+import { Color, SceneModel } from "../../Entities";
+import { PresentionManager } from "../PresentationManager";
+export interface SceneMeshOverlayColorVM {
+    overlayColor: Color | undefined;
+}
+export declare class SceneMeshOverlayPM extends PresentionManager {
+    private sceneModel;
+    private id;
+    private updateView;
+    private previousVM?;
+    doUpdateView: () => void;
+    private vmHasChanged;
+    constructor(sceneModel: SceneModel, id: string, updateView: (vm: SceneMeshOverlayColorVM) => void);
+}
+export declare const defaultSceneModelVM: SceneMeshOverlayColorVM;

package/lib/PresentationManagers/SceneModel/SceneMeshOverlayPM.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultSceneModelVM = exports.SceneMeshOverlayPM = void 0;
+const PresentationManager_1 = require("../PresentationManager");
+class SceneMeshOverlayPM extends PresentationManager_1.PresentionManager {
+    constructor(sceneModel, id, updateView) {
+        super(sceneModel);
+        this.sceneModel = sceneModel;
+        this.id = id;
+        this.updateView = updateView;
+        this.doUpdateView = () => {
+            const sceneModelMesh = this.sceneModel.getMeshById(this.id);
+            const vm = {
+                overlayColor: sceneModelMesh === null || sceneModelMesh === void 0 ? void 0 : sceneModelMesh.overlayColor,
+            };
+            if (!this.vmHasChanged(vm))
+                return;
+            this.updateView(vm);
+            this.previousVM = vm;
+        };
+        this.doUpdateView();
+    }
+    vmHasChanged(vm) {
+        if (this.previousVM === undefined)
+            return true;
+        if (this.previousVM.overlayColor !== vm.overlayColor)
+            return true;
+        return false;
+    }
+}
+exports.SceneMeshOverlayPM = SceneMeshOverlayPM;
+exports.defaultSceneModelVM = {
+    overlayColor: undefined,
+};

package/lib/PresentationManagers/SceneModel/SceneModelPM.d.ts

@@ -0,0 +1,15 @@
+import { SceneModelRepo } from "../../Entities";
+import { PresentionManager } from "../PresentationManager";
+export interface SceneModelVM {
+    activeSceneModelID: string;
+    isLoading: boolean;
+}
+export declare class SceneModelPM extends PresentionManager {
+    private sceneModelRepo;
+    private updateView;
+    private previousVM?;
+    doUpdateView: () => void;
+    private vmHasChanged;
+    constructor(sceneModelRepo: SceneModelRepo, updateView: (vm: SceneModelVM) => void);
+}
+export declare const defaultSceneModelVM: SceneModelVM;