@vived/app 4.27.1 → 4.28.1

package/lib/Components/Callouts/PM/CalloutListPM.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeCalloutListPM = exports.CalloutListPM = void 0;
+const AppObject_1 = require("../../../AppObject");
+const CalloutRepo_1 = require("../Entities/CalloutRepo");
+class CalloutListPM extends AppObject_1.AppObjectPM {
+    static getById(id, appObjects) {
+        var _a;
+        return (_a = appObjects.get(id)) === null || _a === void 0 ? void 0 : _a.getComponent(CalloutListPM.type);
+    }
+}
+exports.CalloutListPM = CalloutListPM;
+CalloutListPM.type = "CalloutListPM";
+function makeCalloutListPM(appObject) {
+    return new CalloutListPMImp(appObject);
+}
+exports.makeCalloutListPM = makeCalloutListPM;
+class CalloutListPMImp extends CalloutListPM {
+    constructor(appObject) {
+        var _a;
+        super(appObject, CalloutListPM.type);
+        this.onRepoChange = () => {
+            if (!this.calloutRepo)
+                return;
+            const callouts = this.calloutRepo.getAll();
+            const ids = callouts.map((callout) => callout.appObject.id);
+            this.doUpdateView(ids);
+        };
+        (_a = this.calloutRepo) === null || _a === void 0 ? void 0 : _a.addChangeObserver(this.onRepoChange);
+        this.onRepoChange();
+    }
+    get calloutRepo() {
+        return this.getCachedLocalComponent(CalloutRepo_1.CalloutRepo.type);
+    }
+    vmsAreEqual(a, b) {
+        if (a.length !== b.length)
+            return false;
+        let idAreTheSame = true;
+        a.forEach((aId, i) => {
+            if (!idAreTheSame)
+                return;
+            const bId = b[i];
+            if (aId !== bId) {
+                idAreTheSame = false;
+            }
+        });
+        return idAreTheSame;
+    }
+}

package/lib/Components/Callouts/PM/CalloutOffsetPM.d.ts

@@ -0,0 +1,7 @@
+import { AppObject, AppObjectPM, AppObjectRepo } from "../../../AppObject";
+import { CalloutOffsetDirection } from "../Entities/CalloutEntity";
+export declare abstract class CalloutOffsetPM extends AppObjectPM<CalloutOffsetDirection> {
+    static readonly type = "CalloutOffsetPM";
+    static get(id: string, appObjects: AppObjectRepo): CalloutOffsetPM | undefined;
+}
+export declare function makeCalloutOffsetPM(appObject: AppObject): CalloutOffsetPM;

package/lib/Components/Callouts/PM/CalloutOffsetPM.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeCalloutOffsetPM = exports.CalloutOffsetPM = void 0;
+const AppObject_1 = require("../../../AppObject");
+const CalloutEntity_1 = require("../Entities/CalloutEntity");
+class CalloutOffsetPM extends AppObject_1.AppObjectPM {
+    static get(id, appObjects) {
+        var _a;
+        return (_a = appObjects
+            .get(id)) === null || _a === void 0 ? void 0 : _a.getComponent(CalloutOffsetPM.type);
+    }
+}
+exports.CalloutOffsetPM = CalloutOffsetPM;
+CalloutOffsetPM.type = "CalloutOffsetPM";
+function makeCalloutOffsetPM(appObject) {
+    return new CalloutOffsetPMImp(appObject);
+}
+exports.makeCalloutOffsetPM = makeCalloutOffsetPM;
+class CalloutOffsetPMImp extends CalloutOffsetPM {
+    constructor(appObject) {
+        var _a;
+        super(appObject, CalloutOffsetPM.type);
+        this.onChange = () => {
+            if (!this.callout)
+                return;
+            this.doUpdateView(this.callout.offsetDirection);
+        };
+        (_a = this.callout) === null || _a === void 0 ? void 0 : _a.addChangeObserver(this.onChange);
+        this.onChange();
+    }
+    get callout() {
+        return this.getCachedLocalComponent(CalloutEntity_1.CalloutEntity.type);
+    }
+    vmsAreEqual(a, b) {
+        return a === b;
+    }
+}

package/lib/Components/Callouts/PM/CalloutSizePM.d.ts

@@ -0,0 +1,6 @@
+import { AppObject, AppObjectPM, AppObjectRepo } from "../../../AppObject";
+export declare abstract class CalloutSizePM extends AppObjectPM<number> {
+    static readonly type = "CalloutSizePM";
+    static get(id: string, appObjects: AppObjectRepo): CalloutSizePM | undefined;
+}
+export declare function makeCalloutSizePM(appObject: AppObject): CalloutSizePM;

package/lib/Components/Callouts/PM/CalloutSizePM.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeCalloutSizePM = exports.CalloutSizePM = void 0;
+const AppObject_1 = require("../../../AppObject");
+const CalloutEntity_1 = require("../Entities/CalloutEntity");
+class CalloutSizePM extends AppObject_1.AppObjectPM {
+    static get(id, appObjects) {
+        var _a;
+        return (_a = appObjects.get(id)) === null || _a === void 0 ? void 0 : _a.getComponent(CalloutSizePM.type);
+    }
+}
+exports.CalloutSizePM = CalloutSizePM;
+CalloutSizePM.type = "CalloutSizePM";
+function makeCalloutSizePM(appObject) {
+    return new CalloutSizePMImp(appObject);
+}
+exports.makeCalloutSizePM = makeCalloutSizePM;
+class CalloutSizePMImp extends CalloutSizePM {
+    constructor(appObject) {
+        var _a;
+        super(appObject, CalloutSizePM.type);
+        this.onEntityChange = () => {
+            if (!this.calloutEntity)
+                return;
+            this.doUpdateView(this.calloutEntity.size);
+        };
+        this.dispose = () => {
+            var _a;
+            super.dispose();
+            (_a = this.calloutEntity) === null || _a === void 0 ? void 0 : _a.removeChangeObserver(this.onEntityChange);
+        };
+        (_a = this.calloutEntity) === null || _a === void 0 ? void 0 : _a.addChangeObserver(this.onEntityChange);
+        this.onEntityChange();
+    }
+    get calloutEntity() {
+        return this.getCachedLocalComponent(CalloutEntity_1.CalloutEntity.type);
+    }
+    vmsAreEqual(a, b) {
+        return a === b;
+    }
+}

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

@@ -0,0 +1,4 @@
+export * from "./CalloutLinePointsPM";
+export * from "./CalloutListPM";
+export * from "./CalloutOffsetPM";
+export * from "./CalloutSizePM";

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

@@ -0,0 +1,16 @@
+"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("./CalloutLinePointsPM"), exports);
+__exportStar(require("./CalloutListPM"), exports);
+__exportStar(require("./CalloutOffsetPM"), exports);
+__exportStar(require("./CalloutSizePM"), exports);

package/lib/Components/Callouts/UC/CalloutScaleHook.d.ts

@@ -0,0 +1,11 @@
+import { AppObject, AppObjectUC } from "../../../AppObject";
+export declare class CalloutScaleHook extends AppObjectUC {
+    static type: string;
+    private get sceneRoot();
+    private get callout();
+    private lastRootScale?;
+    private lastCalloutSize?;
+    private onEntityChange;
+    dispose: () => void;
+    constructor(appObject: AppObject);
+}

package/lib/Components/Callouts/UC/CalloutScaleHook.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CalloutScaleHook = void 0;
+const AppObject_1 = require("../../../AppObject");
+const ValueObjects_1 = require("../../../ValueObjects");
+const SceneRootEntity_1 = require("../../SceneRoot/Entities/SceneRootEntity");
+const CalloutEntity_1 = require("../Entities/CalloutEntity");
+class CalloutScaleHook extends AppObject_1.AppObjectUC {
+    constructor(appObject) {
+        var _a, _b;
+        super(appObject, CalloutScaleHook.type);
+        this.onEntityChange = () => {
+            var _a;
+            if (!this.callout || !this.sceneRoot) {
+                this.error("Missing Components");
+                return;
+            }
+            const rootScale = (_a = this.sceneRoot.scale) !== null && _a !== void 0 ? _a : 1;
+            const calloutSize = this.callout.size;
+            if (rootScale === this.lastRootScale &&
+                calloutSize === this.lastCalloutSize) {
+                return;
+            }
+            const scaler = calloutSize / rootScale;
+            const labelScale = new ValueObjects_1.Vector3(scaler, scaler, scaler);
+            this.callout.labelTransform.localScale = labelScale;
+            this.lastCalloutSize = calloutSize;
+            this.lastRootScale = rootScale;
+        };
+        this.dispose = () => {
+            var _a, _b;
+            (_a = this.sceneRoot) === null || _a === void 0 ? void 0 : _a.removeChangeObserver(this.onEntityChange);
+            (_b = this.callout) === null || _b === void 0 ? void 0 : _b.removeChangeObserver(this.onEntityChange);
+            super.dispose();
+        };
+        (_a = this.sceneRoot) === null || _a === void 0 ? void 0 : _a.addChangeObserver(this.onEntityChange);
+        (_b = this.callout) === null || _b === void 0 ? void 0 : _b.addChangeObserver(this.onEntityChange);
+        this.onEntityChange();
+    }
+    get sceneRoot() {
+        return this.getCachedSingleton(SceneRootEntity_1.SceneRootEntity.type);
+    }
+    get callout() {
+        return this.getCachedLocalComponent(CalloutEntity_1.CalloutEntity.type);
+    }
+}
+exports.CalloutScaleHook = CalloutScaleHook;
+CalloutScaleHook.type = "CalloutScaleHook";

package/lib/Components/Callouts/UC/CreateCalloutUC.d.ts

@@ -0,0 +1,11 @@
+import { AppObject, AppObjectRepo, AppObjectUC } from "../../../AppObject";
+import { Vector3 } from "../../../ValueObjects";
+import { CalloutEntity } from "../Entities/CalloutEntity";
+export declare abstract class CreateCalloutUC extends AppObjectUC {
+    static readonly type = "CreateCalloutUC";
+    readonly newLabelBumpAmount = 0.01;
+    abstract fromPick(pickHit: Vector3, pickHitNormal: Vector3, undoRedo?: boolean): CalloutEntity | undefined;
+    static get(appObj: AppObject): CreateCalloutUC | undefined;
+    static getById(id: string, appObjects: AppObjectRepo): CreateCalloutUC | undefined;
+}
+export declare function makeCreateCalloutUC(appObject: AppObject): CreateCalloutUC;

package/lib/Components/Callouts/UC/CreateCalloutUC.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeCreateCalloutUC = exports.CreateCalloutUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const ValueObjects_1 = require("../../../ValueObjects");
+const LabelEntity_1 = require("../../Label/Entities/LabelEntity");
+const CalloutGlobals_1 = require("../Entities/CalloutGlobals");
+const CalloutRepo_1 = require("../Entities/CalloutRepo");
+const CreateCalloutUndoRedo_1 = require("./CreateCalloutUndoRedo");
+class CreateCalloutUC extends AppObject_1.AppObjectUC {
+    constructor() {
+        super(...arguments);
+        this.newLabelBumpAmount = 0.01;
+    }
+    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.CreateCalloutUC = CreateCalloutUC;
+CreateCalloutUC.type = "CreateCalloutUC";
+function makeCreateCalloutUC(appObject) {
+    return new CreateCalloutUCImp(appObject);
+}
+exports.makeCreateCalloutUC = makeCreateCalloutUC;
+class CreateCalloutUCImp extends CreateCalloutUC {
+    get repo() {
+        return this.getCachedLocalComponent(CalloutRepo_1.CalloutRepo.type);
+    }
+    get calloutGlobals() {
+        return this.getCachedSingleton(CalloutGlobals_1.CalloutGlobals.type);
+    }
+    get repoLabel() {
+        return this.getCachedLocalComponent(LabelEntity_1.LabelEntity.type);
+    }
+    fromPick(pickHit, pickHitNormal, undoRedo = true) {
+        if (!this.repo) {
+            throw new Error("No Callout Repo");
+        }
+        const callout = this.repo.makeCallout();
+        callout.rootTransform.worldPosition = pickHit;
+        callout.rootTransform.worldRotation = ValueObjects_1.Quaternion.FromDirectionVector(pickHitNormal);
+        const labelBump = ValueObjects_1.Vector3.NewVectorOfLength(pickHitNormal, this.newLabelBumpAmount);
+        callout.labelTransform.worldPosition = ValueObjects_1.Vector3.Add(labelBump, pickHit);
+        callout.labelTransform.worldRotation = ValueObjects_1.Quaternion.FromYawPitchRoll(ValueObjects_1.Angle.FromDegrees(180), ValueObjects_1.Angle.FromDegrees(0), ValueObjects_1.Angle.FromDegrees(0));
+        if (this.repoLabel) {
+            callout.label.default = this.repoLabel.default;
+        }
+        if (this.calloutGlobals) {
+            callout.size = this.calloutGlobals.lastSize;
+            callout.overlayColor.overlayColor = this.calloutGlobals.lastColor;
+        }
+        if (undoRedo) {
+            new CreateCalloutUndoRedo_1.CreateCalloutUndoRedo(callout.data, this.appObjects);
+        }
+        return callout;
+    }
+    constructor(appObject) {
+        super(appObject, CreateCalloutUC.type);
+    }
+}

package/lib/Components/Callouts/UC/CreateCalloutUndoRedo.d.ts

@@ -0,0 +1,10 @@
+import { AppObjectRepo } from "../../../AppObject";
+import { UndoRedoAction } from "../../UndoRedo/Entities/UndoRedoEntity";
+import { CalloutDTO } from "../Entities/CalloutEntity";
+export declare class CreateCalloutUndoRedo implements UndoRedoAction {
+    private createdCalloutData;
+    private appObjects;
+    redoAction: () => void;
+    undoAction: () => void;
+    constructor(createdCalloutData: CalloutDTO, appObjects: AppObjectRepo);
+}

package/lib/Components/Callouts/UC/CreateCalloutUndoRedo.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateCalloutUndoRedo = void 0;
+const DispatchStateChangeUC_1 = require("../../Dispatcher/UC/DispatchStateChangeUC");
+const UndoRedoEntity_1 = require("../../UndoRedo/Entities/UndoRedoEntity");
+const CalloutRepo_1 = require("../Entities/CalloutRepo");
+class CreateCalloutUndoRedo {
+    constructor(createdCalloutData, appObjects) {
+        this.createdCalloutData = createdCalloutData;
+        this.appObjects = appObjects;
+        this.redoAction = () => {
+            const repo = CalloutRepo_1.CalloutRepo.getById(this.createdCalloutData.parentID, this.appObjects);
+            if (!repo) {
+                return;
+            }
+            const callout = repo.makeCallout(this.createdCalloutData.id);
+            callout.data = this.createdCalloutData;
+            DispatchStateChangeUC_1.dispatchStateChange(this.appObjects);
+        };
+        this.undoAction = () => {
+            const repo = CalloutRepo_1.CalloutRepo.getById(this.createdCalloutData.parentID, this.appObjects);
+            if (!repo) {
+                return;
+            }
+            repo.deleteCallout(this.createdCalloutData.id);
+            DispatchStateChangeUC_1.dispatchStateChange(this.appObjects);
+        };
+        const undoRedo = UndoRedoEntity_1.UndoRedoEntity.get(this.appObjects);
+        if (!undoRedo) {
+            this.appObjects.submitError("CreateCalloutAction", "Unable to find UndoRedoEntity");
+            return;
+        }
+        undoRedo.submitAction(this);
+    }
+}
+exports.CreateCalloutUndoRedo = CreateCalloutUndoRedo;

package/lib/Components/Callouts/UC/DeleteAllCalloutsUC.d.ts

@@ -0,0 +1,8 @@
+import { AppObject, AppObjectRepo, AppObjectUC } from "../../../AppObject";
+export declare abstract class DeleteAllCalloutsUC extends AppObjectUC {
+    static readonly type = "DeleteAllCalloutsUC";
+    abstract deleteAllCallouts(): void;
+    static get: (appObjects: AppObjectRepo) => DeleteAllCalloutsUC | undefined;
+    static addIfMissing(appObj: AppObject): DeleteAllCalloutsUC;
+}
+export declare function makeDeleteAllCalloutsUC(appObject: AppObject): DeleteAllCalloutsUC;

package/lib/Components/Callouts/UC/DeleteAllCalloutsUC.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeDeleteAllCalloutsUC = exports.DeleteAllCalloutsUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const DispatchStateChangeUC_1 = require("../../Dispatcher/UC/DispatchStateChangeUC");
+const CalloutRepo_1 = require("../Entities/CalloutRepo");
+const DeleteAllCalloutsUndoRedo_1 = require("./DeleteAllCalloutsUndoRedo");
+class DeleteAllCalloutsUC extends AppObject_1.AppObjectUC {
+    static addIfMissing(appObj) {
+        const existing = appObj.getComponent(this.type);
+        if (existing)
+            return existing;
+        else {
+            return makeDeleteAllCalloutsUC(appObj);
+        }
+    }
+}
+exports.DeleteAllCalloutsUC = DeleteAllCalloutsUC;
+DeleteAllCalloutsUC.type = "DeleteAllCalloutsUC";
+DeleteAllCalloutsUC.get = (appObjects) => AppObject_1.getSingletonComponent(DeleteAllCalloutsUC.type, appObjects);
+function makeDeleteAllCalloutsUC(appObject) {
+    return new DeleteAllCalloutsUCImp(appObject);
+}
+exports.makeDeleteAllCalloutsUC = makeDeleteAllCalloutsUC;
+class DeleteAllCalloutsUCImp extends DeleteAllCalloutsUC {
+    deleteAllCallouts() {
+        const deletedCallouts = [];
+        const calloutRepos = this.appObjects.getAllComponents(CalloutRepo_1.CalloutRepo.type);
+        calloutRepos.forEach((repo) => {
+            const callouts = repo.getAll();
+            callouts.forEach((callout) => {
+                deletedCallouts.push(callout.data);
+                repo.removeForAppObject(callout.appObject.id);
+                callout.appObject.dispose();
+            });
+        });
+        DispatchStateChangeUC_1.dispatchStateChange(this.appObjects);
+        new DeleteAllCalloutsUndoRedo_1.DeleteAllCalloutsUndoRedo(deletedCallouts, this.appObjects);
+    }
+    constructor(appObject) {
+        super(appObject, DeleteAllCalloutsUC.type);
+    }
+}

package/lib/Components/Callouts/UC/DeleteAllCalloutsUndoRedo.d.ts

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

package/lib/Components/Callouts/UC/DeleteAllCalloutsUndoRedo.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeleteAllCalloutsUndoRedo = void 0;
+const DispatchStateChangeUC_1 = require("../../Dispatcher/UC/DispatchStateChangeUC");
+const UndoRedoEntity_1 = require("../../UndoRedo/Entities/UndoRedoEntity");
+const CalloutRepo_1 = require("../Entities/CalloutRepo");
+class DeleteAllCalloutsUndoRedo {
+    constructor(deletedCallouts, appObjects) {
+        this.deletedCallouts = deletedCallouts;
+        this.appObjects = appObjects;
+        this.undoAction = () => {
+            this.deletedCallouts.forEach((deletedCallout) => {
+                const repo = CalloutRepo_1.CalloutRepo.getById(deletedCallout.parentID, this.appObjects);
+                if (!repo) {
+                    return;
+                }
+                const callout = repo.makeCallout(deletedCallout.id);
+                callout.data = deletedCallout;
+            });
+            DispatchStateChangeUC_1.dispatchStateChange(this.appObjects);
+        };
+        this.redoAction = () => {
+            this.deletedCallouts.forEach((deletedCallout) => {
+                const repo = CalloutRepo_1.CalloutRepo.getById(deletedCallout.parentID, this.appObjects);
+                if (!repo) {
+                    return;
+                }
+                repo.deleteCallout(deletedCallout.id);
+            });
+            DispatchStateChangeUC_1.dispatchStateChange(this.appObjects);
+        };
+        const undoRedo = UndoRedoEntity_1.UndoRedoEntity.get(this.appObjects);
+        if (!undoRedo) {
+            appObjects.submitWarning("DeleteAllCalloutsUndoRedo", "Unable to find UndoRedoEntity");
+            return;
+        }
+        undoRedo.submitAction(this);
+    }
+}
+exports.DeleteAllCalloutsUndoRedo = DeleteAllCalloutsUndoRedo;

package/lib/Components/Callouts/UC/DeleteCallout.d.ts

@@ -0,0 +1,8 @@
+import { AppObject, AppObjectRepo, AppObjectUC } from "../../../AppObject";
+export declare abstract class DeleteCalloutUC extends AppObjectUC {
+    static readonly type = "DeleteCalloutUC";
+    abstract delete(): void;
+    static get(appObj: AppObject): DeleteCalloutUC | undefined;
+    static getById(id: string, appObjects: AppObjectRepo): DeleteCalloutUC | undefined;
+}
+export declare function makeDeleteCalloutUC(appObject: AppObject): DeleteCalloutUC;

package/lib/Components/Callouts/UC/DeleteCallout.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeDeleteCalloutUC = exports.DeleteCalloutUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const DispatchStateChangeUC_1 = require("../../Dispatcher/UC/DispatchStateChangeUC");
+const CalloutEntity_1 = require("../Entities/CalloutEntity");
+const DeleteCalloutUndoRedo_1 = require("./DeleteCalloutUndoRedo");
+class DeleteCalloutUC 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.DeleteCalloutUC = DeleteCalloutUC;
+DeleteCalloutUC.type = "DeleteCalloutUC";
+function makeDeleteCalloutUC(appObject) {
+    return new DeleteCalloutUCImp(appObject);
+}
+exports.makeDeleteCalloutUC = makeDeleteCalloutUC;
+class DeleteCalloutUCImp extends DeleteCalloutUC {
+    constructor(appObject) {
+        super(appObject, DeleteCalloutUC.type);
+        this.delete = () => {
+            var _a;
+            if (!this.callout)
+                return;
+            new DeleteCalloutUndoRedo_1.DeleteCalloutUndoRedo(this.callout.data, this.appObjects);
+            (_a = this.callout.inRepo) === null || _a === void 0 ? void 0 : _a.deleteCallout(this.callout.id);
+            DispatchStateChangeUC_1.dispatchStateChange(this.appObjects);
+        };
+    }
+    get callout() {
+        return this.getCachedLocalComponent(CalloutEntity_1.CalloutEntity.type);
+    }
+}

package/lib/Components/Callouts/UC/DeleteCalloutUndoRedo.d.ts

@@ -0,0 +1,10 @@
+import { AppObjectRepo } from "../../../AppObject";
+import { UndoRedoAction } from "../../UndoRedo/Entities/UndoRedoEntity";
+import { CalloutDTO } from "../Entities/CalloutEntity";
+export declare class DeleteCalloutUndoRedo implements UndoRedoAction {
+    private deletedCallout;
+    private appObjects;
+    undoAction: () => void;
+    redoAction: () => void;
+    constructor(deletedCallout: CalloutDTO, appObjects: AppObjectRepo);
+}

package/lib/Components/Callouts/UC/DeleteCalloutUndoRedo.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeleteCalloutUndoRedo = void 0;
+const DispatchStateChangeUC_1 = require("../../Dispatcher/UC/DispatchStateChangeUC");
+const UndoRedoEntity_1 = require("../../UndoRedo/Entities/UndoRedoEntity");
+const CalloutRepo_1 = require("../Entities/CalloutRepo");
+class DeleteCalloutUndoRedo {
+    constructor(deletedCallout, appObjects) {
+        this.deletedCallout = deletedCallout;
+        this.appObjects = appObjects;
+        this.undoAction = () => {
+            const repo = CalloutRepo_1.CalloutRepo.getById(this.deletedCallout.parentID, this.appObjects);
+            if (!repo) {
+                return;
+            }
+            const callout = repo.makeCallout(this.deletedCallout.id);
+            callout.data = this.deletedCallout;
+            DispatchStateChangeUC_1.dispatchStateChange(this.appObjects);
+        };
+        this.redoAction = () => {
+            const repo = CalloutRepo_1.CalloutRepo.getById(this.deletedCallout.parentID, this.appObjects);
+            if (!repo) {
+                return;
+            }
+            repo.deleteCallout(this.deletedCallout.id);
+            DispatchStateChangeUC_1.dispatchStateChange(this.appObjects);
+        };
+        const undoRedo = UndoRedoEntity_1.UndoRedoEntity.get(this.appObjects);
+        if (!undoRedo) {
+            this.appObjects.submitWarning("DeleteCalloutUndoRedo", "Unable to find UndoRedoEntity");
+            return;
+        }
+        undoRedo.submitAction(this);
+    }
+}
+exports.DeleteCalloutUndoRedo = DeleteCalloutUndoRedo;

package/lib/Components/Callouts/UC/LookAtCameraUC.d.ts

@@ -0,0 +1,7 @@
+import { AppObject, AppObjectUC } from "../../../AppObject";
+export declare abstract class LookAtCameraUC extends AppObjectUC {
+    static readonly type = "LookAtCameraUC";
+    static get(appObj: AppObject): LookAtCameraUC | undefined;
+    abstract onChange(): void;
+}
+export declare function makeLookAtCameraUC(appObject: AppObject): LookAtCameraUC;