@vived/app 4.27.0 → 4.27.1

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/{Components/Callouts/Adapters → PresentationManagers/QuestionChallenge}/index.js

@@ -10,7 +10,7 @@ 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("./calloutLinePointsAdapter"), exports);
-__exportStar(require("./calloutListAdapter"), exports);
-__exportStar(require("./calloutOffsetAdapter"), exports);
-__exportStar(require("./calloutSizeAdapter"), exports);
+__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;

package/lib/PresentationManagers/SceneModel/SceneModelPM.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultSceneModelVM = exports.SceneModelPM = void 0;
+const PresentationManager_1 = require("../PresentationManager");
+class SceneModelPM extends PresentationManager_1.PresentionManager {
+    constructor(sceneModelRepo, updateView) {
+        super(sceneModelRepo);
+        this.sceneModelRepo = sceneModelRepo;
+        this.updateView = updateView;
+        this.doUpdateView = () => {
+            const sceneModelID = this.sceneModelRepo.activeModelID;
+            const vm = {
+                activeSceneModelID: sceneModelID,
+                isLoading: this.sceneModelRepo.isLoadingSceneModel,
+            };
+            if (!this.vmHasChanged(vm))
+                return;
+            this.updateView(vm);
+            this.previousVM = vm;
+        };
+        this.doUpdateView();
+    }
+    vmHasChanged(vm) {
+        if (this.previousVM === undefined)
+            return true;
+        if (this.previousVM.activeSceneModelID !== vm.activeSceneModelID ||
+            this.previousVM.isLoading !== vm.isLoading)
+            return true;
+        return false;
+    }
+}
+exports.SceneModelPM = SceneModelPM;
+exports.defaultSceneModelVM = {
+    isLoading: false,
+    activeSceneModelID: "",
+};

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

@@ -0,0 +1 @@
+export * from "./SceneModelPM";

package/lib/{Components/BaseApp/Entity → PresentationManagers/SceneModel}/index.js

@@ -10,4 +10,4 @@ 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("./BaseAppState"), exports);
+__exportStar(require("./SceneModelPM"), exports);

package/lib/PresentationManagers/SceneObject/SceneObjectPM.d.ts

@@ -0,0 +1,22 @@
+import { SceneObject } from "../../Entities";
+import { Quaternion, Vector3 } from "../../ValueObjects";
+import { PresentionManager } from "../PresentationManager";
+export interface SceneObjectVM {
+    position: Vector3;
+    rotation: Quaternion;
+    scale: Vector3;
+    enabled: boolean;
+    selected: boolean;
+    hovered: boolean;
+    pressed: boolean;
+    defaultLabel: string;
+    label: string;
+}
+export declare class SceneObjectPM extends PresentionManager {
+    private sceneObject;
+    private updateView;
+    private lastVM?;
+    doUpdateView: () => void;
+    private vmHasChanged;
+    constructor(sceneObject: SceneObject, updateView: (vm: SceneObjectVM) => void);
+}

package/lib/PresentationManagers/SceneObject/SceneObjectPM.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SceneObjectPM = void 0;
+const ValueObjects_1 = require("../../ValueObjects");
+const PresentationManager_1 = require("../PresentationManager");
+class SceneObjectPM extends PresentationManager_1.PresentionManager {
+    constructor(sceneObject, updateView) {
+        super(sceneObject);
+        this.sceneObject = sceneObject;
+        this.updateView = updateView;
+        this.doUpdateView = () => {
+            const enabled = this.sceneObject.shown && this.sceneObject.enabled;
+            const label = this.sceneObject.customLabel.length > 0 ?
+                this.sceneObject.customLabel : this.sceneObject.defaultLabel;
+            const vm = {
+                position: this.sceneObject.transform.localPosition,
+                rotation: this.sceneObject.transform.localRotation,
+                scale: this.sceneObject.transform.localScale,
+                enabled,
+                selected: this.sceneObject.selected,
+                hovered: this.sceneObject.hovered,
+                pressed: this.sceneObject.pressed,
+                defaultLabel: this.sceneObject.defaultLabel,
+                label
+            };
+            if (this.vmHasChanged(vm)) {
+                this.updateView(vm);
+                this.lastVM = vm;
+            }
+        };
+        this.doUpdateView();
+    }
+    vmHasChanged(newVM) {
+        if (this.lastVM === undefined)
+            return true;
+        if (this.lastVM.enabled !== newVM.enabled)
+            return true;
+        if (!ValueObjects_1.Vector3.Equal(this.lastVM.position, newVM.position))
+            return true;
+        if (!ValueObjects_1.Vector3.Equal(this.lastVM.scale, newVM.scale))
+            return true;
+        if (!ValueObjects_1.Quaternion.Close(this.lastVM.rotation, newVM.rotation))
+            return true;
+        if (this.lastVM.selected !== newVM.selected)
+            return true;
+        if (this.lastVM.hovered !== newVM.hovered)
+            return true;
+        if (this.lastVM.pressed !== newVM.pressed)
+            return true;
+        if (this.lastVM.defaultLabel !== newVM.defaultLabel)
+            return true;
+        if (this.lastVM.label !== newVM.label)
+            return true;
+        return false;
+    }
+}
+exports.SceneObjectPM = SceneObjectPM;

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

@@ -0,0 +1 @@
+export * from "./SceneObjectPM";

package/lib/{Components/Camera/Mocks → PresentationManagers/SceneObject}/index.js

@@ -10,4 +10,4 @@ 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("./CameraPmMock"), exports);
+__exportStar(require("./SceneObjectPM"), exports);

package/lib/PresentationManagers/ShowBabylonInspectorPM.d.ts

@@ -0,0 +1,9 @@
+import { Babylon } from "../Entities";
+export declare class ShowBabylonInspectorPM {
+    private babylon;
+    private updateView;
+    private lastSetState?;
+    private doUpdateView;
+    dispose(): void;
+    constructor(babylon: Babylon, updateView: (showInspector: boolean) => void);
+}

package/lib/PresentationManagers/ShowBabylonInspectorPM.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShowBabylonInspectorPM = void 0;
+class ShowBabylonInspectorPM {
+    constructor(babylon, updateView) {
+        this.doUpdateView = () => {
+            const showInspector = this.babylon.showInspector;
+            const hasCanvas = this.babylon.renderCanvas === undefined ? false : true;
+            const showBeShown = hasCanvas && showInspector;
+            if (showBeShown === this.lastSetState)
+                return;
+            this.updateView(showBeShown);
+            this.lastSetState = showBeShown;
+        };
+        this.babylon = babylon;
+        this.updateView = updateView;
+        this.doUpdateView();
+        this.babylon.addObserver(this.doUpdateView);
+    }
+    dispose() {
+        this.babylon.removeObserver(this.doUpdateView);
+    }
+}
+exports.ShowBabylonInspectorPM = ShowBabylonInspectorPM;

package/lib/PresentationManagers/ToolPM.d.ts

@@ -0,0 +1,17 @@
+import { Tool } from "../Entities";
+import { PresentionManager } from "./PresentationManager";
+export interface ToolVM<ToolType> {
+    type: ToolType;
+    label: string;
+    enabled: boolean;
+    selected: boolean;
+    show: boolean;
+    shortcutLabel: string;
+    tooltipLabel: string;
+}
+export declare class ToolPM<ToolType> extends PresentionManager {
+    private tool;
+    private updateView;
+    doUpdateView: () => void;
+    constructor(tool: Tool<ToolType>, updateView: (tools: ToolVM<ToolType>) => void);
+}

package/lib/PresentationManagers/ToolPM.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolPM = void 0;
+const Entities_1 = require("../Entities");
+const PresentationManager_1 = require("./PresentationManager");
+class ToolPM extends PresentationManager_1.PresentionManager {
+    constructor(tool, updateView) {
+        super(tool);
+        this.tool = tool;
+        this.updateView = updateView;
+        this.doUpdateView = () => {
+            const { type, state, label, shortcutLabel } = this.tool;
+            let enabled = false;
+            if (state === Entities_1.ToolState.ACTIVE ||
+                state === Entities_1.ToolState.ENABLED) {
+                enabled = true;
+            }
+            const selected = state === Entities_1.ToolState.ACTIVE ? true : false;
+            const show = state === Entities_1.ToolState.HIDDEN ? false : true;
+            const tooltipLabel = `${label} [${shortcutLabel}]`;
+            const vm = {
+                type,
+                enabled,
+                label,
+                selected,
+                show,
+                shortcutLabel,
+                tooltipLabel,
+            };
+            this.updateView(vm);
+        };
+        this.doUpdateView();
+    }
+}
+exports.ToolPM = ToolPM;

package/lib/PresentationManagers/TransformNodePM.d.ts

@@ -0,0 +1,14 @@
+import { TransformNode } from "../Entities";
+import { Quaternion, Vector3 } from "../ValueObjects";
+export interface TransformNodeVM {
+    position: Vector3;
+    rotation: Quaternion;
+    scale: Vector3;
+}
+export declare class TransformNodePM {
+    private transformNode;
+    private updateView;
+    dispose: () => void;
+    doUpdateView: () => void;
+    constructor(transformNode: TransformNode, updateView: (vm: TransformNodeVM) => void);
+}

package/lib/PresentationManagers/TransformNodePM.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransformNodePM = void 0;
+class TransformNodePM {
+    constructor(transformNode, updateView) {
+        this.transformNode = transformNode;
+        this.updateView = updateView;
+        this.dispose = () => {
+            this.transformNode.removeObserver(this.doUpdateView);
+        };
+        this.doUpdateView = () => {
+            const vm = {
+                position: this.transformNode.localPosition,
+                rotation: this.transformNode.localRotation,
+                scale: this.transformNode.localScale,
+            };
+            this.updateView(vm);
+        };
+        transformNode.addObserver(this.doUpdateView);
+        this.doUpdateView();
+    }
+}
+exports.TransformNodePM = TransformNodePM;

package/lib/PresentationManagers/index.d.ts

@@ -0,0 +1,13 @@
+export * from "./DevicePreviewPM";
+export * from "./FramedScreenContainerPM";
+export * from "./IsAuthoringPM";
+export * from "./PresentationManager";
+export * from "./ShowBabylonInspectorPM";
+export * from "./HasRedoPM";
+export * from "./HasUndoPM";
+export * from "./QuestionChallenge";
+export * from "./SceneModel";
+export * from "./SceneObject";
+export * from "./ToolPM";
+export * from "./TransformNodePM";
+export * from "./HoverLabels";