@vived/app 4.2.0 → 4.4.0

package/lib/Components/Landmarks/UseCases/DeleteLandmarkUC.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeleteLandmarkUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const Dispatcher_1 = require("../../Dispatcher");
+const __1 = require("..");
+const DeleteLandmarkUndoRedo_1 = require("./DeleteLandmarkUndoRedo");
+class DeleteLandmarkUC extends AppObject_1.AppObjectUC {
+    constructor(appObject) {
+        super(appObject, DeleteLandmarkUC.type);
+        this.deleteLandmark = (id, quietly = false, createUndo = false) => {
+            if (!this.landmarkRepo)
+                return;
+            const landmarkAppObject = this.appObjects.get(id);
+            let landmarkEntity;
+            if (landmarkAppObject) {
+                landmarkEntity = __1.LandmarkEntity.get(landmarkAppObject);
+            }
+            if (createUndo && landmarkEntity) {
+                new DeleteLandmarkUndoRedo_1.DeleteLandmarkUndoRedo(landmarkEntity.data, this.appObject);
+            }
+            if (landmarkAppObject) {
+                this.landmarkRepo.removeForAppObject(landmarkAppObject.id);
+                landmarkAppObject.dispose();
+            }
+            if (!quietly) {
+                Dispatcher_1.dispatchStateChange(this.appObjects);
+            }
+        };
+        this.landmarkRepo = appObject.getComponent(__1.LandmarkRepo.type);
+        if (!this.landmarkRepo) {
+            this.warn("App Object does not have a Landmark Repo");
+        }
+    }
+    static get(appObj) {
+        return appObj.getComponent(this.type);
+    }
+    static addIfMissing(appObj) {
+        const existing = appObj.getComponent(this.type);
+        if (existing)
+            return existing;
+        else {
+            return new DeleteLandmarkUC(appObj);
+        }
+    }
+}
+exports.DeleteLandmarkUC = DeleteLandmarkUC;
+DeleteLandmarkUC.type = "DeleteLandmarkUC";

package/lib/Components/Landmarks/UseCases/DeleteLandmarkUndoRedo.d.ts

@@ -0,0 +1,13 @@
+import { AppObject } from "../../../AppObject";
+import { UndoRedoAction } from "../../UndoRedo/Entities/UndoRedoEntity";
+import { LandmarkDTO } from "../Entities/LandmarkEntity";
+export declare class DeleteLandmarkUndoRedo implements UndoRedoAction {
+    private landmarkDTO;
+    private appObject;
+    private landmarkRepo?;
+    private addLandmarkUC?;
+    private deleteLandmarkUC?;
+    undoAction: () => void;
+    redoAction: () => void;
+    constructor(landmarkDTO: LandmarkDTO, appObject: AppObject);
+}

package/lib/Components/Landmarks/UseCases/DeleteLandmarkUndoRedo.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeleteLandmarkUndoRedo = void 0;
+const DispatchStateChangeUC_1 = require("../../Dispatcher/UC/DispatchStateChangeUC");
+const UndoRedoEntity_1 = require("../../UndoRedo/Entities/UndoRedoEntity");
+const LandmarkRepo_1 = require("../Entities/LandmarkRepo");
+const AddLandmarkUC_1 = require("./AddLandmarkUC");
+const DeleteLandmarkUC_1 = require("./DeleteLandmarkUC");
+class DeleteLandmarkUndoRedo {
+    constructor(landmarkDTO, appObject) {
+        this.landmarkDTO = landmarkDTO;
+        this.appObject = appObject;
+        this.undoAction = () => {
+            if (!this.addLandmarkUC)
+                return;
+            this.addLandmarkUC.addFromData(this.landmarkDTO);
+            DispatchStateChangeUC_1.dispatchStateChange(this.appObject.appObjectRepo);
+        };
+        this.redoAction = () => {
+            if (!this.deleteLandmarkUC)
+                return;
+            this.deleteLandmarkUC.deleteLandmark(this.landmarkDTO.id, true);
+            DispatchStateChangeUC_1.dispatchStateChange(this.appObject.appObjectRepo);
+        };
+        this.landmarkRepo = appObject.getComponent(LandmarkRepo_1.LandmarkRepo.type);
+        if (!this.landmarkRepo) {
+            appObject.appObjectRepo.submitWarning("DeleteLandmarkUndoRedo", "App Object does not have a Landmark Repo");
+            return;
+        }
+        this.addLandmarkUC = appObject.getComponent(AddLandmarkUC_1.AddLandmarkUC.type);
+        if (!this.addLandmarkUC) {
+            appObject.appObjectRepo.submitWarning("DeleteLandmarkUndoRedo", "App Object does not have a AddLandmarkUC");
+            return;
+        }
+        this.deleteLandmarkUC = appObject.getComponent(DeleteLandmarkUC_1.DeleteLandmarkUC.type);
+        if (!this.deleteLandmarkUC) {
+            appObject.appObjectRepo.submitWarning("DeleteLandmarkUndoRedo", "App Object does not have a DeleteLandmarkUC");
+            return;
+        }
+        const undoRedo = UndoRedoEntity_1.UndoRedoEntity.get(appObject.appObjectRepo);
+        if (!undoRedo) {
+            appObject.appObjectRepo.submitWarning("DeleteLandmarkUndoRedo", "Unable to find UndoRedoEntity");
+            return;
+        }
+        undoRedo.submitAction(this);
+    }
+}
+exports.DeleteLandmarkUndoRedo = DeleteLandmarkUndoRedo;

package/lib/Components/Landmarks/UseCases/SerializeLandmarks.d.ts

@@ -0,0 +1,16 @@
+import { AppObject, AppObjectUC } from "../../../AppObject";
+import { SerializedSystem } from "../../StateMachine";
+import { LandmarkDTO } from "../Entities/LandmarkEntity";
+export declare class SerializeLandmarks extends AppObjectUC implements SerializedSystem {
+    static readonly type = "SerializeLandmarks";
+    name: string;
+    seriliziationVersion: number;
+    getSystemState(): object;
+    applySystemState(state: object, version: number): void;
+    private handleStateVersion1;
+    applyDefaultState(): void;
+    constructor(appObj: AppObject);
+}
+export interface SerializedLandmarksV1 {
+    landmarks: LandmarkDTO[];
+}

package/lib/Components/Landmarks/UseCases/SerializeLandmarks.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SerializeLandmarks = void 0;
+const AppObject_1 = require("../../../AppObject");
+const Enablement_1 = require("../../Enablement");
+const StateMachine_1 = require("../../StateMachine");
+const LandmarkEntity_1 = require("../Entities/LandmarkEntity");
+const LandmarkGlobals_1 = require("../Entities/LandmarkGlobals");
+const LandmarkRepo_1 = require("../Entities/LandmarkRepo");
+const AddLandmarkUC_1 = require("./AddLandmarkUC");
+class SerializeLandmarks extends AppObject_1.AppObjectUC {
+    constructor(appObj) {
+        super(appObj, SerializeLandmarks.type);
+        this.name = "landmarks";
+        this.seriliziationVersion = 1;
+        const stateMachine = this.appObjects.getSingleton(StateMachine_1.StateMachineEntity.type);
+        if (stateMachine) {
+            stateMachine.registerSerializedSystem(this);
+        }
+        else {
+            this.warn("Unable to find StateMachineEntity");
+        }
+    }
+    getSystemState() {
+        const repos = this.appObjects.getAllComponents(LandmarkRepo_1.LandmarkRepo.type);
+        const landmarks = [];
+        repos.forEach((repo) => {
+            const enabledEntity = repo.appObject.getComponent(Enablement_1.EnablablementEntity.type);
+            let enabled = false;
+            if (enabledEntity) {
+                enabled = enabledEntity.enabled;
+            }
+            if (enabled) {
+                repo.getAll().forEach((landmark) => {
+                    if (landmark.parentID) {
+                        landmarks.push(landmark.data);
+                    }
+                });
+            }
+        });
+        return {
+            landmarks,
+        };
+    }
+    applySystemState(state, version) {
+        if (version === 1) {
+            this.handleStateVersion1(state);
+        }
+        else {
+            this.warn("Unsupported state version. Reverting to default");
+            this.applyDefaultState();
+        }
+    }
+    handleStateVersion1(state) {
+        const { landmarks } = state;
+        if (!landmarks) {
+            this.warn("Unable to parse state. Reverting to default");
+            this.applyDefaultState();
+            return;
+        }
+        const previousLandmarkLookup = new Map();
+        const allLandmarks = this.appObjects.getAllComponents(LandmarkEntity_1.LandmarkEntity.type);
+        allLandmarks.forEach((landmark) => {
+            if (landmark.parentID) {
+                previousLandmarkLookup.set(landmark.appObject.id, landmark);
+            }
+        });
+        landmarks.forEach((landmarkData) => {
+            var _a;
+            const existing = previousLandmarkLookup.get(landmarkData.id);
+            if (existing) {
+                existing.data = landmarkData;
+                previousLandmarkLookup.delete(landmarkData.id);
+            }
+            let addUC = this.appObjects.getAppObjectComponent(landmarkData.parentID, AddLandmarkUC_1.AddLandmarkUC.type);
+            if (!addUC) {
+                const globals = this.appObjects.getSingleton(LandmarkGlobals_1.LandmarkGlobals.type);
+                const newRepoAO = (_a = globals === null || globals === void 0 ? void 0 : globals.landmarkRepoFactory(landmarkData.parentID)) === null || _a === void 0 ? void 0 : _a.appObject;
+                addUC = newRepoAO === null || newRepoAO === void 0 ? void 0 : newRepoAO.getComponent(AddLandmarkUC_1.AddLandmarkUC.type);
+            }
+            if (addUC) {
+                addUC.addFromData(landmarkData);
+            }
+            else {
+                this.error("No create UC");
+            }
+        });
+        previousLandmarkLookup.forEach((landmark) => {
+            var _a;
+            (_a = landmark.inRepo) === null || _a === void 0 ? void 0 : _a.removeForAppObject(landmark.appObject.id);
+            landmark.appObject.dispose();
+        });
+    }
+    applyDefaultState() {
+        const repos = this.appObjects.getAllComponents(LandmarkRepo_1.LandmarkRepo.type);
+        repos.forEach((repo) => {
+            const landmarks = repo.getAll();
+            landmarks.forEach((landmark) => {
+                if (landmark.parentID) {
+                    landmark.appObject.dispose();
+                    repo.removeForAppObject(landmark.appObject.id);
+                }
+            });
+        });
+    }
+}
+exports.SerializeLandmarks = SerializeLandmarks;
+SerializeLandmarks.type = "SerializeLandmarks";

package/lib/Components/Landmarks/UseCases/SetLandmarkSizeUC.d.ts

@@ -0,0 +1,12 @@
+import { AppObject, AppObjectUC } from "../../../AppObject";
+export declare class SetLandmarkSizeUC extends AppObjectUC {
+    static readonly type = "SetLandmarkSizeUC";
+    private initialValue?;
+    private landmark?;
+    private landmarkGlobals?;
+    getClampedSize(size: number): number;
+    updateSize(size: number): void;
+    submitSize(size: number): void;
+    constructor(appObject: AppObject);
+    static get(appObj: AppObject): SetLandmarkSizeUC | undefined;
+}

package/lib/Components/Landmarks/UseCases/SetLandmarkSizeUC.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetLandmarkSizeUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const Dispatcher_1 = require("../../Dispatcher");
+const LandmarkEntity_1 = require("../Entities/LandmarkEntity");
+const LandmarkGlobals_1 = require("../Entities/LandmarkGlobals");
+const SetLandmarkSizeUndoRedo_1 = require("./SetLandmarkSizeUndoRedo");
+class SetLandmarkSizeUC extends AppObject_1.AppObjectUC {
+    constructor(appObject) {
+        super(appObject, SetLandmarkSizeUC.type);
+        this.landmark = appObject.getComponent(LandmarkEntity_1.LandmarkEntity.type);
+        if (!this.landmark) {
+            this.warn("SetLandmarkSizeUC has been added to an App Object that does not have a LandmarkEntity. Add a LandmarkEntity before adding the UC");
+            return;
+        }
+        this.landmarkGlobals = LandmarkGlobals_1.LandmarkGlobals.get(this.appObjects);
+        if (!this.landmarkGlobals) {
+            this.warn("SetLandmarkSizeUC has been added to an App Object but LandmarkGlobals Entity was not added. Add a LandmarkGlobals Entity");
+            return;
+        }
+    }
+    getClampedSize(size) {
+        return Math.max(LandmarkEntity_1.LANDMARK_MINIMUM_SIZE, Math.min(LandmarkEntity_1.LANDMARK_MAXIMUM_SIZE, size));
+    }
+    updateSize(size) {
+        if (!this.landmark)
+            return;
+        if (!this.landmarkGlobals)
+            return;
+        if (this.initialValue === undefined) {
+            this.initialValue = size;
+        }
+        const clampedSize = this.getClampedSize(size);
+        this.landmark.size = clampedSize;
+        this.landmarkGlobals.lastSize = clampedSize;
+    }
+    submitSize(size) {
+        if (!this.initialValue)
+            return;
+        if (!this.landmark)
+            return;
+        if (!this.landmarkGlobals)
+            return;
+        const clampedSize = this.getClampedSize(size);
+        this.landmark.size = clampedSize;
+        this.landmarkGlobals.lastSize = clampedSize;
+        new SetLandmarkSizeUndoRedo_1.SetLandmarkSizeUndoRedo(clampedSize, this.initialValue, this.appObject);
+        Dispatcher_1.dispatchStateChange(this.appObjects);
+        this.initialValue = undefined;
+    }
+    static get(appObj) {
+        return appObj.getComponent(this.type);
+    }
+}
+exports.SetLandmarkSizeUC = SetLandmarkSizeUC;
+SetLandmarkSizeUC.type = "SetLandmarkSizeUC";

package/lib/Components/Landmarks/UseCases/SetLandmarkSizeUndoRedo.d.ts

@@ -0,0 +1,11 @@
+import { AppObject } from "../../../AppObject";
+import { UndoRedoAction } from "../../UndoRedo/Entities/UndoRedoEntity";
+export declare class SetLandmarkSizeUndoRedo implements UndoRedoAction {
+    private size;
+    private initialSize;
+    private appObject;
+    private landmark?;
+    undoAction: () => void;
+    redoAction: () => void;
+    constructor(size: number, initialSize: number, appObject: AppObject);
+}

package/lib/Components/Landmarks/UseCases/SetLandmarkSizeUndoRedo.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetLandmarkSizeUndoRedo = void 0;
+const DispatchStateChangeUC_1 = require("../../Dispatcher/UC/DispatchStateChangeUC");
+const UndoRedoEntity_1 = require("../../UndoRedo/Entities/UndoRedoEntity");
+const LandmarkEntity_1 = require("../Entities/LandmarkEntity");
+class SetLandmarkSizeUndoRedo {
+    constructor(size, initialSize, appObject) {
+        this.size = size;
+        this.initialSize = initialSize;
+        this.appObject = appObject;
+        this.undoAction = () => {
+            if (!this.landmark)
+                return;
+            this.landmark.size = this.initialSize;
+            DispatchStateChangeUC_1.dispatchStateChange(this.appObject.appObjectRepo);
+        };
+        this.redoAction = () => {
+            if (!this.landmark)
+                return;
+            this.landmark.size = this.size;
+            DispatchStateChangeUC_1.dispatchStateChange(this.appObject.appObjectRepo);
+        };
+        this.landmark = appObject.getComponent(LandmarkEntity_1.LandmarkEntity.type);
+        if (!this.landmark) {
+            appObject.appObjectRepo.submitWarning("SetLandmarkSizeUndoRedo", "Unable to find LandmarkEntity");
+            return;
+        }
+        const undoRedo = UndoRedoEntity_1.UndoRedoEntity.get(appObject.appObjectRepo);
+        if (!undoRedo) {
+            appObject.appObjectRepo.submitWarning("SetLandmarkSizeUndoRedo", "Unable to find UndoRedoEntity");
+            return;
+        }
+        undoRedo.submitAction(this);
+    }
+}
+exports.SetLandmarkSizeUndoRedo = SetLandmarkSizeUndoRedo;

package/lib/Components/Landmarks/UseCases/SetOverlayColorUC.d.ts

@@ -0,0 +1,11 @@
+import { AppObject, AppObjectUC } from "../../../AppObject";
+import { OverlayColorEnums } from "../../OverlayColor";
+export declare class SetOverlayColorUC extends AppObjectUC {
+    static readonly type = "SetOverlayColorUC";
+    private overlayColor?;
+    private landmarkGlobals?;
+    setOverlayColor: (color: OverlayColorEnums) => void;
+    dispose: () => void;
+    constructor(appObject: AppObject);
+    static get(appObj: AppObject): SetOverlayColorUC | undefined;
+}

package/lib/Components/Landmarks/UseCases/SetOverlayColorUC.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetOverlayColorUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const Dispatcher_1 = require("../../Dispatcher");
+const OverlayColor_1 = require("../../OverlayColor");
+const LandmarkGlobals_1 = require("../Entities/LandmarkGlobals");
+const SetOverlayColorUndoRedo_1 = require("./SetOverlayColorUndoRedo");
+class SetOverlayColorUC extends AppObject_1.AppObjectUC {
+    constructor(appObject) {
+        super(appObject, SetOverlayColorUC.type);
+        this.setOverlayColor = (color) => {
+            if (!this.overlayColor)
+                return;
+            if (!this.landmarkGlobals)
+                return;
+            if (this.overlayColor.overlayColor === color)
+                return;
+            const prevColor = this.overlayColor.overlayColor;
+            this.overlayColor.overlayColor = color;
+            Dispatcher_1.dispatchStateChange(this.appObjects);
+            new SetOverlayColorUndoRedo_1.SetOverlayColorUndoRedo(color, prevColor, this.appObject);
+            this.landmarkGlobals.lastColor = color;
+        };
+        this.dispose = () => {
+            var _a;
+            super.dispose();
+            (_a = this.overlayColor) === null || _a === void 0 ? void 0 : _a.removeOnDisposeObserver(this.dispose);
+        };
+        this.landmarkGlobals = LandmarkGlobals_1.LandmarkGlobals.get(this.appObjects);
+        if (!this.landmarkGlobals) {
+            this.warn("SetOverlayColorUC has been added to an App Object but LandmarkGlobals Entity was not added. Add a LandmarkGlobals Entity");
+            return;
+        }
+        this.overlayColor = appObject.getComponent(OverlayColor_1.OverlayColor.type);
+        if (!this.overlayColor) {
+            this.warn("SetOverlayColorUC has been added to an App Object that does not have a Overlay Color Entity. Add a Overlay Color Entity before adding the UC");
+            return;
+        }
+    }
+    static get(appObj) {
+        return appObj.getComponent(this.type);
+    }
+}
+exports.SetOverlayColorUC = SetOverlayColorUC;
+SetOverlayColorUC.type = "SetOverlayColorUC";

package/lib/Components/Landmarks/UseCases/SetOverlayColorUndoRedo.d.ts

@@ -0,0 +1,12 @@
+import { AppObject } from "../../../AppObject";
+import { OverlayColorEnums } from "../../OverlayColor";
+import { UndoRedoAction } from "../../UndoRedo/Entities/UndoRedoEntity";
+export declare class SetOverlayColorUndoRedo implements UndoRedoAction {
+    private color;
+    private preColor;
+    private appObject;
+    private overlayColor?;
+    undoAction: () => void;
+    redoAction: () => void;
+    constructor(color: OverlayColorEnums, preColor: OverlayColorEnums, appObject: AppObject);
+}

package/lib/Components/Landmarks/UseCases/SetOverlayColorUndoRedo.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetOverlayColorUndoRedo = void 0;
+const DispatchStateChangeUC_1 = require("../../Dispatcher/UC/DispatchStateChangeUC");
+const OverlayColor_1 = require("../../OverlayColor");
+const UndoRedoEntity_1 = require("../../UndoRedo/Entities/UndoRedoEntity");
+class SetOverlayColorUndoRedo {
+    constructor(color, preColor, appObject) {
+        this.color = color;
+        this.preColor = preColor;
+        this.appObject = appObject;
+        this.undoAction = () => {
+            if (!this.overlayColor)
+                return;
+            this.overlayColor.overlayColor = this.preColor;
+            DispatchStateChangeUC_1.dispatchStateChange(this.appObject.appObjectRepo);
+        };
+        this.redoAction = () => {
+            if (!this.overlayColor)
+                return;
+            this.overlayColor.overlayColor = this.color;
+            DispatchStateChangeUC_1.dispatchStateChange(this.appObject.appObjectRepo);
+        };
+        this.overlayColor = OverlayColor_1.OverlayColor.get(this.appObject);
+        if (!this.overlayColor) {
+            appObject.appObjectRepo.submitWarning("SetOverlayColorUndoRedo", "Unable to find OverlayColorEntity");
+            return;
+        }
+        const undoRedo = UndoRedoEntity_1.UndoRedoEntity.get(appObject.appObjectRepo);
+        if (!undoRedo) {
+            appObject.appObjectRepo.submitWarning("SetOverlayColorUndoRedo", "Unable to find UndoRedoEntity");
+            return;
+        }
+        undoRedo.submitAction(this);
+    }
+}
+exports.SetOverlayColorUndoRedo = SetOverlayColorUndoRedo;

package/lib/Components/Landmarks/UseCases/TryAddNewLandmarkUC.d.ts

@@ -0,0 +1,9 @@
+import { AppObject, AppObjectUC } from "../../../AppObject";
+import { ParametricLine } from "../../../ValueObjects";
+import { LandmarkEntity } from "../Entities/LandmarkEntity";
+export declare abstract class TryAddNewLandmarkUC extends AppObjectUC {
+    static readonly type = "TryAddNewLandmarkUC";
+    abstract addFromRay(ray: ParametricLine): LandmarkEntity | undefined;
+    static get(appObj: AppObject): TryAddNewLandmarkUC | undefined;
+}
+export declare function makeTryAddLandmarkUC(appObject: AppObject): TryAddNewLandmarkUC;

package/lib/Components/Landmarks/UseCases/TryAddNewLandmarkUC.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeTryAddLandmarkUC = exports.TryAddNewLandmarkUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const ValueObjects_1 = require("../../../ValueObjects");
+const Babylon_1 = require("../../Babylon");
+const Dispatcher_1 = require("../../Dispatcher");
+const Label_1 = require("../../Label");
+const LandmarkGlobals_1 = require("../Entities/LandmarkGlobals");
+const AddLandmarkUC_1 = require("./AddLandmarkUC");
+const AddLandmarkUndoRedo_1 = require("./AddLandmarkUndoRedo");
+class TryAddNewLandmarkUC extends AppObject_1.AppObjectUC {
+    static get(appObj) {
+        return appObj.getComponent(this.type);
+    }
+}
+exports.TryAddNewLandmarkUC = TryAddNewLandmarkUC;
+TryAddNewLandmarkUC.type = "TryAddNewLandmarkUC";
+function makeTryAddLandmarkUC(appObject) {
+    return new TryAddNewLandmarkUCImp(appObject);
+}
+exports.makeTryAddLandmarkUC = makeTryAddLandmarkUC;
+class TryAddNewLandmarkUCImp extends TryAddNewLandmarkUC {
+    addFromRay(ray) {
+        const scenePick = Babylon_1.sceneRayPick(ray, this.appObjects);
+        if (!scenePick ||
+            !scenePick.worldPickPoint ||
+            !scenePick.normal ||
+            !scenePick.appObjectID) {
+            return;
+        }
+        const pickAO = scenePick.appObjectID;
+        const addLandmarkUC = this.appObjects.getAppObjectComponent(pickAO, AddLandmarkUC_1.AddLandmarkUC.type);
+        if (!addLandmarkUC) {
+            return;
+        }
+        const newLandmark = addLandmarkUC.addNew();
+        if (!newLandmark) {
+            this.warn("Failed to add landmark");
+            return;
+        }
+        newLandmark.transform.worldPosition = scenePick.worldPickPoint;
+        newLandmark.transform.worldRotation = ValueObjects_1.Quaternion.FromDirectionVector(scenePick.normal);
+        const globals = this.appObjects.getSingleton(LandmarkGlobals_1.LandmarkGlobals.type);
+        if (globals) {
+            newLandmark.size = globals.lastSize;
+            newLandmark.overlayColor.overlayColor = globals.lastColor;
+        }
+        const label = this.appObjects.getAppObjectComponent(pickAO, Label_1.Label.type);
+        newLandmark.label.default = label ? label.default : "";
+        newLandmark.selectable.selected = true;
+        new AddLandmarkUndoRedo_1.AddLandmarkUndoRedo(newLandmark.data, this.appObject);
+        Dispatcher_1.dispatchStateChange(this.appObjects);
+        return newLandmark;
+    }
+    constructor(appObject) {
+        super(appObject, TryAddNewLandmarkUC.type);
+    }
+}

package/lib/Components/Landmarks/UseCases/TryPreviewLandmarkUC.d.ts

@@ -0,0 +1,15 @@
+import { AppObject, AppObjectUC } from "../../../AppObject";
+import { ParametricLine } from "../../../ValueObjects";
+export declare abstract class TryPreviewLandmarkUC extends AppObjectUC {
+    static readonly type = "TryPreviewLandmarkUC";
+    abstract tryPreviewLandmark: (ray: ParametricLine, pressed: boolean) => boolean | undefined;
+    static get(appObj: AppObject): TryPreviewLandmarkUC | undefined;
+}
+export declare function makeTryPreviewLandmark(appObject: AppObject): TryPreviewLandmarkUCImp;
+declare class TryPreviewLandmarkUCImp extends TryPreviewLandmarkUC {
+    private previewLandmark?;
+    private hidePreview;
+    tryPreviewLandmark: (ray: ParametricLine, pressed: boolean) => false | undefined;
+    constructor(appObject: AppObject);
+}
+export {};

package/lib/Components/Landmarks/UseCases/TryPreviewLandmarkUC.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeTryPreviewLandmark = exports.TryPreviewLandmarkUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const ValueObjects_1 = require("../../../ValueObjects");
+const App_1 = require("../../App");
+const Babylon_1 = require("../../Babylon");
+const LandmarkGlobals_1 = require("../Entities/LandmarkGlobals");
+const LandmarkRepo_1 = require("../Entities/LandmarkRepo");
+class TryPreviewLandmarkUC extends AppObject_1.AppObjectUC {
+    static get(appObj) {
+        return appObj.getComponent(this.type);
+    }
+}
+exports.TryPreviewLandmarkUC = TryPreviewLandmarkUC;
+TryPreviewLandmarkUC.type = "TryPreviewLandmarkUC";
+function makeTryPreviewLandmark(appObject) {
+    const uc = new TryPreviewLandmarkUCImp(appObject);
+    return uc;
+}
+exports.makeTryPreviewLandmark = makeTryPreviewLandmark;
+class TryPreviewLandmarkUCImp extends TryPreviewLandmarkUC {
+    constructor(appObject) {
+        var _a;
+        super(appObject, TryPreviewLandmarkUC.type);
+        this.tryPreviewLandmark = (ray, pressed) => {
+            if (!this.previewLandmark) {
+                return false;
+            }
+            const baseApp = this.appObjects.getSingleton(App_1.BaseAppState.type);
+            if (!baseApp || !baseApp.isAuthoring) {
+                this.hidePreview();
+                return false;
+            }
+            const scenePick = Babylon_1.sceneRayPick(ray, this.appObjects);
+            if (!scenePick ||
+                !scenePick.worldPickPoint ||
+                !scenePick.normal ||
+                !scenePick.appObjectID) {
+                this.hidePreview();
+                return;
+            }
+            const aoRepo = this.appObjects.getAppObjectComponent(scenePick.appObjectID, LandmarkRepo_1.LandmarkRepo.type);
+            if (!aoRepo) {
+                this.hidePreview();
+                return;
+            }
+            this.previewLandmark.hideable.isHidden = false;
+            this.previewLandmark.position = scenePick.worldPickPoint;
+            this.previewLandmark.rotation = ValueObjects_1.Quaternion.FromDirectionVector(scenePick.normal);
+            this.previewLandmark.selectable.pressed = pressed;
+        };
+        this.previewLandmark = (_a = this.appObject.getComponent(LandmarkGlobals_1.LandmarkGlobals.type)) === null || _a === void 0 ? void 0 : _a.previewLandmark;
+        if (!this.previewLandmark) {
+            console.warn("No preview landmark");
+        }
+    }
+    hidePreview() {
+        if (!this.previewLandmark)
+            return;
+        this.previewLandmark.hideable.isHidden = true;
+    }
+}

package/lib/Components/Landmarks/UseCases/index.d.ts

@@ -0,0 +1,11 @@
+export * from "./AddLandmarkUC";
+export * from "./AddLandmarkUndoRedo";
+export * from "./DeleteLandmarkUC";
+export * from "./DeleteLandmarkUndoRedo";
+export * from "./SerializeLandmarks";
+export * from "./SetLandmarkSizeUC";
+export * from "./SetLandmarkSizeUndoRedo";
+export * from "./SetOverlayColorUC";
+export * from "./SetOverlayColorUndoRedo";
+export * from "./TryAddNewLandmarkUC";
+export * from "./TryPreviewLandmarkUC";

package/lib/Components/Landmarks/UseCases/index.js

@@ -0,0 +1,23 @@
+"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("./AddLandmarkUC"), exports);
+__exportStar(require("./AddLandmarkUndoRedo"), exports);
+__exportStar(require("./DeleteLandmarkUC"), exports);
+__exportStar(require("./DeleteLandmarkUndoRedo"), exports);
+__exportStar(require("./SerializeLandmarks"), exports);
+__exportStar(require("./SetLandmarkSizeUC"), exports);
+__exportStar(require("./SetLandmarkSizeUndoRedo"), exports);
+__exportStar(require("./SetOverlayColorUC"), exports);
+__exportStar(require("./SetOverlayColorUndoRedo"), exports);
+__exportStar(require("./TryAddNewLandmarkUC"), exports);
+__exportStar(require("./TryPreviewLandmarkUC"), exports);