@vived/app 4.24.0 → 4.26.0

package/lib/Components/Landmarks/PM/LandmarkSizePM.d.ts

@@ -1,10 +1,6 @@
-import { AppObject, AppObjectPM } from "../../../AppObject";
-export declare class LandmarkSizePM extends AppObjectPM<number> {
+import { AppObject, AppObjectPM, AppObjectRepo } from "../../../AppObject";
+export declare abstract class LandmarkSizePM extends AppObjectPM<number> {
     static readonly type = "LandmarkSizePM";
-    static addIfMissing(appObj: AppObject): LandmarkSizePM;
-    private landmarkEntity?;
-    vmsAreEqual(a: number, b: number): boolean;
-    onRepoChange: () => void;
-    dispose: () => void;
-    constructor(appObject: AppObject);
+    static get(id: string, appObjects: AppObjectRepo): LandmarkSizePM | undefined;
 }
+export declare function makeLandmarkSizePM(appObject: AppObject): LandmarkSizePM;

package/lib/Components/Landmarks/PM/LandmarkSizePM.js

@@ -1,10 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LandmarkSizePM = void 0;
+exports.makeLandmarkSizePM = exports.LandmarkSizePM = void 0;
 const AppObject_1 = require("../../../AppObject");
 const LandmarkEntity_1 = require("../Entities/LandmarkEntity");
 class LandmarkSizePM extends AppObject_1.AppObjectPM {
+    static get(id, appObjects) {
+        var _a;
+        return (_a = appObjects
+            .get(id)) === null || _a === void 0 ? void 0 : _a.getComponent(LandmarkSizePM.type);
+    }
+}
+exports.LandmarkSizePM = LandmarkSizePM;
+LandmarkSizePM.type = "LandmarkSizePM";
+function makeLandmarkSizePM(appObject) {
+    return new LandmarkSizePMImp(appObject);
+}
+exports.makeLandmarkSizePM = makeLandmarkSizePM;
+class LandmarkSizePMImp extends LandmarkSizePM {
     constructor(appObject) {
+        var _a;
         super(appObject, LandmarkSizePM.type);
         this.onRepoChange = () => {
             if (!this.landmarkEntity)
@@ -17,28 +31,13 @@ class LandmarkSizePM extends AppObject_1.AppObjectPM {
             (_a = this.landmarkEntity) === null || _a === void 0 ? void 0 : _a.removeChangeObserver(this.onRepoChange);
             (_b = this.landmarkEntity) === null || _b === void 0 ? void 0 : _b.removeOnDisposeObserver(this.dispose);
         };
-        this.landmarkEntity = appObject.getComponent(LandmarkEntity_1.LandmarkEntity.type);
-        if (this.landmarkEntity) {
-            this.landmarkEntity.addChangeObserver(this.onRepoChange);
-            this.landmarkEntity.addOnDisposeObserver(() => this.dispose());
-            this.onRepoChange();
-        }
-        else {
-            console.warn("[LandmarkSizePM] App Object does not have a LandmarkEntity Entity");
-        }
+        (_a = this.landmarkEntity) === null || _a === void 0 ? void 0 : _a.addChangeObserver(this.onRepoChange);
+        this.onRepoChange();
     }
-    static addIfMissing(appObj) {
-        const existing = appObj.getComponent(LandmarkSizePM.type);
-        if (existing) {
-            return existing;
-        }
-        else {
-            return new LandmarkSizePM(appObj);
-        }
+    get landmarkEntity() {
+        return this.getCachedLocalComponent(LandmarkEntity_1.LandmarkEntity.type);
     }
     vmsAreEqual(a, b) {
         return a === b;
     }
 }
-exports.LandmarkSizePM = LandmarkSizePM;
-LandmarkSizePM.type = "LandmarkSizePM";

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

@@ -1,13 +1,11 @@
-import { AppObject } from "../../../AppObject";
+import { AppObjectRepo } 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?;
+    private appObjects;
+    private get landmarkRepo();
     undoAction: () => void;
     redoAction: () => void;
-    constructor(landmarkDTO: LandmarkDTO, appObject: AppObject);
+    constructor(landmarkDTO: LandmarkDTO, appObjects: AppObjectRepo);
 }

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

@@ -4,45 +4,32 @@ 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) {
+    constructor(landmarkDTO, appObjects) {
         this.landmarkDTO = landmarkDTO;
-        this.appObject = appObject;
+        this.appObjects = appObjects;
         this.undoAction = () => {
-            if (!this.deleteLandmarkUC)
+            if (!this.landmarkRepo)
                 return;
-            this.deleteLandmarkUC.deleteLandmark(this.landmarkDTO.id, true);
-            DispatchStateChangeUC_1.dispatchStateChange(this.appObject.appObjectRepo);
+            this.landmarkRepo.deleteLandmark(this.landmarkDTO.id);
+            DispatchStateChangeUC_1.dispatchStateChange(this.appObjects);
         };
         this.redoAction = () => {
-            if (!this.addLandmarkUC)
+            if (!this.landmarkRepo)
                 return;
-            this.addLandmarkUC.addFromData(this.landmarkDTO);
-            DispatchStateChangeUC_1.dispatchStateChange(this.appObject.appObjectRepo);
+            const landmark = this.landmarkRepo.createLandmark(this.landmarkDTO.id);
+            landmark.data = this.landmarkDTO;
+            DispatchStateChangeUC_1.dispatchStateChange(this.appObjects);
         };
-        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);
+        const undoRedo = UndoRedoEntity_1.UndoRedoEntity.get(appObjects);
         if (!undoRedo) {
-            appObject.appObjectRepo.submitWarning("AddLandmarkUndoRedo", "Unable to find UndoRedoEntity");
+            appObjects.submitWarning("AddLandmarkUndoRedo", "Unable to find UndoRedoEntity");
             return;
         }
         undoRedo.submitAction(this);
     }
+    get landmarkRepo() {
+        return LandmarkRepo_1.LandmarkRepo.getByID(this.landmarkDTO.parentID, this.appObjects);
+    }
 }
 exports.AddLandmarkUndoRedo = AddLandmarkUndoRedo;

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

@@ -0,0 +1,7 @@
+import { AppObject, AppObjectRepo, AppObjectUC } from "../../../AppObject";
+export declare abstract class DeleteAllLandmarksUC extends AppObjectUC {
+    static readonly type = "DeleteAllLandmarksUC";
+    abstract deleteAllLandmarks(): void;
+    static get: (appObjects: AppObjectRepo) => DeleteAllLandmarksUC | undefined;
+}
+export declare function makeDeleteAllLandmarksUC(appObject: AppObject): DeleteAllLandmarksUC;

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

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeDeleteAllLandmarksUC = exports.DeleteAllLandmarksUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const Dispatcher_1 = require("../../Dispatcher");
+const LandmarkRepo_1 = require("../Entities/LandmarkRepo");
+const DeleteAllLandmarksUndoRedo_1 = require("./DeleteAllLandmarksUndoRedo");
+class DeleteAllLandmarksUC extends AppObject_1.AppObjectUC {
+}
+exports.DeleteAllLandmarksUC = DeleteAllLandmarksUC;
+DeleteAllLandmarksUC.type = "DeleteAllLandmarksUC";
+DeleteAllLandmarksUC.get = (appObjects) => AppObject_1.getSingletonComponent(DeleteAllLandmarksUC.type, appObjects);
+function makeDeleteAllLandmarksUC(appObject) {
+    return new DeleteAllCalloutsUCImp(appObject);
+}
+exports.makeDeleteAllLandmarksUC = makeDeleteAllLandmarksUC;
+class DeleteAllCalloutsUCImp extends DeleteAllLandmarksUC {
+    deleteAllLandmarks() {
+        const deletedLandmarks = [];
+        const landmarkRepos = this.appObjects.getAllComponents(LandmarkRepo_1.LandmarkRepo.type);
+        landmarkRepos.forEach((repo) => {
+            const callouts = repo.getAll();
+            callouts.forEach((landmark) => {
+                deletedLandmarks.push(landmark.data);
+                repo.removeForAppObject(landmark.appObject.id);
+                landmark.appObject.dispose();
+            });
+        });
+        Dispatcher_1.dispatchStateChange(this.appObjects);
+        new DeleteAllLandmarksUndoRedo_1.DeleteAllLandmarksUndoRedo(deletedLandmarks, this.appObjects);
+    }
+    constructor(appObject) {
+        super(appObject, DeleteAllLandmarksUC.type);
+    }
+}

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

@@ -0,0 +1,10 @@
+import { AppObjectRepo } from "../../../AppObject";
+import { UndoRedoAction } from "../../UndoRedo";
+import { LandmarkDTO } from "../Entities/LandmarkEntity";
+export declare class DeleteAllLandmarksUndoRedo implements UndoRedoAction {
+    private deletedLandmarks;
+    private appObjects;
+    undoAction: () => void;
+    redoAction: () => void;
+    constructor(deletedLandmarks: LandmarkDTO[], appObjects: AppObjectRepo);
+}

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

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeleteAllLandmarksUndoRedo = void 0;
+const Dispatcher_1 = require("../../Dispatcher");
+const UndoRedo_1 = require("../../UndoRedo");
+const LandmarkRepo_1 = require("../Entities/LandmarkRepo");
+class DeleteAllLandmarksUndoRedo {
+    constructor(deletedLandmarks, appObjects) {
+        this.deletedLandmarks = deletedLandmarks;
+        this.appObjects = appObjects;
+        this.undoAction = () => {
+            this.deletedLandmarks.forEach((deletedLandmark) => {
+                const landmarkRepo = LandmarkRepo_1.LandmarkRepo.getByID(deletedLandmark.parentID, this.appObjects);
+                if (!landmarkRepo) {
+                    return;
+                }
+                const landmark = landmarkRepo.createLandmark(deletedLandmark.id);
+                landmark.data = deletedLandmark;
+            });
+            Dispatcher_1.dispatchStateChange(this.appObjects);
+        };
+        this.redoAction = () => {
+            this.deletedLandmarks.forEach((deletedLandmark) => {
+                const repo = LandmarkRepo_1.LandmarkRepo.getByID(deletedLandmark.parentID, this.appObjects);
+                repo === null || repo === void 0 ? void 0 : repo.deleteLandmark(deletedLandmark.id);
+            });
+            Dispatcher_1.dispatchStateChange(this.appObjects);
+        };
+        const undoRedo = UndoRedo_1.UndoRedoEntity.get(appObjects);
+        if (!undoRedo) {
+            appObjects.submitWarning("DeleteAllLandmarksUndoRedo", "Unable to find UndoRedoEntity");
+            return;
+        }
+        undoRedo.submitAction(this);
+    }
+}
+exports.DeleteAllLandmarksUndoRedo = DeleteAllLandmarksUndoRedo;

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

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

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

@@ -1,48 +1,38 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DeleteLandmarkUC = void 0;
+exports.makeDeleteLandmarkUC = exports.DeleteLandmarkUC = void 0;
 const AppObject_1 = require("../../../AppObject");
 const Dispatcher_1 = require("../../Dispatcher");
 const Entities_1 = require("../Entities");
 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 = Entities_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(Entities_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);
-        }
+    static getById(id, appObjs) {
+        var _a;
+        return (_a = appObjs.get(id)) === null || _a === void 0 ? void 0 : _a.getComponent(this.type);
     }
 }
 exports.DeleteLandmarkUC = DeleteLandmarkUC;
 DeleteLandmarkUC.type = "DeleteLandmarkUC";
+function makeDeleteLandmarkUC(appObject) {
+    return new DeleteLandmarkUCImp(appObject);
+}
+exports.makeDeleteLandmarkUC = makeDeleteLandmarkUC;
+class DeleteLandmarkUCImp extends DeleteLandmarkUC {
+    constructor(appObject) {
+        super(appObject, DeleteLandmarkUC.type);
+        this.deleteLandmark = () => {
+            var _a;
+            if (!this.landmark)
+                return;
+            new DeleteLandmarkUndoRedo_1.DeleteLandmarkUndoRedo(this.landmark.data, this.appObjects);
+            (_a = this.landmark.inRepo) === null || _a === void 0 ? void 0 : _a.deleteLandmark(this.landmark.id);
+            Dispatcher_1.dispatchStateChange(this.appObjects);
+        };
+    }
+    get landmark() {
+        return this.getCachedLocalComponent(Entities_1.LandmarkEntity.type);
+    }
+}

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

@@ -1,13 +1,11 @@
-import { AppObject } from "../../../AppObject";
+import { AppObjectRepo } 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?;
+    private appObjects;
+    private get landmarkRepo();
     undoAction: () => void;
     redoAction: () => void;
-    constructor(landmarkDTO: LandmarkDTO, appObject: AppObject);
+    constructor(landmarkDTO: LandmarkDTO, appObjects: AppObjectRepo);
 }

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

@@ -4,45 +4,32 @@ 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) {
+    constructor(landmarkDTO, appObjects) {
         this.landmarkDTO = landmarkDTO;
-        this.appObject = appObject;
+        this.appObjects = appObjects;
         this.undoAction = () => {
-            if (!this.addLandmarkUC)
+            if (!this.landmarkRepo)
                 return;
-            this.addLandmarkUC.addFromData(this.landmarkDTO);
-            DispatchStateChangeUC_1.dispatchStateChange(this.appObject.appObjectRepo);
+            const landmark = this.landmarkRepo.createLandmark(this.landmarkDTO.id);
+            landmark.data = this.landmarkDTO;
+            DispatchStateChangeUC_1.dispatchStateChange(this.appObjects);
         };
         this.redoAction = () => {
-            if (!this.deleteLandmarkUC)
+            if (!this.landmarkRepo)
                 return;
-            this.deleteLandmarkUC.deleteLandmark(this.landmarkDTO.id, true);
-            DispatchStateChangeUC_1.dispatchStateChange(this.appObject.appObjectRepo);
+            this.landmarkRepo.deleteLandmark(this.landmarkDTO.id);
+            DispatchStateChangeUC_1.dispatchStateChange(this.appObjects);
         };
-        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);
+        const undoRedo = UndoRedoEntity_1.UndoRedoEntity.get(appObjects);
         if (!undoRedo) {
-            appObject.appObjectRepo.submitWarning("DeleteLandmarkUndoRedo", "Unable to find UndoRedoEntity");
+            appObjects.submitWarning("DeleteLandmarkUndoRedo", "Unable to find UndoRedoEntity");
             return;
         }
         undoRedo.submitAction(this);
     }
+    get landmarkRepo() {
+        return LandmarkRepo_1.LandmarkRepo.getByID(this.landmarkDTO.parentID, this.appObjects);
+    }
 }
 exports.DeleteLandmarkUndoRedo = DeleteLandmarkUndoRedo;

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

@@ -5,9 +5,11 @@ export declare class SerializeLandmarks extends AppObjectUC implements Serialize
     static readonly type = "SerializeLandmarks";
     name: string;
     seriliziationVersion: number;
+    private get globals();
     getSystemState(): object;
     applySystemState(state: object, version: number): void;
     private handleStateVersion1;
+    private disposeLandmark;
     applyDefaultState(): void;
     constructor(appObj: AppObject);
 }

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

@@ -2,18 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SerializeLandmarks = void 0;
 const AppObject_1 = require("../../../AppObject");
-const Entities_1 = require("../../Enablement/Entities");
-const Entities_2 = require("../../StateMachine/Entities");
+const Entities_1 = require("../../StateMachine/Entities");
 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(Entities_2.StateMachineEntity.type);
+        const stateMachine = this.appObjects.getSingleton(Entities_1.StateMachineEntity.type);
         if (stateMachine) {
             stateMachine.registerSerializedSystem(this);
         }
@@ -21,21 +19,15 @@ class SerializeLandmarks extends AppObject_1.AppObjectUC {
             this.warn("Unable to find StateMachineEntity");
         }
     }
+    get globals() {
+        return this.getCachedSingleton(LandmarkGlobals_1.LandmarkGlobals.type);
+    }
     getSystemState() {
-        const repos = this.appObjects.getAllComponents(LandmarkRepo_1.LandmarkRepo.type);
+        const allLandmarks = this.appObjects.getAllComponents(LandmarkEntity_1.LandmarkEntity.type);
         const landmarks = [];
-        repos.forEach((repo) => {
-            const enabledEntity = repo.appObject.getComponent(Entities_1.EnablementEntity.type);
-            let enabled = false;
-            if (enabledEntity) {
-                enabled = enabledEntity.enabled;
-            }
-            if (enabled) {
-                repo.getAll().forEach((landmark) => {
-                    if (landmark.parentID) {
-                        landmarks.push(landmark.data);
-                    }
-                });
+        allLandmarks.forEach((landmark) => {
+            if (landmark.parentID) {
+                landmarks.push(landmark.data);
             }
         });
         return {
@@ -71,36 +63,31 @@ class SerializeLandmarks extends AppObject_1.AppObjectUC {
             if (existing) {
                 existing.data = landmarkData;
                 previousLandmarkLookup.delete(landmarkData.id);
+                return;
             }
-            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");
+            let repo = this.appObjects.getAppObjectComponent(landmarkData.parentID, LandmarkRepo_1.LandmarkRepo.type);
+            if (!repo) {
+                repo = (_a = this.globals) === null || _a === void 0 ? void 0 : _a.landmarkRepoFactory(landmarkData.parentID);
             }
+            const landmark = repo.createLandmark(landmarkData.id);
+            landmark.data = landmarkData;
         });
         previousLandmarkLookup.forEach((landmark) => {
-            var _a;
-            (_a = landmark.inRepo) === null || _a === void 0 ? void 0 : _a.removeForAppObject(landmark.appObject.id);
-            landmark.appObject.dispose();
+            this.disposeLandmark(landmark);
         });
     }
+    disposeLandmark(landmark) {
+        const repo = LandmarkRepo_1.LandmarkRepo.getByID(landmark.parentID, this.appObjects);
+        if (repo) {
+            repo.deleteLandmark(landmark.appObject.id);
+        }
+    }
     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);
-                }
-            });
+        const allLandmarks = this.appObjects.getAllComponents(LandmarkEntity_1.LandmarkEntity.type);
+        allLandmarks.forEach((landmark) => {
+            if (landmark.parentID) {
+                this.disposeLandmark(landmark);
+            }
         });
     }
 }

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

@@ -1,12 +1,9 @@
-import { AppObject, AppObjectUC } from "../../../AppObject";
-export declare class SetLandmarkSizeUC extends AppObjectUC {
+import { AppObject, AppObjectRepo, AppObjectUC } from "../../../AppObject";
+export declare abstract 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);
+    abstract updateSize(size: number): void;
+    abstract submitSize(size: number): void;
     static get(appObj: AppObject): SetLandmarkSizeUC | undefined;
+    static getById(id: string, appObjects: AppObjectRepo): SetLandmarkSizeUC | undefined;
 }
+export declare function makeSetLandmarkSizeUC(appObject: AppObject): SetLandmarkSizeUC;

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

@@ -1,27 +1,35 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SetLandmarkSizeUC = void 0;
+exports.makeSetLandmarkSizeUC = 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 {
+    static get(appObj) {
+        return appObj.getComponent(this.type);
+    }
+    static getById(id, appObjects) {
+        var _a;
+        return (_a = appObjects.get(id)) === null || _a === void 0 ? void 0 : _a.getComponent(this.type);
+    }
+}
+exports.SetLandmarkSizeUC = SetLandmarkSizeUC;
+SetLandmarkSizeUC.type = "SetLandmarkSizeUC";
+function makeSetLandmarkSizeUC(appObject) {
+    return new SetLandmarkSizeUCImp(appObject);
+}
+exports.makeSetLandmarkSizeUC = makeSetLandmarkSizeUC;
+class SetLandmarkSizeUCImp extends SetLandmarkSizeUC {
     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));
+    get landmark() {
+        return this.getCachedLocalComponent(LandmarkEntity_1.LandmarkEntity.type);
+    }
+    get landmarkGlobals() {
+        return this.getCachedSingleton(LandmarkGlobals_1.LandmarkGlobals.type);
     }
     updateSize(size) {
         if (!this.landmark)
@@ -29,11 +37,9 @@ class SetLandmarkSizeUC extends AppObject_1.AppObjectUC {
         if (!this.landmarkGlobals)
             return;
         if (this.initialValue === undefined) {
-            this.initialValue = size;
+            this.initialValue = this.landmark.size;
         }
-        const clampedSize = this.getClampedSize(size);
-        this.landmark.size = clampedSize;
-        this.landmarkGlobals.lastSize = clampedSize;
+        this.landmark.size = size;
     }
     submitSize(size) {
         if (!this.initialValue)
@@ -42,16 +48,16 @@ class SetLandmarkSizeUC extends AppObject_1.AppObjectUC {
             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.landmark.size = size;
+        this.landmarkGlobals.lastSize = size;
+        if (this.initialValue && this.initialValue !== this.landmark.size) {
+            new SetLandmarkSizeUndoRedo_1.SetLandmarkSizeUndoRedo({
+                landmark: this.landmark,
+                redoSize: this.landmark.size,
+                undoSize: this.initialValue,
+            }, this.appObjects);
+            Dispatcher_1.dispatchStateChange(this.appObjects);
+        }
         this.initialValue = undefined;
     }
-    static get(appObj) {
-        return appObj.getComponent(this.type);
-    }
 }
-exports.SetLandmarkSizeUC = SetLandmarkSizeUC;
-SetLandmarkSizeUC.type = "SetLandmarkSizeUC";