@vived/app 4.6.2 → 4.7.0

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/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/Components/HoverLabel/Controllers/index.d.ts

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

package/lib/Components/HoverLabel/Controllers/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("./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/Components/HoverLabel/Entities/index.js

@@ -0,0 +1,13 @@
+"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("./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;

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/Components/HoverLabel/PM/index.d.ts

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

package/lib/Components/HoverLabel/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("./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/Components/HoverLabel/UseCases/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("./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/Components/HoverLabel/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("./Entities"), exports);
+__exportStar(require("./UseCases"), exports);
+__exportStar(require("./PM"), exports);
+__exportStar(require("./Controllers"), exports);

package/lib/Components/index.d.ts

@@ -25,3 +25,4 @@ export * from "./XR";
 export * from "./zSpace";
 export * from "./Selection";
 export * from "./Landmarks";
+export * from "./HoverLabel";

package/lib/Components/index.js

@@ -37,3 +37,4 @@ __exportStar(require("./XR"), exports);
 __exportStar(require("./zSpace"), exports);
 __exportStar(require("./Selection"), exports);
 __exportStar(require("./Landmarks"), exports);
+__exportStar(require("./HoverLabel"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vived/app",
-  "version": "4.6.2",
+  "version": "4.7.0",
   "description": "Public package for the VIVED Learning App system",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",