@vived/app 4.6.1 → 4.7.0

package/lib/Components/HoverLabel/PM/HoverLabelPM.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultHoverLabelVM = exports.HoverLabelPM = void 0;
+const AppObject_1 = require("../../../AppObject");
+const HoverLabel_1 = require("../Entities/HoverLabel");
+class HoverLabelPM extends AppObject_1.AppObjectPM {
+    constructor(appObject) {
+        super(appObject, HoverLabelPM.type);
+        this.onEnityChange = () => {
+            if (!this.hoverLabel)
+                return;
+            const vm = {
+                show: false,
+                text: "",
+                position: { x: 0, y: 0 },
+            };
+            if (this.hoverLabel.show) {
+                vm.show = true;
+                vm.text = this.hoverLabel.label;
+                vm.position.x = this.hoverLabel.position.x;
+                vm.position.y = this.hoverLabel.position.y;
+            }
+            this.doUpdateView(vm);
+        };
+        this.dispose = () => {
+            var _a, _b;
+            super.dispose();
+            (_a = this.hoverLabel) === null || _a === void 0 ? void 0 : _a.removeChangeObserver(this.onEnityChange);
+            (_b = this.hoverLabel) === null || _b === void 0 ? void 0 : _b.removeOnDisposeObserver(this.dispose);
+        };
+        this.hoverLabel = HoverLabel_1.HoverLabel.get(appObject);
+        if (this.hoverLabel) {
+            this.hoverLabel.addChangeObserver(this.onEnityChange);
+            this.hoverLabel.addOnDisposeObserver(() => this.dispose());
+            this.onEnityChange();
+        }
+        else {
+            this.warn("App Object does not have a HoverLabel Entity");
+        }
+    }
+    static addIfMissing(appObj) {
+        const existing = appObj.getComponent(HoverLabelPM.type);
+        if (existing) {
+            return existing;
+        }
+        else {
+            return new HoverLabelPM(appObj);
+        }
+    }
+    vmsAreEqual(a, b) {
+        if (a.show !== b.show)
+            return false;
+        if (a.text !== b.text)
+            return false;
+        if (a.position.x !== b.position.x || a.position.y !== b.position.y)
+            return false;
+        return true;
+    }
+}
+exports.HoverLabelPM = HoverLabelPM;
+HoverLabelPM.type = "HoverLabelPM";
+exports.defaultHoverLabelVM = {
+    show: false,
+    text: "",
+    position: { x: 0, y: 0 },
+};

package/lib/{PresentationManagers/HoverLabels → Components/HoverLabel/PM}/index.d.ts

@@ -1,2 +1,2 @@
-export * from "./HoverLabelPM";
 export * from "./AllowHoverLabelPM";
+export * from "./HoverLabelPM";

package/lib/{PresentationManagers/HoverLabels → Components/HoverLabel/PM}/index.js

@@ -10,5 +10,5 @@ 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("./HoverLabelPM"), exports);
 __exportStar(require("./AllowHoverLabelPM"), exports);
+__exportStar(require("./HoverLabelPM"), exports);

package/lib/Components/HoverLabel/UseCases/SerializeAllowHoverLabel.d.ts

@@ -0,0 +1,15 @@
+import { AppObject, AppObjectUC } from "../../../AppObject";
+import { SerializedSystem } from "../../StateMachine";
+export declare class SerializeAllowHoverLabel extends AppObjectUC implements SerializedSystem {
+    static readonly type = "SerializeAllowHoverLabel";
+    name: string;
+    seriliziationVersion: number;
+    getSystemState(): object;
+    applySystemState(state: object, version: number): void;
+    applyDefaultState(): void;
+    private handleStateVersion1;
+    constructor(appObj: AppObject);
+}
+export interface AllowHoverLabelV1 {
+    allow: boolean;
+}

package/lib/Components/HoverLabel/UseCases/SerializeAllowHoverLabel.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SerializeAllowHoverLabel = void 0;
+const AppObject_1 = require("../../../AppObject");
+const StateMachine_1 = require("../../StateMachine");
+const HoverLabel_1 = require("../Entities/HoverLabel");
+class SerializeAllowHoverLabel extends AppObject_1.AppObjectUC {
+    constructor(appObj) {
+        super(appObj, SerializeAllowHoverLabel.type);
+        this.name = "allowHoverLabel";
+        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 hoverLabel = HoverLabel_1.HoverLabel.get(this.appObject);
+        if (!hoverLabel) {
+            return {
+                allow: false,
+            };
+        }
+        const state = {
+            allow: hoverLabel.allowHoverLabel,
+        };
+        return state;
+    }
+    applySystemState(state, version) {
+        if (state && version === 1) {
+            const castState = state;
+            this.handleStateVersion1(castState);
+        }
+        else {
+            // Unsupported version
+            console.warn(`Unsupported data version ${version} for serialized system ${this.name}. Reverting to default state`);
+            this.applyDefaultState();
+        }
+    }
+    applyDefaultState() {
+        const hoverLabel = HoverLabel_1.HoverLabel.get(this.appObject);
+        if (!hoverLabel)
+            return;
+        hoverLabel.allowHoverLabel = true;
+    }
+    handleStateVersion1(data) {
+        const hoverLabel = HoverLabel_1.HoverLabel.get(this.appObject);
+        if (!hoverLabel)
+            return;
+        hoverLabel.allowHoverLabel = data.allow;
+    }
+}
+exports.SerializeAllowHoverLabel = SerializeAllowHoverLabel;
+SerializeAllowHoverLabel.type = "SerializeAllowHoverLabel";

package/lib/Components/HoverLabel/UseCases/ToggleAllowHoverLabel.d.ts

@@ -0,0 +1,13 @@
+import { AppObject, AppObjectRepo, AppObjectUC } from "../../../AppObject";
+export declare abstract class ToggleAllowHoverLabelUC extends AppObjectUC {
+    static readonly type = "ToggleAllowHoverLabelUC";
+    abstract toggleAllowHoverLabel(): void;
+    static get(appObjects: AppObjectRepo): ToggleAllowHoverLabelUC | undefined;
+}
+export declare function makeToggleAllowHoverLabel(appObject: AppObject): ToggleAllowHoverLabelIMP;
+declare class ToggleAllowHoverLabelIMP extends ToggleAllowHoverLabelUC {
+    private hoverLabel?;
+    toggleAllowHoverLabel: () => void;
+    constructor(appObject: AppObject);
+}
+export {};

package/lib/Components/HoverLabel/UseCases/ToggleAllowHoverLabel.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeToggleAllowHoverLabel = exports.ToggleAllowHoverLabelUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const Dispatcher_1 = require("../../Dispatcher");
+const HoverLabel_1 = require("../Entities/HoverLabel");
+class ToggleAllowHoverLabelUC extends AppObject_1.AppObjectUC {
+    static get(appObjects) {
+        const ucs = appObjects.getAllComponents(ToggleAllowHoverLabelUC.type);
+        if (ucs.length === 0) {
+            console.warn("Unable to find a ToggleAllowHoverLabelUC. Add one on Mount");
+            return undefined;
+        }
+        else if (ucs.length > 1) {
+            console.warn("Multiple ToggleAllowHoverLabelUC have been found. There should only be one. Using the first one");
+        }
+        return ucs[0];
+    }
+}
+exports.ToggleAllowHoverLabelUC = ToggleAllowHoverLabelUC;
+ToggleAllowHoverLabelUC.type = "ToggleAllowHoverLabelUC";
+function makeToggleAllowHoverLabel(appObject) {
+    return new ToggleAllowHoverLabelIMP(appObject);
+}
+exports.makeToggleAllowHoverLabel = makeToggleAllowHoverLabel;
+class ToggleAllowHoverLabelIMP extends ToggleAllowHoverLabelUC {
+    constructor(appObject) {
+        super(appObject, ToggleAllowHoverLabelUC.type);
+        this.toggleAllowHoverLabel = () => {
+            if (!this.hoverLabel)
+                return;
+            this.hoverLabel.allowHoverLabel = !this.hoverLabel.allowHoverLabel;
+            Dispatcher_1.dispatchStateChange(this.appObjects);
+        };
+        this.hoverLabel = HoverLabel_1.HoverLabel.get(this.appObject);
+        if (!this.hoverLabel) {
+            this.warn("Hover Label App Object was not found.");
+        }
+    }
+}

package/lib/Components/HoverLabel/UseCases/TryShowHoverLabel.d.ts

@@ -0,0 +1,14 @@
+import { AppObject, AppObjectRepo, AppObjectUC } from "../../../AppObject";
+import { Vector2 } from "../../../ValueObjects";
+export declare abstract class TryShowHoverLabel extends AppObjectUC {
+    static readonly type = "TryShowHoverLabel";
+    abstract tryShowHoverLabel(position: Vector2): void;
+    static get(appObjects: AppObjectRepo): TryShowHoverLabel | undefined;
+}
+export declare function makeTryShowHoverLabel(appObject: AppObject): TryShowHoverLabelIMP;
+declare class TryShowHoverLabelIMP extends TryShowHoverLabel {
+    private hoverLabel?;
+    constructor(appObject: AppObject);
+    tryShowHoverLabel: (position: Vector2) => void;
+}
+export {};

package/lib/Components/HoverLabel/UseCases/TryShowHoverLabel.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeTryShowHoverLabel = exports.TryShowHoverLabel = void 0;
+const AppObject_1 = require("../../../AppObject");
+const Babylon_1 = require("../../Babylon");
+const Label_1 = require("../../Label");
+const HoverLabel_1 = require("../Entities/HoverLabel");
+class TryShowHoverLabel extends AppObject_1.AppObjectUC {
+    static get(appObjects) {
+        const ucs = appObjects.getAllComponents(TryShowHoverLabel.type);
+        if (ucs.length === 0) {
+            console.warn("Unable to find a TryShowHoverLabel. Add one on Mount");
+            return undefined;
+        }
+        else if (ucs.length > 1) {
+            console.warn("Multiple TryShowHoverLabel have been found. There should only be one. Using the first one");
+        }
+        return ucs[0];
+    }
+}
+exports.TryShowHoverLabel = TryShowHoverLabel;
+TryShowHoverLabel.type = "TryShowHoverLabel";
+function makeTryShowHoverLabel(appObject) {
+    return new TryShowHoverLabelIMP(appObject);
+}
+exports.makeTryShowHoverLabel = makeTryShowHoverLabel;
+class TryShowHoverLabelIMP extends TryShowHoverLabel {
+    constructor(appObject) {
+        super(appObject, TryShowHoverLabel.type);
+        this.tryShowHoverLabel = (position) => {
+            if (!this.hoverLabel)
+                return;
+            if (!this.hoverLabel.allowHoverLabel) {
+                this.hoverLabel.hideHoverLabel();
+                return;
+            }
+            const scenePick = Babylon_1.scenePixelPick(position, this.appObjects);
+            if (!scenePick || !scenePick.appObjectID) {
+                return;
+            }
+            const appObj = this.appObjects.get(scenePick.appObjectID);
+            if (!appObj) {
+                return;
+            }
+            const label = Label_1.Label.get(appObj);
+            if (!label) {
+                return;
+            }
+            if (label.display) {
+                this.hoverLabel.showHoverLabel(label.display, position);
+            }
+            else {
+                this.hoverLabel.hideHoverLabel();
+            }
+        };
+        this.hoverLabel = HoverLabel_1.HoverLabel.get(this.appObject);
+        if (!this.hoverLabel) {
+            this.warn("Hover Label App Object was not found.");
+        }
+    }
+}

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

@@ -0,0 +1,3 @@
+export * from "./SerializeAllowHoverLabel";
+export * from "./ToggleAllowHoverLabel";
+export * from "./TryShowHoverLabel";

package/lib/{AppObjectComponents/ChannelModel → Components/HoverLabel/UseCases}/index.js

@@ -10,5 +10,6 @@ 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("./Entities/ChannelModel"), exports);
-__exportStar(require("./Entities/ChannelModelRepo"), exports);
+__exportStar(require("./SerializeAllowHoverLabel"), exports);
+__exportStar(require("./ToggleAllowHoverLabel"), exports);
+__exportStar(require("./TryShowHoverLabel"), exports);

package/lib/Components/HoverLabel/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./Entities";
+export * from "./UseCases";
+export * from "./PM";
+export * from "./Controllers";

package/lib/{AppObjectComponents/Hideable → Components/HoverLabel}/index.js

@@ -10,5 +10,7 @@ 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("./Entities/Hideable"), exports);
-__exportStar(require("./PresentationManagers/IsHiddenPM"), exports);
+__exportStar(require("./Entities"), exports);
+__exportStar(require("./UseCases"), exports);
+__exportStar(require("./PM"), exports);
+__exportStar(require("./Controllers"), exports);

package/lib/Components/Landmarks/Controller/Mouse/MouseLandmark.d.ts

@@ -0,0 +1,22 @@
+import { AppObject, AppObjectController } from "../../../../AppObject";
+import { MouseController, MouseInputEvent } from "../../../MouseInput";
+export declare abstract class MouseLandmark extends AppObjectController implements MouseController {
+    static type: string;
+    addingLandmark: boolean;
+    pressed: boolean;
+    abstract onMove: (e: MouseInputEvent) => void;
+    abstract onDown: (e: MouseInputEvent) => void;
+}
+export declare function makeMouseLandmark(appObject: AppObject): MouseLandmarkImp;
+declare class MouseLandmarkImp extends MouseLandmark {
+    addingLandmark: boolean;
+    pressed: boolean;
+    private tryPreviewLandmarkUc?;
+    private tryAddLandmarkUc?;
+    allow: (e: MouseInputEvent) => boolean;
+    onMove: (e: MouseInputEvent) => void;
+    onDown: (e: MouseInputEvent) => void;
+    onUp: (e: MouseInputEvent) => void;
+    constructor(appObject: AppObject);
+}
+export {};

package/lib/Components/Landmarks/Controller/Mouse/MouseLandmark.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMouseLandmark = exports.MouseLandmark = void 0;
+const AppObject_1 = require("../../../../AppObject");
+const Babylon_1 = require("../../../Babylon");
+const MouseInput_1 = require("../../../MouseInput");
+const LandmarkGlobals_1 = require("../../Entities/LandmarkGlobals");
+const TryAddNewLandmarkUC_1 = require("../../UseCases/TryAddNewLandmarkUC");
+const TryPreviewLandmarkUC_1 = require("../../UseCases/TryPreviewLandmarkUC");
+class MouseLandmark extends AppObject_1.AppObjectController {
+    constructor() {
+        super(...arguments);
+        this.addingLandmark = false;
+        this.pressed = false;
+    }
+}
+exports.MouseLandmark = MouseLandmark;
+MouseLandmark.type = "Mouse_Landmark_Controller";
+function makeMouseLandmark(appObject) {
+    return new MouseLandmarkImp(appObject);
+}
+exports.makeMouseLandmark = makeMouseLandmark;
+class MouseLandmarkImp extends MouseLandmark {
+    constructor(appObject) {
+        super(appObject, MouseLandmark.type);
+        this.addingLandmark = false;
+        this.pressed = false;
+        this.allow = (e) => {
+            return true;
+        };
+        this.onMove = (e) => {
+            if (!this.allow(e))
+                return;
+            if (!this.tryPreviewLandmarkUc) {
+                return;
+            }
+            const ray = Babylon_1.pixelToSceneRay(e.position, this.appObjects);
+            this.tryPreviewLandmarkUc.tryPreviewLandmark(ray, this.pressed);
+        };
+        this.onDown = (e) => {
+            this.addingLandmark = false;
+            if (e.button !== 0)
+                return;
+            if (!this.allow(e))
+                return;
+            if (!this.tryPreviewLandmarkUc) {
+                return;
+            }
+            const ray = Babylon_1.pixelToSceneRay(e.position, this.appObjects);
+            const pressed = true;
+            this.tryPreviewLandmarkUc.tryPreviewLandmark(ray, pressed);
+            this.addingLandmark = true;
+            this.pressed = true;
+        };
+        this.onUp = (e) => {
+            var _a;
+            if (!this.allow(e))
+                return;
+            if (!this.addingLandmark)
+                return;
+            if (!this.tryAddLandmarkUc)
+                return;
+            const landmarkPreview = (_a = this.appObject.getComponent(LandmarkGlobals_1.LandmarkGlobals.type)) === null || _a === void 0 ? void 0 : _a.previewLandmark;
+            if (!landmarkPreview) {
+                return;
+            }
+            const ray = Babylon_1.pixelToSceneRay(e.position, this.appObjects);
+            this.tryAddLandmarkUc.addFromRay(ray);
+            landmarkPreview.hideable.isHidden = true;
+            this.addingLandmark = false;
+            this.pressed = false;
+        };
+        this.tryPreviewLandmarkUc = TryPreviewLandmarkUC_1.TryPreviewLandmarkUC.get(appObject);
+        if (!this.tryPreviewLandmarkUc) {
+            this.warn("Unable to find TryPreviewLandmarkUC");
+            return;
+        }
+        this.tryAddLandmarkUc = TryAddNewLandmarkUC_1.TryAddNewLandmarkUC.get(appObject);
+        if (!this.tryAddLandmarkUc) {
+            this.warn("Unable to find TryAddNewLandmarkUC");
+            return;
+        }
+        const mouseInput = MouseInput_1.MouseInputEntity.get(this.appObjects);
+        if (mouseInput) {
+            mouseInput.registerController(this);
+        }
+        else {
+            this.warn("Unable to find MouseInputEntity");
+        }
+    }
+}

package/lib/Components/Landmarks/Controller/Touch/TouchLandmark.d.ts

@@ -0,0 +1,20 @@
+import { AppObject, AppObjectController } from "../../../../AppObject";
+import { TouchController, TouchInputEvent } from "../../../TouchController";
+export declare abstract class TouchLandmark extends AppObjectController implements TouchController {
+    static type: string;
+    abstract onTouchStart(e: TouchInputEvent): void;
+    abstract onTouchMove(e: TouchInputEvent): void;
+    abstract onTouchEnd(e: TouchInputEvent): void;
+}
+export declare function makeTouchLandmark(appObject: AppObject): TouchLandmarkImp;
+declare class TouchLandmarkImp extends TouchLandmark {
+    private lastTouch;
+    private tryPreviewLandmarkUc?;
+    private tryAddLandmarkUc?;
+    allow: (e: TouchInputEvent) => boolean;
+    onTouchStart: (e: TouchInputEvent) => void;
+    onTouchMove: (e: TouchInputEvent) => void;
+    onTouchEnd: (e: TouchInputEvent) => void;
+    constructor(appObject: AppObject);
+}
+export {};

package/lib/Components/Landmarks/Controller/Touch/TouchLandmark.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeTouchLandmark = exports.TouchLandmark = void 0;
+const AppObject_1 = require("../../../../AppObject");
+const ValueObjects_1 = require("../../../../ValueObjects");
+const Babylon_1 = require("../../../Babylon");
+const TouchController_1 = require("../../../TouchController");
+const LandmarkGlobals_1 = require("../../Entities/LandmarkGlobals");
+const TryAddNewLandmarkUC_1 = require("../../UseCases/TryAddNewLandmarkUC");
+const TryPreviewLandmarkUC_1 = require("../../UseCases/TryPreviewLandmarkUC");
+class TouchLandmark extends AppObject_1.AppObjectController {
+}
+exports.TouchLandmark = TouchLandmark;
+TouchLandmark.type = "TOUCH_LANDMARK_CONTROLLER";
+function makeTouchLandmark(appObject) {
+    return new TouchLandmarkImp(appObject);
+}
+exports.makeTouchLandmark = makeTouchLandmark;
+class TouchLandmarkImp extends TouchLandmark {
+    constructor(appObject) {
+        super(appObject, TouchLandmark.type);
+        this.lastTouch = ValueObjects_1.Vector2.Zero();
+        this.allow = (e) => {
+            return true;
+        };
+        this.onTouchStart = (e) => {
+            if (!this.allow(e))
+                return;
+            if (e.touchCount > 1)
+                return;
+            if (!this.tryPreviewLandmarkUc)
+                return;
+            const position = e.touches[0].position;
+            this.lastTouch = position;
+            const ray = Babylon_1.pixelToSceneRay(position, this.appObjects);
+            this.tryPreviewLandmarkUc.tryPreviewLandmark(ray, true);
+        };
+        this.onTouchMove = (e) => {
+            if (!this.allow(e))
+                return;
+            if (e.touchCount > 1)
+                return;
+            if (!this.tryPreviewLandmarkUc)
+                return;
+            const position = e.touches[0].position;
+            this.lastTouch = position;
+            const ray = Babylon_1.pixelToSceneRay(position, this.appObjects);
+            this.tryPreviewLandmarkUc.tryPreviewLandmark(ray, true);
+        };
+        this.onTouchEnd = (e) => {
+            var _a;
+            if (!this.allow(e))
+                return;
+            if (e.touchCount > 1)
+                return;
+            if (!this.tryAddLandmarkUc)
+                return;
+            const landmarkPreview = (_a = this.appObject.getComponent(LandmarkGlobals_1.LandmarkGlobals.type)) === null || _a === void 0 ? void 0 : _a.previewLandmark;
+            if (!landmarkPreview) {
+                return;
+            }
+            const ray = Babylon_1.pixelToSceneRay(this.lastTouch, this.appObjects);
+            this.tryAddLandmarkUc.addFromRay(ray);
+            landmarkPreview.hideable.isHidden = true;
+        };
+        this.tryPreviewLandmarkUc = TryPreviewLandmarkUC_1.TryPreviewLandmarkUC.get(appObject);
+        if (!this.tryPreviewLandmarkUc) {
+            this.warn("Unable to find TryPreviewLandmarkUC");
+            return;
+        }
+        this.tryAddLandmarkUc = TryAddNewLandmarkUC_1.TryAddNewLandmarkUC.get(appObject);
+        if (!this.tryAddLandmarkUc) {
+            this.warn("Unable to find TryAddNewLandmarkUC");
+            return;
+        }
+        const touchInput = TouchController_1.TouchInputEntity.get(this.appObjects);
+        if (touchInput) {
+            touchInput.registerController(this);
+        }
+        else {
+            this.warn("Unable to find TouchInputEntity");
+        }
+    }
+}

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/Tools/Factory/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./setupTool";
+export * from "./setupToolRepo";

package/lib/{UseCases/SceneObjects → Components/Tools/Factory}/index.js

@@ -10,4 +10,5 @@ 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("./PeelSceneObject"), exports);
+__exportStar(require("./setupTool"), exports);
+__exportStar(require("./setupToolRepo"), exports);