@vived/app 4.6.1 → 4.7.0

package/lib/AppObject/AppObjectPM.js

@@ -13,7 +13,7 @@ class AppObjectPM extends AppObjectComponent_1.AppObjectComponent {
     }
     addView(updateView) {
         this.observerList.add(updateView);
-        if (this._lastVM) {
+        if (this._lastVM !== undefined) {
             updateView(this._lastVM);
         }
     }

package/lib/Components/App/UC/submitError.d.ts

@@ -0,0 +1,2 @@
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+export declare function submitError(sender: string, message: string, appObjects: AppObjectRepo, showAlert?: boolean): void;

package/lib/Components/App/UC/submitError.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.submitError = void 0;
+const Dispatcher_1 = require("../../Dispatcher");
+const LogUC_1 = require("../../Dispatcher/UC/LogUC");
+function submitError(sender, message, appObjects, showAlert = true) {
+    const logUC = LogUC_1.LogUC.get(appObjects);
+    if (logUC) {
+        logUC.error(sender, message);
+    }
+    else {
+        console.error(`[${sender}]: ${message}`);
+    }
+    if (!showAlert)
+        return;
+    const alert = Dispatcher_1.ShowAlertUC.get(appObjects);
+    if (!alert)
+        return;
+    alert.showAlert({
+        title: "Error",
+        closeButtonLabel: "Close",
+        closeCallback: () => {
+            // done
+        },
+        message: `[${sender}]: ${message}`
+    });
+}
+exports.submitError = submitError;

package/lib/Components/App/UC/submitFatal.d.ts

@@ -0,0 +1,2 @@
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+export declare function submitFatal(sender: string, message: string, appObjects: AppObjectRepo, showAlert?: boolean): void;

package/lib/Components/App/UC/submitFatal.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.submitFatal = void 0;
+const Dispatcher_1 = require("../../Dispatcher");
+const LogUC_1 = require("../../Dispatcher/UC/LogUC");
+function submitFatal(sender, message, appObjects, showAlert = true) {
+    const logUC = LogUC_1.LogUC.get(appObjects);
+    if (logUC) {
+        logUC.fatal(sender, message);
+    }
+    else {
+        console.error(`[${sender}]: ${message}`);
+    }
+    if (!showAlert)
+        return;
+    const alert = Dispatcher_1.ShowAlertUC.get(appObjects);
+    if (!alert)
+        return;
+    alert.showAlert({
+        title: "Fatal Error",
+        closeButtonLabel: "Close",
+        closeCallback: () => {
+            // done
+        },
+        message: `[${sender}]: ${message}`
+    });
+}
+exports.submitFatal = submitFatal;

package/lib/Components/App/UC/submitLog.d.ts

@@ -0,0 +1,2 @@
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+export declare function submitLog(sender: string, message: string, appObjects: AppObjectRepo, showAlert?: boolean): void;

package/lib/Components/App/UC/submitLog.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.submitLog = void 0;
+const Dispatcher_1 = require("../../Dispatcher");
+const LogUC_1 = require("../../Dispatcher/UC/LogUC");
+function submitLog(sender, message, appObjects, showAlert = false) {
+    const logUC = LogUC_1.LogUC.get(appObjects);
+    if (logUC) {
+        logUC.log(sender, message);
+    }
+    else {
+        console.log(`[${sender}]: ${message}`);
+    }
+    if (!showAlert)
+        return;
+    const alert = Dispatcher_1.ShowAlertUC.get(appObjects);
+    if (!alert)
+        return;
+    alert.showAlert({
+        title: "Log",
+        closeButtonLabel: "Close",
+        closeCallback: () => {
+            // done
+        },
+        message: `[${sender}]: ${message}`
+    });
+}
+exports.submitLog = submitLog;

package/lib/Components/App/UC/submitWarning.d.ts

@@ -0,0 +1,2 @@
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+export declare function submitWarning(sender: string, message: string, appObjects: AppObjectRepo, showAlert?: boolean): void;

package/lib/Components/App/UC/submitWarning.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.submitWarning = void 0;
+const Dispatcher_1 = require("../../Dispatcher");
+const LogUC_1 = require("../../Dispatcher/UC/LogUC");
+function submitWarning(sender, message, appObjects, showAlert = false) {
+    const logUC = LogUC_1.LogUC.get(appObjects);
+    if (logUC) {
+        logUC.warn(sender, message);
+    }
+    else {
+        console.warn(`[${sender}]: ${message}`);
+    }
+    if (!showAlert)
+        return;
+    const alert = Dispatcher_1.ShowAlertUC.get(appObjects);
+    if (!alert)
+        return;
+    alert.showAlert({
+        title: "Warning",
+        closeButtonLabel: "Close",
+        closeCallback: () => {
+            // done
+        },
+        message: `[${sender}]: ${message}`
+    });
+}
+exports.submitWarning = submitWarning;

package/lib/Components/Babylon/Mocks/MockScenePixelPickUC.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="jest" />
+import { AppObject } from "../../../AppObject";
+import { ScenePixelPickUC } from "../UC";
+export declare class MockScenePixelPickUC extends ScenePixelPickUC {
+    scenePixelPick: jest.Mock<any, any>;
+    constructor(appObject: AppObject);
+}

package/lib/Components/Babylon/Mocks/MockScenePixelPickUC.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockScenePixelPickUC = void 0;
+const UC_1 = require("../UC");
+class MockScenePixelPickUC extends UC_1.ScenePixelPickUC {
+    constructor(appObject) {
+        super(appObject, UC_1.ScenePixelPickUC.type);
+        this.scenePixelPick = jest.fn();
+    }
+}
+exports.MockScenePixelPickUC = MockScenePixelPickUC;

package/lib/Components/Camera/Factory/CameraFactoryImp.d.ts

@@ -0,0 +1,4 @@
+import { AppObject } from "@vived/app";
+import { EntityContext } from "Entities/EntityContext";
+import { CameraFactory } from "../Entities/CameraFactory";
+export declare function makeCameraFactory(appObject: AppObject, entities: EntityContext): CameraFactory;

package/lib/Components/Camera/Factory/CameraFactoryImp.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeCameraFactory = void 0;
+const AppObjectComponents_1 = require("@vived/app/lib/AppObjectComponents");
+const CameraEntity_1 = require("../Entities/CameraEntity");
+const CameraFactory_1 = require("../Entities/CameraFactory");
+const CameraPM_1 = require("../PM/CameraPM");
+function makeCameraFactory(appObject, entities) {
+    return new CameraFactoryImp(appObject, entities);
+}
+exports.makeCameraFactory = makeCameraFactory;
+class CameraFactoryImp extends CameraFactory_1.CameraFactory {
+    constructor(appObject, entities) {
+        super(appObject, CameraFactory_1.CameraFactory.type);
+        this.entities = entities;
+        this.setupCamera = () => {
+            const appObjects = this.entities.appObjects;
+            const cameraEntityAo = appObjects.getOrCreate(CameraFactory_1.CameraFactory.entityAppObjectId);
+            new AppObjectComponents_1.Transform3D(cameraEntityAo);
+            const cameraEntity = CameraEntity_1.makeCameraEntity(cameraEntityAo);
+            CameraPM_1.makeCameraPM(cameraEntityAo);
+            return cameraEntity;
+        };
+    }
+}

package/lib/Components/Dispatcher/Mocks/MockLogUC.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="jest" />
+import { AppObject } from "../../../AppObject/AppObject";
+import { LogUC } from "../UC/LogUC";
+export declare class MockLogUC extends LogUC {
+    log: jest.Mock<any, any>;
+    warn: jest.Mock<any, any>;
+    error: jest.Mock<any, any>;
+    fatal: jest.Mock<any, any>;
+    constructor(appObject: AppObject);
+}

package/lib/Components/Dispatcher/Mocks/MockLogUC.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockLogUC = void 0;
+const LogUC_1 = require("../UC/LogUC");
+class MockLogUC extends LogUC_1.LogUC {
+    constructor(appObject) {
+        super(appObject, LogUC_1.LogUC.type);
+        this.log = jest.fn();
+        this.warn = jest.fn();
+        this.error = jest.fn();
+        this.fatal = jest.fn();
+    }
+}
+exports.MockLogUC = MockLogUC;

package/lib/Components/HoverLabel/Controllers/HoverLabelMouse.d.ts

@@ -0,0 +1,17 @@
+import { AppObject, AppObjectController } from "../../../AppObject";
+import { MouseController, MouseInputEvent } from "../../MouseInput";
+export declare abstract class HoverLabelMouse extends AppObjectController implements MouseController {
+    static type: string;
+    pressed: boolean;
+    abstract onMove: (e: MouseInputEvent) => void;
+}
+export declare function makeHoverLabelMouse(appObject: AppObject): HoverLabelMouseImp;
+export declare class HoverLabelMouseImp extends HoverLabelMouse {
+    readonly hoverLabelDelay = 500;
+    private currentTimeout;
+    private hoverLabel?;
+    private tryShowHoverLabel?;
+    allow: (e: MouseInputEvent) => boolean;
+    onMove: (e: MouseInputEvent) => void;
+    constructor(appObject: AppObject);
+}

package/lib/Components/HoverLabel/Controllers/HoverLabelMouse.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HoverLabelMouseImp = exports.makeHoverLabelMouse = exports.HoverLabelMouse = void 0;
+const TryShowHoverLabel_1 = require("../UseCases/TryShowHoverLabel");
+const HoverLabel_1 = require("../Entities/HoverLabel");
+const AppObject_1 = require("../../../AppObject");
+const MouseInput_1 = require("../../MouseInput");
+class HoverLabelMouse extends AppObject_1.AppObjectController {
+    constructor() {
+        super(...arguments);
+        this.pressed = false;
+    }
+}
+exports.HoverLabelMouse = HoverLabelMouse;
+HoverLabelMouse.type = "Mouse_HoverLabel_Controller";
+function makeHoverLabelMouse(appObject) {
+    return new HoverLabelMouseImp(appObject);
+}
+exports.makeHoverLabelMouse = makeHoverLabelMouse;
+class HoverLabelMouseImp extends HoverLabelMouse {
+    constructor(appObject) {
+        super(appObject, HoverLabelMouse.type);
+        this.hoverLabelDelay = 500;
+        this.allow = (e) => {
+            return true;
+        };
+        this.onMove = (e) => {
+            if (!this.hoverLabel)
+                return;
+            if (!this.tryShowHoverLabel)
+                return;
+            this.hoverLabel.hideHoverLabel();
+            if (this.currentTimeout) {
+                clearTimeout(this.currentTimeout);
+            }
+            this.currentTimeout = setTimeout(() => {
+                var _a;
+                (_a = this.tryShowHoverLabel) === null || _a === void 0 ? void 0 : _a.tryShowHoverLabel(e.position);
+                this.currentTimeout = undefined;
+            }, this.hoverLabelDelay);
+        };
+        this.hoverLabel = HoverLabel_1.HoverLabel.get(appObject);
+        if (!this.hoverLabel) {
+            this.warn("Unable to find HoverLabel Entity");
+            return;
+        }
+        this.tryShowHoverLabel = TryShowHoverLabel_1.TryShowHoverLabel.get(this.appObjects);
+        if (!this.tryShowHoverLabel) {
+            this.warn("Unable to find TryShowHoverLabel UC");
+            return;
+        }
+        const mouseInput = MouseInput_1.MouseInputEntity.get(this.appObjects);
+        if (mouseInput) {
+            mouseInput.registerController(this);
+        }
+        else {
+            this.warn("Unable to find MouseInputEntity");
+        }
+    }
+}
+exports.HoverLabelMouseImp = HoverLabelMouseImp;

package/lib/Components/HoverLabel/Controllers/HoverLabelTouch.d.ts

@@ -0,0 +1,22 @@
+import { AppObject, AppObjectController } from "../../../AppObject";
+import { TouchController, TouchInputEvent } from "../../TouchController";
+export declare abstract class HoverLabelTouch 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 makeHoverLabelTouch(appObject: AppObject): HoverLabelTouchImp;
+export declare class HoverLabelTouchImp extends HoverLabelTouch {
+    readonly touchLabelDragThreshold = 15;
+    private lastPosition;
+    private startPosition;
+    private touchStarted;
+    private hoverLabel?;
+    private tryShowHoverLabel?;
+    allow: (e: TouchInputEvent) => boolean;
+    onTouchStart: (e: TouchInputEvent) => void;
+    onTouchMove: (e: TouchInputEvent) => void;
+    onTouchEnd: () => void;
+    constructor(appObject: AppObject);
+}

package/lib/Components/HoverLabel/Controllers/HoverLabelTouch.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HoverLabelTouchImp = exports.makeHoverLabelTouch = exports.HoverLabelTouch = void 0;
+const AppObject_1 = require("../../../AppObject");
+const ValueObjects_1 = require("../../../ValueObjects");
+const TouchController_1 = require("../../TouchController");
+const HoverLabel_1 = require("../Entities/HoverLabel");
+const TryShowHoverLabel_1 = require("../UseCases/TryShowHoverLabel");
+class HoverLabelTouch extends AppObject_1.AppObjectController {
+}
+exports.HoverLabelTouch = HoverLabelTouch;
+HoverLabelTouch.type = "Touch_Hoverlabel_Controller";
+function makeHoverLabelTouch(appObject) {
+    return new HoverLabelTouchImp(appObject);
+}
+exports.makeHoverLabelTouch = makeHoverLabelTouch;
+class HoverLabelTouchImp extends HoverLabelTouch {
+    constructor(appObject) {
+        super(appObject, HoverLabelTouch.type);
+        this.touchLabelDragThreshold = 15;
+        this.lastPosition = ValueObjects_1.Vector2.Zero();
+        this.startPosition = ValueObjects_1.Vector2.Zero();
+        this.touchStarted = false;
+        this.allow = (e) => {
+            return true;
+        };
+        this.onTouchStart = (e) => {
+            if (!this.hoverLabel)
+                return;
+            this.hoverLabel.hideHoverLabel();
+            this.touchStarted = false;
+            if (e.touchCount !== 1)
+                return;
+            this.startPosition = e.touches[0].position;
+            this.lastPosition = e.touches[0].position;
+            this.touchStarted = true;
+        };
+        this.onTouchMove = (e) => {
+            if (!this.touchStarted)
+                return;
+            this.lastPosition = e.touches[0].position;
+        };
+        this.onTouchEnd = () => {
+            if (!this.touchStarted)
+                return;
+            if (!this.tryShowHoverLabel)
+                return;
+            const xDiff = this.lastPosition.x - this.startPosition.x;
+            const yDiff = this.lastPosition.y - this.startPosition.y;
+            const dist = Math.sqrt(xDiff * xDiff + yDiff * yDiff);
+            if (dist < this.touchLabelDragThreshold) {
+                this.tryShowHoverLabel.tryShowHoverLabel(this.lastPosition);
+            }
+        };
+        this.hoverLabel = HoverLabel_1.HoverLabel.get(appObject);
+        if (!this.hoverLabel) {
+            this.warn("Unable to find HoverLabel Entity");
+            return;
+        }
+        this.tryShowHoverLabel = TryShowHoverLabel_1.TryShowHoverLabel.get(this.appObjects);
+        if (!this.tryShowHoverLabel) {
+            this.warn("Unable to find TryShowHoverLabel UC");
+            return;
+        }
+        const touchInput = TouchController_1.TouchInputEntity.get(this.appObjects);
+        if (touchInput) {
+            touchInput.registerController(this);
+        }
+        else {
+            this.warn("Unable to find TouchInputEntity");
+        }
+    }
+}
+exports.HoverLabelTouchImp = HoverLabelTouchImp;

package/lib/Components/HoverLabel/Controllers/ToggleAllowHoverLabelController.d.ts

@@ -0,0 +1,2 @@
+import { AppObjectRepo } from "../../../AppObject";
+export declare function toggleAllowHoverLabel(appObjects: AppObjectRepo): void;

package/lib/Components/HoverLabel/Controllers/ToggleAllowHoverLabelController.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toggleAllowHoverLabel = void 0;
+const ToggleAllowHoverLabel_1 = require("../UseCases/ToggleAllowHoverLabel");
+function toggleAllowHoverLabel(appObjects) {
+    const toggleAllowHoverLabelUC = ToggleAllowHoverLabel_1.ToggleAllowHoverLabelUC.get(appObjects);
+    if (!toggleAllowHoverLabelUC) {
+        appObjects.submitWarning("ToggleAllowHoverLabelController", "ToggleAllowHoverLabelUC not found.");
+        return;
+    }
+    toggleAllowHoverLabelUC.toggleAllowHoverLabel();
+}
+exports.toggleAllowHoverLabel = toggleAllowHoverLabel;

package/lib/{Controllers → Components/HoverLabel/Controllers}/index.d.ts

@@ -1,3 +1,3 @@
-export * from "./ToolHotkeys";
-export * from "./HoverLabelTouch";
 export * from "./HoverLabelMouse";
+export * from "./HoverLabelTouch";
+export * from "./ToggleAllowHoverLabelController";

package/lib/{Controllers → Components/HoverLabel/Controllers}/index.js

@@ -10,6 +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("./ToolHotkeys"), exports);
-__exportStar(require("./HoverLabelTouch"), exports);
 __exportStar(require("./HoverLabelMouse"), exports);
+__exportStar(require("./HoverLabelTouch"), exports);
+__exportStar(require("./ToggleAllowHoverLabelController"), exports);

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

@@ -0,0 +1,33 @@
+import { AppObject, AppObjectEntity, AppObjectRepo } from "../../../AppObject";
+import { Vector2 } from "../../../ValueObjects";
+import { Transform3D } from "../../Transform3D";
+export declare abstract class HoverLabel extends AppObjectEntity {
+    static readonly type = "HoverLabel";
+    abstract readonly transform?: Transform3D;
+    abstract get show(): boolean;
+    abstract get position(): Vector2;
+    abstract get label(): string;
+    abstract get allowHoverLabel(): boolean;
+    abstract set allowHoverLabel(allow: boolean);
+    abstract showHoverLabel: (label: string, position: Vector2) => void;
+    abstract hideHoverLabel: () => void;
+    static get(appObj: AppObject): HoverLabel | undefined;
+    static getFromRepo(appObjects: AppObjectRepo): HoverLabel | undefined;
+}
+export declare function makeHoverLabel(appObject: AppObject): HoverLabelImp;
+declare class HoverLabelImp extends HoverLabel {
+    readonly transform?: Transform3D;
+    constructor(appObject: AppObject);
+    private _position;
+    get position(): Vector2;
+    private _show;
+    get show(): boolean;
+    private _label;
+    get label(): string;
+    private memoizedAllow;
+    get allowHoverLabel(): boolean;
+    set allowHoverLabel(allow: boolean);
+    showHoverLabel: (label: string, position: Vector2) => void;
+    hideHoverLabel: () => void;
+}
+export {};

package/lib/Components/HoverLabel/Entities/HoverLabel.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeHoverLabel = exports.HoverLabel = void 0;
+const AppObject_1 = require("../../../AppObject");
+const Entities_1 = require("../../../Entities");
+const ValueObjects_1 = require("../../../ValueObjects");
+const Transform3D_1 = require("../../Transform3D");
+class HoverLabel extends AppObject_1.AppObjectEntity {
+    static get(appObj) {
+        return appObj.getComponent(this.type);
+    }
+    static getFromRepo(appObjects) {
+        const ucs = appObjects.getAllComponents(HoverLabel.type);
+        if (ucs.length === 0) {
+            console.warn("Unable to find a HoverLabel. Add one on Mount");
+            return undefined;
+        }
+        else if (ucs.length > 1) {
+            console.warn("Multiple HoverLabels have been found. There should only be one. Using the first one");
+        }
+        return ucs[0];
+    }
+}
+exports.HoverLabel = HoverLabel;
+HoverLabel.type = "HoverLabel";
+function makeHoverLabel(appObject) {
+    Transform3D_1.Transform3D.addIfMissing(appObject);
+    return new HoverLabelImp(appObject);
+}
+exports.makeHoverLabel = makeHoverLabel;
+class HoverLabelImp extends HoverLabel {
+    constructor(appObject) {
+        super(appObject, HoverLabel.type);
+        this._position = ValueObjects_1.Vector2.Zero();
+        this._show = false;
+        this._label = "";
+        this.memoizedAllow = new Entities_1.MemoizedBoolean(true, this.notifyOnChange);
+        this.showHoverLabel = (label, position) => {
+            if (!this.allowHoverLabel) {
+                return;
+            }
+            if (label === this._label &&
+                ValueObjects_1.Vector2.Equal(position, this._position) &&
+                this.show) {
+                return;
+            }
+            this._label = label;
+            this._position = position;
+            this._show = true;
+            this.notifyOnChange();
+        };
+        this.hideHoverLabel = () => {
+            if (!this._show)
+                return;
+            this._show = false;
+            this._label = "";
+            this._position = ValueObjects_1.Vector2.Zero();
+            this.notifyOnChange();
+        };
+        this.transform = Transform3D_1.Transform3D.get(appObject);
+        if (!this.transform) {
+            throw Error("HoverLabel does not have a transform component");
+        }
+    }
+    get position() {
+        return this._position;
+    }
+    get show() {
+        return this._show;
+    }
+    get label() {
+        return this._label;
+    }
+    get allowHoverLabel() {
+        return this.memoizedAllow.val;
+    }
+    set allowHoverLabel(allow) {
+        if (allow === this.memoizedAllow.val) {
+            return;
+        }
+        this.memoizedAllow.val = allow;
+        if (allow === false) {
+            this.hideHoverLabel();
+        }
+    }
+}

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

@@ -0,0 +1 @@
+export * from "./HoverLabel";

package/lib/{PresentationManagers/SceneModel → Components/HoverLabel/Entities}/index.js

@@ -10,4 +10,4 @@ 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("./SceneModelPM"), exports);
+__exportStar(require("./HoverLabel"), exports);

package/lib/Components/HoverLabel/PM/AllowHoverLabelPM.d.ts

@@ -0,0 +1,11 @@
+import { AppObject, AppObjectPM } from "../../../AppObject";
+export declare class AllowHoverLabelPM extends AppObjectPM<boolean> {
+    static readonly type = "AllowHoverLabelPM";
+    static addIfMissing(appObj: AppObject): AllowHoverLabelPM;
+    private hoverLabel?;
+    vmsAreEqual(a: boolean, b: boolean): boolean;
+    onEnityChange: () => void;
+    dispose: () => void;
+    constructor(appObject: AppObject);
+}
+export declare const defaultAllowHoverLabelVM: boolean;

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

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultAllowHoverLabelVM = exports.AllowHoverLabelPM = void 0;
+const AppObject_1 = require("../../../AppObject");
+const HoverLabel_1 = require("../Entities/HoverLabel");
+class AllowHoverLabelPM extends AppObject_1.AppObjectPM {
+    constructor(appObject) {
+        super(appObject, AllowHoverLabelPM.type);
+        this.onEnityChange = () => {
+            if (!this.hoverLabel)
+                return;
+            this.doUpdateView(this.hoverLabel.allowHoverLabel);
+        };
+        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(AllowHoverLabelPM.type);
+        if (existing) {
+            return existing;
+        }
+        else {
+            return new AllowHoverLabelPM(appObj);
+        }
+    }
+    vmsAreEqual(a, b) {
+        return a === b;
+    }
+}
+exports.AllowHoverLabelPM = AllowHoverLabelPM;
+AllowHoverLabelPM.type = "AllowHoverLabelPM";
+exports.defaultAllowHoverLabelVM = true;

package/lib/Components/HoverLabel/PM/HoverLabelPM.d.ts

@@ -0,0 +1,19 @@
+import { AppObject, AppObjectPM } from "../../../AppObject";
+export interface HoverLabelVM {
+    show: boolean;
+    text: string;
+    position: {
+        x: number;
+        y: number;
+    };
+}
+export declare class HoverLabelPM extends AppObjectPM<HoverLabelVM> {
+    static readonly type = "HoverLabelPM";
+    static addIfMissing(appObj: AppObject): HoverLabelPM;
+    private hoverLabel?;
+    vmsAreEqual(a: HoverLabelVM, b: HoverLabelVM): boolean;
+    onEnityChange: () => void;
+    dispose: () => void;
+    constructor(appObject: AppObject);
+}
+export declare const defaultHoverLabelVM: HoverLabelVM;