@vived/app 4.3.0 → 4.5.0

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

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeAddLandmarkUC = exports.AddLandmarkUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const Utilities_1 = require("../../../Utilities");
+const Label_1 = require("../../Label");
+const Transform3D_1 = require("../../Transform3D");
+const LandmarkGlobals_1 = require("../Entities/LandmarkGlobals");
+const LandmarkRepo_1 = require("../Entities/LandmarkRepo");
+class AddLandmarkUC extends AppObject_1.AppObjectUC {
+}
+exports.AddLandmarkUC = AddLandmarkUC;
+AddLandmarkUC.type = "AddLandmarkUC";
+function makeAddLandmarkUC(appObject) {
+    return new AddLandmarkUCImp(appObject);
+}
+exports.makeAddLandmarkUC = makeAddLandmarkUC;
+class AddLandmarkUCImp extends AddLandmarkUC {
+    constructor(appObject) {
+        super(appObject, AddLandmarkUC.type);
+        this.landmarkRepo = appObject.getComponent(LandmarkRepo_1.LandmarkRepo.type);
+        if (!this.landmarkRepo) {
+            this.warn("LandmarkRepo App Object has not been added. Add to the LandmarkRepo App Object before Adding Landmark.");
+            return;
+        }
+        this.transform3D = appObject.getComponent(Transform3D_1.Transform3D.type);
+        if (!this.transform3D) {
+            this.warn("Transform3D App Object has not been added. Add to the Transform3D App Object before Adding Landmark.");
+            return;
+        }
+        this.label = appObject.getComponent(Label_1.Label.type); // Not required
+    }
+    addFromData(data) {
+        if (!this.landmarkRepo || !this.transform3D)
+            return;
+        if (data.parentID !== this.appObject.id)
+            return;
+        const existingLandmark = this.landmarkRepo.getForAppObject(data.id);
+        if (existingLandmark) {
+            existingLandmark.data = data;
+            return;
+        }
+        const globals = this.appObjects.getSingleton(LandmarkGlobals_1.LandmarkGlobals.type);
+        if (!globals)
+            return;
+        const newLandmark = globals.landmarkFactory(data.id);
+        if (!newLandmark)
+            return;
+        newLandmark.transform.parent = this.transform3D;
+        newLandmark.data = data;
+        this.landmarkRepo.add(newLandmark);
+        return newLandmark;
+    }
+    addNew() {
+        if (!this.landmarkRepo || !this.transform3D)
+            return;
+        const globals = this.appObjects.getSingleton(LandmarkGlobals_1.LandmarkGlobals.type);
+        if (!globals)
+            return;
+        const newLandmark = globals.landmarkFactory(Utilities_1.generateUniqueID());
+        if (!newLandmark)
+            return;
+        newLandmark.transform.parent = this.transform3D;
+        this.landmarkRepo.add(newLandmark);
+        return newLandmark;
+    }
+}

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

@@ -0,0 +1,13 @@
+import { AppObject } from "../../../AppObject";
+import { UndoRedoAction } from "../../UndoRedo/Entities/UndoRedoEntity";
+import { LandmarkDTO } from "../Entities/LandmarkEntity";
+export declare class AddLandmarkUndoRedo 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/AddLandmarkUndoRedo.js

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

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

@@ -0,0 +1,9 @@
+import { AppObject, AppObjectUC } from "../../../AppObject";
+export declare class DeleteLandmarkUC extends AppObjectUC {
+    static readonly type = "DeleteLandmarkUC";
+    private landmarkRepo?;
+    static get(appObj: AppObject): DeleteLandmarkUC | undefined;
+    static addIfMissing(appObj: AppObject): DeleteLandmarkUC;
+    deleteLandmark: (id: string, quietly?: boolean, createUndo?: boolean) => void;
+    constructor(appObject: AppObject);
+}

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;