@vived/app 4.2.0 → 4.4.0

package/lib/Components/Landmarks/Entities/LandmarkEntity.d.ts

@@ -0,0 +1,40 @@
+import { AppObject, AppObjectEntity } from "../../../AppObject";
+import { Quaternion, QuaternionDTO, Vector3, Vector3DTO } from "../../../ValueObjects";
+import { Hideable } from "../../Hideable";
+import { Label } from "../../Label";
+import { OverlayColor, OverlayColorEnums } from "../../OverlayColor";
+import { Selectable } from "../../Selection";
+import { Transform3D } from "../../Transform3D";
+import { LandmarkRepo } from "./LandmarkRepo";
+export declare const LANDMARK_MINIMUM_SIZE: number;
+export declare const LANDMARK_MAXIMUM_SIZE: number;
+export interface LandmarkDTO {
+    id: string;
+    position: Vector3DTO;
+    size: number;
+    rotation: QuaternionDTO;
+    label: string;
+    defaultLabel: string;
+    parentID: string;
+    color: OverlayColorEnums;
+}
+export declare abstract class LandmarkEntity extends AppObjectEntity {
+    static readonly type = "LANDMARK";
+    static get(appObj: AppObject): LandmarkEntity | undefined;
+    abstract inRepo?: LandmarkRepo;
+    abstract get size(): number;
+    abstract set size(val: number);
+    abstract readonly parentID: string;
+    abstract get label(): Label;
+    abstract get transform(): Transform3D;
+    abstract get hideable(): Hideable;
+    abstract get overlayColor(): OverlayColor;
+    abstract get selectable(): Selectable;
+    abstract get position(): Vector3;
+    abstract set position(p: Vector3);
+    abstract get rotation(): Quaternion;
+    abstract set rotation(r: Quaternion);
+    abstract get data(): LandmarkDTO;
+    abstract set data(dto: LandmarkDTO);
+}
+export declare function makeLandmarkEntity(appObject: AppObject, parentID: string): LandmarkEntity;

package/lib/Components/Landmarks/Entities/LandmarkEntity.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeLandmarkEntity = exports.LandmarkEntity = exports.LANDMARK_MAXIMUM_SIZE = exports.LANDMARK_MINIMUM_SIZE = void 0;
+const AppObject_1 = require("../../../AppObject");
+const Entities_1 = require("../../../Entities");
+const ValueObjects_1 = require("../../../ValueObjects");
+const Hideable_1 = require("../../Hideable");
+const Label_1 = require("../../Label");
+const OverlayColor_1 = require("../../OverlayColor");
+const Selection_1 = require("../../Selection");
+const Transform3D_1 = require("../../Transform3D");
+exports.LANDMARK_MINIMUM_SIZE = 0.1;
+exports.LANDMARK_MAXIMUM_SIZE = 2;
+class LandmarkEntity extends AppObject_1.AppObjectEntity {
+    static get(appObj) {
+        return appObj.getComponent(this.type);
+    }
+}
+exports.LandmarkEntity = LandmarkEntity;
+LandmarkEntity.type = "LANDMARK";
+function makeLandmarkEntity(appObject, parentID) {
+    const landmark = new LandmarkImp(appObject, parentID);
+    return landmark;
+}
+exports.makeLandmarkEntity = makeLandmarkEntity;
+class LandmarkImp extends LandmarkEntity {
+    constructor(appObject, parentID) {
+        super(appObject, LandmarkEntity.type);
+        this.memoizedSize = new Entities_1.MemoizedNumber(1, this.notifyOnChange);
+        this.parentID = parentID;
+        this._label = Label_1.Label.addIfMissing(appObject);
+        this._label.addChangeObserver(this.notifyOnChange);
+        this._transform = Transform3D_1.Transform3D.addIfMissing(appObject);
+        this._transform.addChangeObserver(this.notifyOnChange);
+        this._hideable = Hideable_1.Hideable.addIfMissing(appObject);
+        this._hideable.addChangeObserver(this.notifyOnChange);
+        this._overlayColor = OverlayColor_1.OverlayColor.addIfMissing(appObject);
+        this._overlayColor.addChangeObserver(this.notifyOnChange);
+        this._selectable = Selection_1.makeSelectable(appObject);
+        this._selectable.addChangeObserver(this.notifyOnChange);
+    }
+    get label() {
+        return this._label;
+    }
+    get transform() {
+        return this._transform;
+    }
+    get hideable() {
+        return this._hideable;
+    }
+    get overlayColor() {
+        return this._overlayColor;
+    }
+    get selectable() {
+        return this._selectable;
+    }
+    get size() {
+        return this.memoizedSize.val;
+    }
+    set size(val) {
+        this.memoizedSize.val = val;
+    }
+    get position() {
+        return this._transform.localPosition;
+    }
+    set position(p) {
+        this._transform.localPosition = p;
+    }
+    get rotation() {
+        return this._transform.localRotation;
+    }
+    set rotation(r) {
+        this._transform.localRotation = r;
+    }
+    get data() {
+        return {
+            id: this.appObject.id,
+            parentID: this.parentID,
+            position: this.position.dto,
+            rotation: this.rotation.dto,
+            size: this.memoizedSize.val,
+            label: this._label.custom,
+            defaultLabel: this._label.default,
+            color: this._overlayColor.overlayColor,
+        };
+    }
+    set data(dto) {
+        this.rotation = ValueObjects_1.Quaternion.FromDTO(dto.rotation);
+        this.position = ValueObjects_1.Vector3.FromDTO(dto.position);
+        this.memoizedSize.val = dto.size;
+        this._label.custom = dto.label;
+        this._label.default = dto.defaultLabel;
+        this._overlayColor.overlayColor = dto.color;
+    }
+    dispose() {
+        super.dispose();
+        this._label.removeChangeObserver(this.notifyOnChange);
+        this._transform.removeChangeObserver(this.notifyOnChange);
+        this._hideable.removeChangeObserver(this.notifyOnChange);
+        this._overlayColor.removeChangeObserver(this.notifyOnChange);
+        this._selectable.removeChangeObserver(this.notifyOnChange);
+        this._label.dispose();
+        this._transform.dispose();
+        this._hideable.dispose();
+        this._overlayColor.dispose();
+        this._selectable.dispose();
+        if (this.inRepo) {
+            this.inRepo.removeForAppObject(this.appObject.id);
+        }
+    }
+}

package/lib/Components/Landmarks/Entities/LandmarkGlobals.d.ts

@@ -0,0 +1,14 @@
+import { AppObject, AppObjectEntity, AppObjectRepo } from "../../../AppObject";
+import { OverlayColorEnums } from "../../OverlayColor";
+import { LandmarkEntity } from "./LandmarkEntity";
+import { LandmarkRepo } from "./LandmarkRepo";
+export declare abstract class LandmarkGlobals extends AppObjectEntity {
+    static readonly type = "LandmarkGlobals";
+    static get: (appObjects: AppObjectRepo) => LandmarkGlobals | undefined;
+    abstract landmarkFactory(id: string): LandmarkEntity | undefined;
+    abstract landmarkRepoFactory(id: string): LandmarkRepo | undefined;
+    abstract lastSize: number;
+    abstract lastColor: OverlayColorEnums;
+    abstract readonly previewLandmark: LandmarkEntity;
+}
+export declare function makeLandmarkGlobals(appObject: AppObject): LandmarkGlobals;

package/lib/Components/Landmarks/Entities/LandmarkGlobals.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeLandmarkGlobals = exports.LandmarkGlobals = void 0;
+const AppObject_1 = require("../../../AppObject");
+const OverlayColor_1 = require("../../OverlayColor");
+const LandmarkEntity_1 = require("./LandmarkEntity");
+class LandmarkGlobals extends AppObject_1.AppObjectEntity {
+}
+exports.LandmarkGlobals = LandmarkGlobals;
+LandmarkGlobals.type = "LandmarkGlobals";
+LandmarkGlobals.get = (appObjects) => AppObject_1.getSingletonComponent(LandmarkGlobals.type, appObjects);
+function makeLandmarkGlobals(appObject) {
+    return new LandmarkConstantsImp(appObject);
+}
+exports.makeLandmarkGlobals = makeLandmarkGlobals;
+class LandmarkConstantsImp extends LandmarkGlobals {
+    constructor(appObject) {
+        super(appObject, LandmarkGlobals.type);
+        this.lastSize = 1;
+        this.lastColor = OverlayColor_1.OverlayColorEnums.BLUE;
+        this.appObjects.registerSingleton(this);
+        this.previewLandmark = LandmarkEntity_1.makeLandmarkEntity(appObject, "global");
+    }
+    landmarkFactory(id) {
+        this.error("Landmark Factory was in injected");
+        return;
+    }
+    landmarkRepoFactory(id) {
+        this.error("Landmark Repo Factory was in injected");
+        return;
+    }
+}

package/lib/Components/Landmarks/Entities/LandmarkRepo.d.ts

@@ -0,0 +1,9 @@
+import { AppObject, AppObjectEntityRepo } from "../../../AppObject";
+import { LandmarkEntity } from "./LandmarkEntity";
+export declare type LandmarkFactory = (id: string) => LandmarkEntity;
+export declare abstract class LandmarkRepo extends AppObjectEntityRepo<LandmarkEntity> {
+    static readonly type = "LANDMARK_REPO";
+    static get(appObj: AppObject): LandmarkRepo | undefined;
+    static addIfMissing(appObject: AppObject): LandmarkRepo;
+}
+export declare function makeLandmarkRepoEntity(appObject: AppObject): LandmarkRepo;

package/lib/Components/Landmarks/Entities/LandmarkRepo.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeLandmarkRepoEntity = exports.LandmarkRepo = void 0;
+const AppObject_1 = require("../../../AppObject");
+class LandmarkRepo extends AppObject_1.AppObjectEntityRepo {
+    static get(appObj) {
+        return appObj.getComponent(this.type);
+    }
+    static addIfMissing(appObject) {
+        const existing = appObject.getComponent(LandmarkRepo.type);
+        if (existing) {
+            return existing;
+        }
+        else {
+            return makeLandmarkRepoEntity(appObject);
+        }
+    }
+}
+exports.LandmarkRepo = LandmarkRepo;
+LandmarkRepo.type = "LANDMARK_REPO";
+function makeLandmarkRepoEntity(appObject) {
+    return new LandmarkRepoImp(appObject);
+}
+exports.makeLandmarkRepoEntity = makeLandmarkRepoEntity;
+class LandmarkRepoImp extends LandmarkRepo {
+    add(landmark) {
+        super.add(landmark);
+        landmark.inRepo = this;
+    }
+    constructor(appObject) {
+        super(appObject, LandmarkRepo.type);
+    }
+}

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

@@ -0,0 +1,3 @@
+export * from "./LandmarkEntity";
+export * from "./LandmarkGlobals";
+export * from "./LandmarkRepo";

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

@@ -0,0 +1,15 @@
+"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("./LandmarkEntity"), exports);
+__exportStar(require("./LandmarkGlobals"), exports);
+__exportStar(require("./LandmarkRepo"), exports);

package/lib/Components/Landmarks/Mocks/MockLandmark.d.ts

@@ -0,0 +1,27 @@
+import { AppObject } from "../../../AppObject";
+import { Quaternion, Vector3 } from "../../../ValueObjects";
+import { Hideable } from "../../Hideable";
+import { Label } from "../../Label";
+import { OverlayColor } from "../../OverlayColor";
+import { Selectable } from "../../Selection";
+import { Transform3D } from "../../Transform3D";
+import { LandmarkDTO, LandmarkEntity } from "../Entities/LandmarkEntity";
+import { LandmarkRepo } from "../Entities/LandmarkRepo";
+export declare class MockLandmark extends LandmarkEntity {
+    inRepo?: LandmarkRepo | undefined;
+    get size(): number;
+    set size(val: number);
+    parentID: string;
+    get label(): Label;
+    get transform(): Transform3D;
+    get hideable(): Hideable;
+    get overlayColor(): OverlayColor;
+    get selectable(): Selectable;
+    get position(): Vector3;
+    set position(p: Vector3);
+    get rotation(): Quaternion;
+    set rotation(r: Quaternion);
+    get data(): LandmarkDTO;
+    set data(dto: LandmarkDTO);
+    constructor(appObject: AppObject);
+}

package/lib/Components/Landmarks/Mocks/MockLandmark.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockLandmark = void 0;
+const LandmarkEntity_1 = require("../Entities/LandmarkEntity");
+class MockLandmark extends LandmarkEntity_1.LandmarkEntity {
+    constructor(appObject) {
+        super(appObject, LandmarkEntity_1.LandmarkEntity.type);
+        this.parentID = "";
+    }
+    get size() {
+        throw new Error("Method not implemented.");
+    }
+    set size(val) {
+        throw new Error("Method not implemented.");
+    }
+    get label() {
+        throw new Error("Method not implemented.");
+    }
+    get transform() {
+        throw new Error("Method not implemented.");
+    }
+    get hideable() {
+        throw new Error("Method not implemented.");
+    }
+    get overlayColor() {
+        throw new Error("Method not implemented.");
+    }
+    get selectable() {
+        throw new Error("Method not implemented.");
+    }
+    get position() {
+        throw new Error("Method not implemented.");
+    }
+    set position(p) {
+        throw new Error("Method not implemented.");
+    }
+    get rotation() {
+        throw new Error("Method not implemented.");
+    }
+    set rotation(r) {
+        throw new Error("Method not implemented.");
+    }
+    get data() {
+        throw new Error("Method not implemented.");
+    }
+    set data(dto) {
+        throw new Error("Method not implemented.");
+    }
+}
+exports.MockLandmark = MockLandmark;

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

@@ -0,0 +1,10 @@
+import { AppObject, AppObjectPM } from "../../../AppObject";
+export declare class LandmarkListPM extends AppObjectPM<string[]> {
+    static readonly type = "LandmarkListPM";
+    static addIfMissing(appObj: AppObject): LandmarkListPM;
+    private landmarkRepo?;
+    vmsAreEqual(a: string[], b: string[]): boolean;
+    onRepoChange: () => void;
+    dispose: () => void;
+    constructor(appObject: AppObject);
+}

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

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LandmarkListPM = void 0;
+const AppObject_1 = require("../../../AppObject");
+const LandmarkRepo_1 = require("../Entities/LandmarkRepo");
+class LandmarkListPM extends AppObject_1.AppObjectPM {
+    constructor(appObject) {
+        super(appObject, LandmarkListPM.type);
+        this.onRepoChange = () => {
+            if (!this.landmarkRepo)
+                return;
+            const landmarks = this.landmarkRepo.getAll();
+            const ids = landmarks.map((landmark) => landmark.appObject.id);
+            this.doUpdateView(ids);
+        };
+        this.dispose = () => {
+            var _a, _b;
+            super.dispose();
+            (_a = this.landmarkRepo) === null || _a === void 0 ? void 0 : _a.removeChangeObserver(this.onRepoChange);
+            (_b = this.landmarkRepo) === null || _b === void 0 ? void 0 : _b.removeOnDisposeObserver(this.dispose);
+        };
+        this.landmarkRepo = appObject.getComponent(LandmarkRepo_1.LandmarkRepo.type);
+        if (this.landmarkRepo) {
+            this.landmarkRepo.addChangeObserver(this.onRepoChange);
+            this.landmarkRepo.addOnDisposeObserver(() => this.dispose());
+            this.onRepoChange();
+        }
+        else {
+            console.warn("[LandmarkListPM] App Object does not have a LandmarkRepo Entity");
+        }
+    }
+    static addIfMissing(appObj) {
+        const existing = appObj.getComponent(LandmarkListPM.type);
+        if (existing) {
+            return existing;
+        }
+        else {
+            return new LandmarkListPM(appObj);
+        }
+    }
+    vmsAreEqual(a, b) {
+        return a.length === b.length;
+    }
+}
+exports.LandmarkListPM = LandmarkListPM;
+LandmarkListPM.type = "LandmarkListPM";

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

@@ -0,0 +1,10 @@
+import { AppObject, AppObjectPM } from "../../../AppObject";
+export declare 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);
+}

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

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LandmarkSizePM = void 0;
+const AppObject_1 = require("../../../AppObject");
+const LandmarkEntity_1 = require("../Entities/LandmarkEntity");
+class LandmarkSizePM extends AppObject_1.AppObjectPM {
+    constructor(appObject) {
+        super(appObject, LandmarkSizePM.type);
+        this.onRepoChange = () => {
+            if (!this.landmarkEntity)
+                return;
+            this.doUpdateView(this.landmarkEntity.size);
+        };
+        this.dispose = () => {
+            var _a, _b;
+            super.dispose();
+            (_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");
+        }
+    }
+    static addIfMissing(appObj) {
+        const existing = appObj.getComponent(LandmarkSizePM.type);
+        if (existing) {
+            return existing;
+        }
+        else {
+            return new LandmarkSizePM(appObj);
+        }
+    }
+    vmsAreEqual(a, b) {
+        return a === b;
+    }
+}
+exports.LandmarkSizePM = LandmarkSizePM;
+LandmarkSizePM.type = "LandmarkSizePM";

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

@@ -0,0 +1,2 @@
+export * from "./LandmarkListPM";
+export * from "./LandmarkSizePM";

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

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

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

@@ -0,0 +1,8 @@
+import { AppObject, AppObjectUC } from "../../../AppObject";
+import { LandmarkDTO, LandmarkEntity } from "../Entities/LandmarkEntity";
+export declare abstract class AddLandmarkUC extends AppObjectUC {
+    static readonly type = "AddLandmarkUC";
+    abstract addFromData(data: LandmarkDTO): LandmarkEntity | undefined;
+    abstract addNew(): LandmarkEntity | undefined;
+}
+export declare function makeAddLandmarkUC(appObject: AppObject): AddLandmarkUC;

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);
+}