@vived/app 4.23.0 → 4.24.0

package/lib/Components/Selection/Controller/StylusHoverOnAppObjectSC.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StylusHoverOnAppObjectSC = void 0;
+const AppObjectController_1 = require("../../../AppObject/AppObjectController");
+const Stylus_1 = require("../../Stylus");
+const HoverAppObjectUC_1 = require("../UC/HoverAppObjectUC");
+class StylusHoverOnAppObjectSC extends AppObjectController_1.AppObjectController {
+    constructor(appObject) {
+        super(appObject, StylusHoverOnAppObjectSC.type);
+        this.allow = () => {
+            return true;
+        };
+        this.onStylusMove = () => {
+            if (!this.stylus)
+                return;
+            if (!this.hoverUC)
+                return;
+            if (!this.allow())
+                return;
+            const pointerRay = this.stylus.pickRay;
+            this.hoverUC.tryHoverAppObject(pointerRay);
+        };
+        this.stylus = Stylus_1.StylusEntity.get(this.appObjects);
+        if (!this.stylus) {
+            this.warn("Unable to find StylusEntity");
+            return;
+        }
+        this.hoverUC = appObject.getComponent(HoverAppObjectUC_1.HoverAppObjectUC.type);
+        if (!this.stylus) {
+            console.warn("StylusInputPointer Controller has been added to an app object that does not have a ZSpaceStylusEntity");
+        }
+        else if (!this.hoverUC) {
+            console.warn("HoverAppObjectUC has not been found on any objects in the app object repo");
+        }
+        else {
+            this.stylus.registerController(this);
+        }
+    }
+}
+exports.StylusHoverOnAppObjectSC = StylusHoverOnAppObjectSC;
+StylusHoverOnAppObjectSC.type = "StylusHoverOnAppObjectSC";

package/lib/Components/Selection/Controller/StylusPressOnAppObjectSC.d.ts

@@ -0,0 +1,18 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectController } from "../../../AppObject/AppObjectController";
+import { StylusController } from "../../Stylus";
+export declare class StylusPressOnAppObjectSC extends AppObjectController implements StylusController {
+    static readonly type = "StylusPressOnAppObjectSC";
+    static readonly maxTapDistancePx = 5;
+    private stylus?;
+    private pressUC?;
+    private startPosition;
+    private endPosition;
+    private pressedID;
+    private isPressed;
+    allow: (button: number) => boolean;
+    onButtonDown: (button: number) => void;
+    onButtonUp: (button: number) => void;
+    onStylusMove: () => void;
+    constructor(appObject: AppObject);
+}

package/lib/Components/Selection/Controller/StylusPressOnAppObjectSC.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StylusPressOnAppObjectSC = void 0;
+const AppObjectController_1 = require("../../../AppObject/AppObjectController");
+const Vector3_1 = require("../../../ValueObjects/Vector3");
+const Stylus_1 = require("../../Stylus");
+const PressAppObjectUC_1 = require("../UC/PressAppObjectUC");
+class StylusPressOnAppObjectSC extends AppObjectController_1.AppObjectController {
+    constructor(appObject) {
+        super(appObject, StylusPressOnAppObjectSC.type);
+        this.startPosition = Vector3_1.Vector3.Zero();
+        this.endPosition = Vector3_1.Vector3.Zero();
+        this.pressedID = null;
+        this.isPressed = false;
+        this.allow = (button) => {
+            return true;
+        };
+        this.onButtonDown = (button) => {
+            var _a;
+            if (!this.stylus)
+                return;
+            if (!this.pressUC)
+                return;
+            if (!this.allow(button))
+                return;
+            this.startPosition = this.stylus.transform.localPosition;
+            this.endPosition = this.startPosition;
+            this.isPressed = true;
+            this.pressedID = (_a = this.pressUC) === null || _a === void 0 ? void 0 : _a.tryPressAppObject(this.stylus.pickRay);
+        };
+        this.onButtonUp = (button) => {
+            this.isPressed = false;
+            if (button !== 0)
+                return;
+            if (!this.pressUC)
+                return;
+            // Set pressedID to null
+            this.pressUC.pressAppObject(this.pressedID, this.isPressed);
+        };
+        this.onStylusMove = () => {
+            var _a;
+            if (!this.pressUC) {
+                return;
+            }
+            if (this.isPressed) {
+                this.endPosition = (_a = this.stylus) === null || _a === void 0 ? void 0 : _a.transform.localPosition;
+                const movement = Vector3_1.Vector3.Subtract(this.startPosition, this.endPosition)
+                    .magnitude;
+                if (movement > StylusPressOnAppObjectSC.maxTapDistancePx) {
+                    // Set pressedID to null
+                    this.pressUC.pressAppObject(null, this.isPressed);
+                }
+            }
+        };
+        this.stylus = Stylus_1.StylusEntity.get(this.appObjects);
+        if (!this.stylus) {
+            this.error("Unable to find StylusEntity");
+            return;
+        }
+        this.pressUC = appObject.getComponent(PressAppObjectUC_1.PressAppObjectUC.type);
+        if (!this.pressUC) {
+            this.error("Unable to get PressAppObjectUC from the App Object");
+            return;
+        }
+        this.stylus.registerController(this);
+    }
+}
+exports.StylusPressOnAppObjectSC = StylusPressOnAppObjectSC;
+StylusPressOnAppObjectSC.type = "StylusPressOnAppObjectSC";
+StylusPressOnAppObjectSC.maxTapDistancePx = 5;

package/lib/Components/Selection/Controller/StylusSelectAppObjectSC.d.ts

@@ -0,0 +1,11 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectController } from "../../../AppObject/AppObjectController";
+import { StylusController } from "../../Stylus";
+export declare class StylusSelectAppObjectSC extends AppObjectController implements StylusController {
+    static readonly type = "StylusSelectAppObjectSC";
+    private stylus?;
+    private selectUC?;
+    allow: () => boolean;
+    onButtonClick: (button: number) => void;
+    constructor(appObject: AppObject);
+}

package/lib/Components/Selection/Controller/StylusSelectAppObjectSC.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StylusSelectAppObjectSC = void 0;
+const AppObjectController_1 = require("../../../AppObject/AppObjectController");
+const Stylus_1 = require("../../Stylus");
+const UC_1 = require("../UC");
+class StylusSelectAppObjectSC extends AppObjectController_1.AppObjectController {
+    constructor(appObject) {
+        super(appObject, StylusSelectAppObjectSC.type);
+        this.allow = () => {
+            return true;
+        };
+        this.onButtonClick = (button) => {
+            if (button !== 0)
+                return;
+            if (!this.stylus)
+                return;
+            if (!this.selectUC)
+                return;
+            if (!this.allow())
+                return;
+            const pointerRay = this.stylus.pickRay;
+            this.selectUC.trySelectAppObject(pointerRay);
+        };
+        this.stylus = Stylus_1.StylusEntity.get(this.appObjects);
+        if (!this.stylus) {
+            this.error("Unable to find StylusEntity");
+            return;
+        }
+        this.selectUC = appObject.getComponent(UC_1.SelectAppObjectUC.type);
+        if (!this.selectUC) {
+            this.error("Added to an App Object that does not have SelectAppObjectUC");
+            return;
+        }
+        this.stylus.registerController(this);
+    }
+}
+exports.StylusSelectAppObjectSC = StylusSelectAppObjectSC;
+StylusSelectAppObjectSC.type = "StylusSelectAppObjectSC";

package/lib/Components/Selection/Controller/TapToSelectAppObject.js

@@ -47,7 +47,7 @@ class TapToSelectAppObject extends AppObjectController_1.AppObjectController {
                 .magnitued;
             if (movement <= TapToSelectAppObject.maxTapDistancePx) {
                 const ray = Babylon_1.pixelToSceneRay(this.endPosition, this.appObjects);
-                (_a = this.selectUC) === null || _a === void 0 ? void 0 : _a.trySelectSceneObject(ray);
+                (_a = this.selectUC) === null || _a === void 0 ? void 0 : _a.trySelectAppObject(ray);
             }
         };
         this.selectUC = appObject.getComponent(SelectAppObjectUC_1.SelectAppObjectUC.type);

package/lib/Components/Selection/Controller/TouchPressOnAppObject.js

@@ -34,7 +34,7 @@ class TouchPressOnAppObject extends AppObjectController_1.AppObjectController {
             this.endPosition = this.startPosition;
             this.doTouchEnd = true;
             const ray = Babylon_1.pixelToSceneRay(this.endPosition, this.appObjects);
-            this.pressedID = (_a = this.pressUC) === null || _a === void 0 ? void 0 : _a.tryPressSceneObject(ray);
+            this.pressedID = (_a = this.pressUC) === null || _a === void 0 ? void 0 : _a.tryPressAppObject(ray);
         };
         this.onTouchMove = (e) => {
             var _a, _b;
@@ -43,11 +43,11 @@ class TouchPressOnAppObject extends AppObjectController_1.AppObjectController {
                 const movement = Vector2_1.Vector2.Subtract(this.startPosition, this.endPosition)
                     .magnitued;
                 if (movement > TouchPressOnAppObject.maxTapDistancePx) {
-                    (_a = this.pressUC) === null || _a === void 0 ? void 0 : _a.pressSceneObject(null, true);
+                    (_a = this.pressUC) === null || _a === void 0 ? void 0 : _a.pressAppObject(null, true);
                 }
             }
             else {
-                (_b = this.pressUC) === null || _b === void 0 ? void 0 : _b.pressSceneObject(null, true);
+                (_b = this.pressUC) === null || _b === void 0 ? void 0 : _b.pressAppObject(null, true);
                 this.doTouchEnd = false;
             }
         };
@@ -57,7 +57,7 @@ class TouchPressOnAppObject extends AppObjectController_1.AppObjectController {
                 return;
             }
             this.isPressed = false;
-            (_a = this.pressUC) === null || _a === void 0 ? void 0 : _a.pressSceneObject(this.pressedID, this.isPressed);
+            (_a = this.pressUC) === null || _a === void 0 ? void 0 : _a.pressAppObject(this.pressedID, this.isPressed);
         };
         this.pressUC = appObject.getComponent(PressAppObjectUC_1.PressAppObjectUC.type);
         if (!this.pressUC) {

package/lib/Components/Selection/Controller/index.d.ts

@@ -1,8 +1,10 @@
 export * from "./MouseHoverOnAppObject";
 export * from "./MousePressOnAppObject";
 export * from "./MouseSelectAppObject";
+export * from "./setHoverOnAppObject";
+export * from "./selectAppObject";
+export * from "./StylusHoverOnAppObjectSC";
+export * from "./StylusPressOnAppObjectSC";
+export * from "./StylusSelectAppObjectSC";
 export * from "./TapToSelectAppObject";
 export * from "./TouchPressOnAppObject";
-export * from "./HoverOnAppObjectSC";
-export * from "./PressOnAppObjectSC";
-export * from "./SelectAppObjectSC";

package/lib/Components/Selection/Controller/index.js

@@ -13,8 +13,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./MouseHoverOnAppObject"), exports);
 __exportStar(require("./MousePressOnAppObject"), exports);
 __exportStar(require("./MouseSelectAppObject"), exports);
+__exportStar(require("./setHoverOnAppObject"), exports);
+__exportStar(require("./selectAppObject"), exports);
+__exportStar(require("./StylusHoverOnAppObjectSC"), exports);
+__exportStar(require("./StylusPressOnAppObjectSC"), exports);
+__exportStar(require("./StylusSelectAppObjectSC"), exports);
 __exportStar(require("./TapToSelectAppObject"), exports);
 __exportStar(require("./TouchPressOnAppObject"), exports);
-__exportStar(require("./HoverOnAppObjectSC"), exports);
-__exportStar(require("./PressOnAppObjectSC"), exports);
-__exportStar(require("./SelectAppObjectSC"), exports);

package/lib/Components/Selection/Controller/selectAppObject.d.ts

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

package/lib/Components/Selection/Controller/selectAppObject.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.selectAppObject = void 0;
+const UC_1 = require("../UC");
+function selectAppObject(id, appObjects) {
+    const uc = UC_1.SelectAppObjectUC.get(appObjects);
+    if (uc) {
+        uc.selectAppObject(id, true);
+    }
+    else {
+        appObjects.submitError("selectAppObject", "Unable to find SelectAppObjectUC");
+    }
+}
+exports.selectAppObject = selectAppObject;

package/lib/Components/Selection/Controller/setHoverOnAppObject.d.ts

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

package/lib/Components/Selection/Controller/setHoverOnAppObject.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setHoverOnAppObject = void 0;
+const UC_1 = require("../UC");
+function setHoverOnAppObject(id, isHovered, appObjects) {
+    const uc = UC_1.HoverAppObjectUC.get(appObjects);
+    if (uc) {
+        uc.hoverAppObject(id, isHovered);
+    }
+    else {
+        appObjects.submitError("setHoverOnAppObject", "Unable to find HoverAppObjectUC");
+    }
+}
+exports.setHoverOnAppObject = setHoverOnAppObject;

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

@@ -13,6 +13,7 @@ export declare abstract class Selection extends AppObjectEntity {
     abstract removeSelectable(selectable: Selectable): void;
     abstract addSelectable(selectable: Selectable): void;
     abstract hasSelectable(id: string): boolean;
+    abstract makeAppObjectSelectable(appObject: AppObject): Selectable;
     static get(appObjects: AppObjectRepo): Selection | undefined;
 }
 export declare function makeSelection(appObj: AppObject): Selection;

package/lib/Components/Selection/Entities/Selection.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeSelection = exports.Selection = void 0;
 const AppObject_1 = require("../../../AppObject");
 const AppObjectEntity_1 = require("../../../AppObject/AppObjectEntity");
+const Selectable_1 = require("./Selectable");
 class Selection extends AppObjectEntity_1.AppObjectEntity {
     static get(appObjects) {
         return AppObject_1.getSingletonComponent(Selection.type, appObjects);
@@ -57,10 +58,10 @@ class SelectionImp extends Selection {
         }
         if (this._selected === finalVal)
             return;
-        const prevPressed = this._selected;
+        const prevSelected = this._selected;
         this._selected = finalVal;
-        if (prevPressed !== null) {
-            const selectable = this.selectableLookup.get(prevPressed);
+        if (prevSelected !== null) {
+            const selectable = this.selectableLookup.get(prevSelected);
             if (selectable)
                 selectable.selected = false;
         }
@@ -119,4 +120,9 @@ class SelectionImp extends Selection {
     hasSelectable(id) {
         return this.selectableLookup.has(id);
     }
+    makeAppObjectSelectable(appObject) {
+        const selectable = Selectable_1.makeSelectable(appObject);
+        this.addSelectable(selectable);
+        return selectable;
+    }
 }

package/lib/Components/Selection/Mocks/HoverAppObjectUCMock.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="jest" />
+import { AppObject } from "../../../AppObject";
+import { HoverAppObjectUC } from "../UC";
+export declare class HoverAppObjectUCMock extends HoverAppObjectUC {
+    allowHover: jest.Mock<any, any>;
+    allowTryHover: jest.Mock<any, any>;
+    hoverAppObject: jest.Mock<any, any>;
+    tryHoverAppObject: jest.Mock<any, any>;
+    constructor(appObject: AppObject);
+}

package/lib/Components/Selection/Mocks/HoverAppObjectUCMock.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HoverAppObjectUCMock = void 0;
+const UC_1 = require("../UC");
+class HoverAppObjectUCMock extends UC_1.HoverAppObjectUC {
+    constructor(appObject) {
+        super(appObject, UC_1.HoverAppObjectUC.type);
+        this.allowHover = jest.fn();
+        this.allowTryHover = jest.fn();
+        this.hoverAppObject = jest.fn();
+        this.tryHoverAppObject = jest.fn();
+    }
+}
+exports.HoverAppObjectUCMock = HoverAppObjectUCMock;

package/lib/Components/Selection/Mocks/PressAppObjectUCMock.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="jest" />
+import { AppObject } from "../../../AppObject";
+import { PressAppObjectUC } from "../UC";
+export declare class PressAppObjectUCMock extends PressAppObjectUC {
+    allowPress: jest.Mock<any, any>;
+    allowTryPress: jest.Mock<any, any>;
+    pressAppObject: jest.Mock<any, any>;
+    tryPressAppObject: jest.Mock<any, any>;
+    constructor(appObject: AppObject);
+}

package/lib/Components/Selection/Mocks/PressAppObjectUCMock.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PressAppObjectUCMock = void 0;
+const UC_1 = require("../UC");
+class PressAppObjectUCMock extends UC_1.PressAppObjectUC {
+    constructor(appObject) {
+        super(appObject, UC_1.PressAppObjectUC.type);
+        this.allowPress = jest.fn();
+        this.allowTryPress = jest.fn();
+        this.pressAppObject = jest.fn();
+        this.tryPressAppObject = jest.fn();
+    }
+}
+exports.PressAppObjectUCMock = PressAppObjectUCMock;

package/lib/Components/Selection/Mocks/SelectAppObjectUCMock.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="jest" />
+import { AppObject } from "../../../AppObject";
+import { SelectAppObjectUC } from "../UC";
+export declare class SelectAppObjectUCMock extends SelectAppObjectUC {
+    allowSelect: jest.Mock<any, any>;
+    allowTrySelect: jest.Mock<any, any>;
+    selectAppObject: jest.Mock<any, any>;
+    trySelectAppObject: jest.Mock<any, any>;
+    constructor(appObject: AppObject);
+}

package/lib/Components/Selection/Mocks/SelectAppObjectUCMock.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SelectAppObjectUCMock = void 0;
+const UC_1 = require("../UC");
+class SelectAppObjectUCMock extends UC_1.SelectAppObjectUC {
+    constructor(appObject) {
+        super(appObject, UC_1.SelectAppObjectUC.type);
+        this.allowSelect = jest.fn();
+        this.allowTrySelect = jest.fn();
+        this.selectAppObject = jest.fn();
+        this.trySelectAppObject = jest.fn();
+    }
+}
+exports.SelectAppObjectUCMock = SelectAppObjectUCMock;

package/lib/Components/Selection/Mocks/SelectableStatePMMock.d.ts

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

package/lib/Components/Selection/Mocks/SelectableStatePMMock.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SelectableStatePMMock = void 0;
+const SelectableStatePM_1 = require("../PM/SelectableStatePM");
+class SelectableStatePMMock extends SelectableStatePM_1.SelectableStatePM {
+    constructor(appObject) {
+        super(appObject, SelectableStatePM_1.SelectableStatePM.type);
+        this.vmsAreEqual = jest.fn();
+    }
+}
+exports.SelectableStatePMMock = SelectableStatePMMock;

package/lib/Components/Selection/Mocks/SelectedObjectPMMock.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="jest" />
+import { AppObject, AppObjectRepo } from "../../../AppObject";
+import { SelectedObjectPM } from "../PM/SelectedObjectPM";
+export declare class SelectedObjectPMMock extends SelectedObjectPM {
+    vmsAreEqual: jest.Mock<any, any>;
+    constructor(appObject: AppObject);
+}
+export declare function makeSelectedObjectPMMock(appObjects: AppObjectRepo): SelectedObjectPMMock;

package/lib/Components/Selection/Mocks/SelectedObjectPMMock.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSelectedObjectPMMock = exports.SelectedObjectPMMock = void 0;
+const SelectedObjectPM_1 = require("../PM/SelectedObjectPM");
+class SelectedObjectPMMock extends SelectedObjectPM_1.SelectedObjectPM {
+    constructor(appObject) {
+        super(appObject, SelectedObjectPM_1.SelectedObjectPM.type);
+        this.vmsAreEqual = jest.fn();
+    }
+}
+exports.SelectedObjectPMMock = SelectedObjectPMMock;
+function makeSelectedObjectPMMock(appObjects) {
+    return new SelectedObjectPMMock(appObjects.getOrCreate("SelectedObjectPMMock"));
+}
+exports.makeSelectedObjectPMMock = makeSelectedObjectPMMock;

package/lib/Components/Selection/Mocks/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./HoverAppObjectUCMock";
+export * from "./PressAppObjectUCMock";
+export * from "./SelectableStatePMMock";
+export * from "./SelectAppObjectUCMock";
+export * from "./SelectedObjectPMMock";

package/lib/Components/Selection/Mocks/index.js

@@ -0,0 +1,17 @@
+"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("./HoverAppObjectUCMock"), exports);
+__exportStar(require("./PressAppObjectUCMock"), exports);
+__exportStar(require("./SelectableStatePMMock"), exports);
+__exportStar(require("./SelectAppObjectUCMock"), exports);
+__exportStar(require("./SelectedObjectPMMock"), exports);

package/lib/Components/Selection/PM/SelectableStatePM.d.ts

@@ -1,3 +1,4 @@
+import { AppObjectRepo } from "../../../AppObject";
 import { AppObject } from "../../../AppObject/AppObject";
 import { AppObjectPM } from "../../../AppObject/AppObjectPM";
 export interface SelectableStateVM {
@@ -5,12 +6,9 @@ export interface SelectableStateVM {
     isPressed: boolean;
     isHovered: boolean;
 }
-export declare class SelectableStatePM extends AppObjectPM<SelectableStateVM> {
+export declare const defaultSelectableStateVM: SelectableStateVM;
+export declare abstract class SelectableStatePM extends AppObjectPM<SelectableStateVM> {
     static readonly type = "SelectableStatePM";
-    private selectable?;
-    onSelectionChange: () => void;
-    vmsAreEqual(a: SelectableStateVM, b: SelectableStateVM): boolean;
-    dispose: () => void;
-    constructor(appObject: AppObject);
-    static defaultVM: SelectableStateVM;
+    static get(id: string, appObjects: AppObjectRepo): SelectableStatePM | undefined;
 }
+export declare function makeSelectableStatePM(appObject: AppObject): SelectableStatePM;

package/lib/Components/Selection/PM/SelectableStatePM.js

@@ -1,10 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SelectableStatePM = void 0;
+exports.makeSelectableStatePM = exports.SelectableStatePM = exports.defaultSelectableStateVM = void 0;
 const AppObjectPM_1 = require("../../../AppObject/AppObjectPM");
 const Selectable_1 = require("../Entities/Selectable");
+exports.defaultSelectableStateVM = {
+    isHovered: false,
+    isPressed: false,
+    isSelected: false,
+};
 class SelectableStatePM extends AppObjectPM_1.AppObjectPM {
+    static get(id, appObjects) {
+        var _a;
+        return (_a = appObjects
+            .get(id)) === null || _a === void 0 ? void 0 : _a.getComponent(SelectableStatePM.type);
+    }
+}
+exports.SelectableStatePM = SelectableStatePM;
+SelectableStatePM.type = "SelectableStatePM";
+function makeSelectableStatePM(appObject) {
+    return new SelectableStatePMImp(appObject);
+}
+exports.makeSelectableStatePM = makeSelectableStatePM;
+class SelectableStatePMImp extends SelectableStatePM {
     constructor(appObject) {
+        var _a;
         super(appObject, SelectableStatePM.type);
         this.onSelectionChange = () => {
             if (!this.selectable)
@@ -17,21 +36,16 @@ class SelectableStatePM extends AppObjectPM_1.AppObjectPM {
             this.doUpdateView(vm);
         };
         this.dispose = () => {
-            var _a, _b;
+            var _a;
             super.dispose();
             (_a = this.selectable) === null || _a === void 0 ? void 0 : _a.removeChangeObserver(this.onSelectionChange);
-            (_b = this.selectable) === null || _b === void 0 ? void 0 : _b.removeOnDisposeObserver(this.dispose);
         };
-        this.selectable = Selectable_1.Selectable.get(appObject);
-        if (!this.selectable) {
-            console.warn("[SelectablePM] App Object does not have a Selectable Entity");
-            this.dispose();
-            return;
-        }
-        this.selectable.addChangeObserver(this.onSelectionChange);
-        this.selectable.addOnDisposeObserver(this.dispose);
+        (_a = this.selectable) === null || _a === void 0 ? void 0 : _a.addChangeObserver(this.onSelectionChange);
         this.onSelectionChange();
     }
+    get selectable() {
+        return this.getCachedLocalComponent(Selectable_1.Selectable.type);
+    }
     vmsAreEqual(a, b) {
         if (a.isHovered !== b.isHovered)
             return false;
@@ -42,10 +56,3 @@ class SelectableStatePM extends AppObjectPM_1.AppObjectPM {
         return true;
     }
 }
-exports.SelectableStatePM = SelectableStatePM;
-SelectableStatePM.type = "SelectableStatePM";
-SelectableStatePM.defaultVM = {
-    isHovered: false,
-    isPressed: false,
-    isSelected: false,
-};

package/lib/Components/Selection/PM/SelectedObjectPM.d.ts

@@ -1,6 +1,8 @@
+import { AppObjectRepo } from "../../../AppObject";
 import { AppObject } from "../../../AppObject/AppObject";
 import { AppObjectPM } from "../../../AppObject/AppObjectPM";
 export declare abstract class SelectedObjectPM extends AppObjectPM<string | null> {
     static readonly type = "SelectedObjectPM";
+    static get(appObjects: AppObjectRepo): SelectedObjectPM | undefined;
 }
 export declare function makeSelectedObjectPM(appObj: AppObject): SelectedObjectPM;

package/lib/Components/Selection/PM/SelectedObjectPM.js

@@ -1,9 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeSelectedObjectPM = exports.SelectedObjectPM = void 0;
+const AppObject_1 = require("../../../AppObject");
 const AppObjectPM_1 = require("../../../AppObject/AppObjectPM");
 const Selection_1 = require("../Entities/Selection");
 class SelectedObjectPM extends AppObjectPM_1.AppObjectPM {
+    static get(appObjects) {
+        return AppObject_1.getSingletonComponent(SelectedObjectPM.type, appObjects);
+    }
 }
 exports.SelectedObjectPM = SelectedObjectPM;
 SelectedObjectPM.type = "SelectedObjectPM";
@@ -13,27 +17,19 @@ function makeSelectedObjectPM(appObj) {
 exports.makeSelectedObjectPM = makeSelectedObjectPM;
 class SelectedObjectPMImp extends SelectedObjectPM {
     constructor(appObject) {
+        var _a;
         super(appObject, SelectedObjectPM.type);
         this.onSelectionChange = () => {
             if (!this.selection)
                 return;
             this.doUpdateView(this.selection.selectedObjectId);
         };
-        this.dispose = () => {
-            var _a, _b;
-            super.dispose();
-            (_a = this.selection) === null || _a === void 0 ? void 0 : _a.removeChangeObserver(this.onSelectionChange);
-            (_b = this.selection) === null || _b === void 0 ? void 0 : _b.removeOnDisposeObserver(this.dispose);
-        };
-        this.selection = appObject.getComponent(Selection_1.Selection.type);
-        if (!this.selection) {
-            console.warn("[SelectedObjectPM] App Object does not have a Selection Entity");
-            this.dispose();
-            return;
-        }
-        this.selection.addChangeObserver(this.onSelectionChange);
-        this.selection.addOnDisposeObserver(this.dispose);
+        (_a = this.selection) === null || _a === void 0 ? void 0 : _a.addChangeObserver(this.onSelectionChange);
         this.onSelectionChange();
+        this.appObjects.registerSingleton(this);
+    }
+    get selection() {
+        return this.getCachedSingleton(Selection_1.Selection.type);
     }
     vmsAreEqual(a, b) {
         return a === b;