@vived/app 4.1.0 → 4.3.0

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

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TouchPressOnAppObject = void 0;
+const AppObjectController_1 = require("../../../AppObject/AppObjectController");
+const Vector2_1 = require("../../../ValueObjects/Vector2");
+const Babylon_1 = require("../../Babylon");
+const TouchController_1 = require("../../TouchController");
+const PressAppObjectUC_1 = require("../UC/PressAppObjectUC");
+class TouchPressOnAppObject extends AppObjectController_1.AppObjectController {
+    constructor(appObject) {
+        super(appObject, TouchPressOnAppObject.type);
+        this.startPosition = Vector2_1.Vector2.Zero();
+        this.endPosition = Vector2_1.Vector2.Zero();
+        this.doTouchEnd = false;
+        this.pressedID = null;
+        this.isPressed = false;
+        this.allow = (e) => {
+            return true;
+        };
+        this.onTouchStart = (e) => {
+            var _a;
+            this.doTouchEnd = false;
+            this.isPressed = true;
+            if (!this.pressUC) {
+                return;
+            }
+            if (e.touches.length !== 1) {
+                return;
+            }
+            if (!this.allow(e)) {
+                return;
+            }
+            this.startPosition = e.touches[0].position;
+            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.onTouchMove = (e) => {
+            var _a, _b;
+            if (e.touches.length === 1) {
+                this.endPosition = e.touches[0].position;
+                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);
+                }
+            }
+            else {
+                (_b = this.pressUC) === null || _b === void 0 ? void 0 : _b.pressSceneObject(null, true);
+                this.doTouchEnd = false;
+            }
+        };
+        this.onTouchEnd = () => {
+            var _a;
+            if (!this.doTouchEnd) {
+                return;
+            }
+            this.isPressed = false;
+            (_a = this.pressUC) === null || _a === void 0 ? void 0 : _a.pressSceneObject(this.pressedID, this.isPressed);
+        };
+        this.pressUC = appObject.getComponent(PressAppObjectUC_1.PressAppObjectUC.type);
+        if (!this.pressUC) {
+            console.warn("TouchPress has been added to an App Object that does not have a PressAppObjectUC. Add a PressAppObjectUC before adding the Controller.");
+            return;
+        }
+        const touchInput = TouchController_1.TouchInputEntity.get(this.appObjects);
+        if (touchInput) {
+            touchInput.registerController(this);
+        }
+        else {
+            this.warn("Unable to find TouchInputEntity");
+        }
+    }
+}
+exports.TouchPressOnAppObject = TouchPressOnAppObject;
+TouchPressOnAppObject.type = "TouchPressOnAppObject";
+TouchPressOnAppObject.maxTapDistancePx = 5;

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

@@ -0,0 +1,8 @@
+export * from "./MouseHoverOnAppObject";
+export * from "./MousePressOnAppObject";
+export * from "./MouseSelectAppObject";
+export * from "./TapToSelectAppObject";
+export * from "./TouchPressOnAppObject";
+export * from "./StylusHoverOnAppObject";
+export * from "./StylusPressOnAppObject";
+export * from "./StylusSelectAppObject";

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

@@ -0,0 +1,20 @@
+"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("./MouseHoverOnAppObject"), exports);
+__exportStar(require("./MousePressOnAppObject"), exports);
+__exportStar(require("./MouseSelectAppObject"), exports);
+__exportStar(require("./TapToSelectAppObject"), exports);
+__exportStar(require("./TouchPressOnAppObject"), exports);
+__exportStar(require("./StylusHoverOnAppObject"), exports);
+__exportStar(require("./StylusPressOnAppObject"), exports);
+__exportStar(require("./StylusSelectAppObject"), exports);

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

@@ -0,0 +1,15 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectEntity } from "../../../AppObject/AppObjectEntity";
+import { Selection } from "./Selection";
+export declare abstract class Selectable extends AppObjectEntity {
+    static readonly type = "SELECTABLE_ENTITY";
+    abstract inSelection: Selection | undefined;
+    abstract get hovered(): boolean;
+    abstract set hovered(val: boolean);
+    abstract get pressed(): boolean;
+    abstract set pressed(val: boolean);
+    abstract get selected(): boolean;
+    abstract set selected(val: boolean);
+    static get(appObj: AppObject): Selectable | undefined;
+}
+export declare function makeSelectable(appObj: AppObject): Selectable;

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

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSelectable = exports.Selectable = void 0;
+const AppObjectEntity_1 = require("../../../AppObject/AppObjectEntity");
+const MemoizedBoolean_1 = require("../../../Entities/MemoizedBoolean");
+class Selectable extends AppObjectEntity_1.AppObjectEntity {
+    static get(appObj) {
+        return appObj.getComponent(this.type);
+    }
+}
+exports.Selectable = Selectable;
+Selectable.type = "SELECTABLE_ENTITY";
+function makeSelectable(appObj) {
+    return new SelectableImp(appObj);
+}
+exports.makeSelectable = makeSelectable;
+class SelectableImp extends Selectable {
+    constructor(appObject) {
+        super(appObject, Selectable.type);
+        this.memoizedHovered = new MemoizedBoolean_1.MemoizedBoolean(false, this.notifyOnChange);
+        this.memoizedPressed = new MemoizedBoolean_1.MemoizedBoolean(false, this.notifyOnChange);
+        this.memoizedSelected = new MemoizedBoolean_1.MemoizedBoolean(false, this.notifyOnChange);
+    }
+    dispose() {
+        super.dispose();
+        if (this.inSelection) {
+            this.inSelection.removeSelectable(this);
+        }
+    }
+    get hovered() {
+        return this.memoizedHovered.val;
+    }
+    set hovered(val) {
+        this.memoizedHovered.val = val;
+    }
+    get pressed() {
+        return this.memoizedPressed.val;
+    }
+    set pressed(val) {
+        this.memoizedPressed.val = val;
+    }
+    get selected() {
+        return this.memoizedSelected.val;
+    }
+    set selected(val) {
+        this.memoizedSelected.val = val;
+    }
+}

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

@@ -0,0 +1,18 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectEntity } from "../../../AppObject/AppObjectEntity";
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+import { Selectable } from "./Selectable";
+export declare abstract class Selection extends AppObjectEntity {
+    static readonly type = "SELECTION_ENTITY";
+    abstract get pressedObjectId(): string | null;
+    abstract set pressedObjectId(val: string | null);
+    abstract get selectedObjectId(): string | null;
+    abstract set selectedObjectId(val: string | null);
+    abstract get hoveredObjectId(): string | null;
+    abstract set hoveredObjectId(val: string | null);
+    abstract removeSelectable(selectable: Selectable): void;
+    abstract addSelectable(selectable: Selectable): void;
+    abstract hasSelectable(id: string): boolean;
+    static get(appObjects: AppObjectRepo): Selection | undefined;
+}
+export declare function makeSelection(appObj: AppObject): Selection;

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

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSelection = exports.Selection = void 0;
+const AppObject_1 = require("../../../AppObject");
+const AppObjectEntity_1 = require("../../../AppObject/AppObjectEntity");
+class Selection extends AppObjectEntity_1.AppObjectEntity {
+    static get(appObjects) {
+        return AppObject_1.getSingletonComponent(Selection.type, appObjects);
+    }
+}
+exports.Selection = Selection;
+Selection.type = "SELECTION_ENTITY";
+function makeSelection(appObj) {
+    return new SelectionImp(appObj);
+}
+exports.makeSelection = makeSelection;
+class SelectionImp extends Selection {
+    constructor(appObj) {
+        super(appObj, Selection.type);
+        this.selectableLookup = new Map();
+        this._pressed = null;
+        this._selected = null;
+        this._hovered = null;
+    }
+    get pressedObjectId() {
+        return this._pressed;
+    }
+    set pressedObjectId(val) {
+        let finalVal = null;
+        if (val !== null && this.selectableLookup.has(val)) {
+            finalVal = val;
+        }
+        if (this._pressed === finalVal)
+            return;
+        const prevPressed = this._pressed;
+        this._pressed = finalVal;
+        if (prevPressed !== null) {
+            const selectable = this.selectableLookup.get(prevPressed);
+            if (selectable)
+                selectable.pressed = false;
+        }
+        if (this._pressed !== null) {
+            const selectable = this.selectableLookup.get(this._pressed);
+            if (selectable)
+                selectable.pressed = true;
+        }
+        this.notifyOnChange();
+        return;
+    }
+    get selectedObjectId() {
+        return this._selected;
+    }
+    set selectedObjectId(val) {
+        let finalVal = null;
+        if (val !== null && this.selectableLookup.has(val)) {
+            finalVal = val;
+        }
+        if (this._selected === finalVal)
+            return;
+        const prevPressed = this._selected;
+        this._selected = finalVal;
+        if (prevPressed !== null) {
+            const selectable = this.selectableLookup.get(prevPressed);
+            if (selectable)
+                selectable.selected = false;
+        }
+        if (this._selected !== null) {
+            const selectable = this.selectableLookup.get(this._selected);
+            if (selectable)
+                selectable.selected = true;
+        }
+        this.notifyOnChange();
+        return;
+    }
+    get hoveredObjectId() {
+        return this._hovered;
+    }
+    set hoveredObjectId(val) {
+        let finalVal = null;
+        if (val !== null && this.selectableLookup.has(val)) {
+            finalVal = val;
+        }
+        if (this._hovered === finalVal)
+            return;
+        const prevPressed = this._hovered;
+        this._hovered = finalVal;
+        if (prevPressed !== null) {
+            const selectable = this.selectableLookup.get(prevPressed);
+            if (selectable)
+                selectable.hovered = false;
+        }
+        if (this._hovered !== null) {
+            const selectable = this.selectableLookup.get(this._hovered);
+            if (selectable)
+                selectable.hovered = true;
+        }
+        this.notifyOnChange();
+        return;
+    }
+    removeSelectable(selectable) {
+        const id = selectable.appObject.id;
+        if (!this.selectableLookup.has(id))
+            return;
+        this.selectableLookup.delete(id);
+        if (this._pressed === id) {
+            this.pressedObjectId = null;
+        }
+        if (this._hovered === id) {
+            this.hoveredObjectId = null;
+        }
+        if (this._selected === id) {
+            this.selectedObjectId = null;
+        }
+    }
+    addSelectable(selectable) {
+        selectable.inSelection = this;
+        this.selectableLookup.set(selectable.appObject.id, selectable);
+    }
+    hasSelectable(id) {
+        return this.selectableLookup.has(id);
+    }
+}

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

@@ -0,0 +1,2 @@
+export * from "./Selectable";
+export * from "./Selection";

package/lib/Components/Selection/Entities/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("./Selectable"), exports);
+__exportStar(require("./Selection"), exports);

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

@@ -0,0 +1,16 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectPM } from "../../../AppObject/AppObjectPM";
+export interface SelectableStateVM {
+    isSelected: boolean;
+    isPressed: boolean;
+    isHovered: boolean;
+}
+export declare 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;
+}

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

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SelectableStatePM = void 0;
+const AppObjectPM_1 = require("../../../AppObject/AppObjectPM");
+const Selectable_1 = require("../Entities/Selectable");
+class SelectableStatePM extends AppObjectPM_1.AppObjectPM {
+    constructor(appObject) {
+        super(appObject, SelectableStatePM.type);
+        this.onSelectionChange = () => {
+            if (!this.selectable)
+                return;
+            const vm = {
+                isHovered: this.selectable.hovered,
+                isPressed: this.selectable.pressed,
+                isSelected: this.selectable.selected,
+            };
+            this.doUpdateView(vm);
+        };
+        this.dispose = () => {
+            var _a, _b;
+            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);
+        this.onSelectionChange();
+    }
+    vmsAreEqual(a, b) {
+        if (a.isHovered !== b.isHovered)
+            return false;
+        if (a.isPressed !== b.isPressed)
+            return false;
+        if (a.isSelected !== b.isSelected)
+            return false;
+        return true;
+    }
+}
+exports.SelectableStatePM = SelectableStatePM;
+SelectableStatePM.type = "SelectableStatePM";
+SelectableStatePM.defaultVM = {
+    isHovered: false,
+    isPressed: false,
+    isSelected: false,
+};

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

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

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

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSelectedObjectPM = exports.SelectedObjectPM = void 0;
+const AppObjectPM_1 = require("../../../AppObject/AppObjectPM");
+const Selection_1 = require("../Entities/Selection");
+class SelectedObjectPM extends AppObjectPM_1.AppObjectPM {
+}
+exports.SelectedObjectPM = SelectedObjectPM;
+SelectedObjectPM.type = "SelectedObjectPM";
+function makeSelectedObjectPM(appObj) {
+    return new SelectedObjectPMImp(appObj);
+}
+exports.makeSelectedObjectPM = makeSelectedObjectPM;
+class SelectedObjectPMImp extends SelectedObjectPM {
+    constructor(appObject) {
+        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);
+        this.onSelectionChange();
+    }
+    vmsAreEqual(a, b) {
+        return a === b;
+    }
+}

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

@@ -0,0 +1,2 @@
+export * from "./SelectableStatePM";
+export * from "./SelectedObjectPM";

package/lib/Components/Selection/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("./SelectableStatePM"), exports);
+__exportStar(require("./SelectedObjectPM"), exports);

package/lib/Components/Selection/UC/HoverAppObjectUC.d.ts

@@ -0,0 +1,11 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+import { ParametricLine } from "../../../ValueObjects/ParametricLine";
+export declare abstract class HoverAppObjectUC extends AppObjectUC {
+    static readonly type = "HoverAppObjectUC";
+    abstract allowHover(): boolean;
+    abstract allowTryHover(): boolean;
+    abstract hoverSceneObject: (id: string, isHovered: boolean) => void;
+    abstract tryHoverSceneObject: (ray: ParametricLine) => void;
+}
+export declare function makeHoverAppObject(appObject: AppObject): HoverAppObjectUC;

package/lib/Components/Selection/UC/HoverAppObjectUC.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeHoverAppObject = exports.HoverAppObjectUC = void 0;
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const Babylon_1 = require("../../Babylon");
+const Selectable_1 = require("../Entities/Selectable");
+const Selection_1 = require("../Entities/Selection");
+class HoverAppObjectUC extends AppObjectUC_1.AppObjectUC {
+}
+exports.HoverAppObjectUC = HoverAppObjectUC;
+HoverAppObjectUC.type = "HoverAppObjectUC";
+function makeHoverAppObject(appObject) {
+    return new HoverAppObjectUCImp(appObject);
+}
+exports.makeHoverAppObject = makeHoverAppObject;
+class HoverAppObjectUCImp extends HoverAppObjectUC {
+    constructor(appObject) {
+        super(appObject, HoverAppObjectUC.type);
+        this.allowHover = () => {
+            return true;
+        };
+        this.allowTryHover = () => {
+            return true;
+        };
+        this.tryHoverSceneObject = (ray) => {
+            if (!this.selection)
+                return;
+            if (!this.allowTryHover())
+                return;
+            const rayPick = Babylon_1.sceneRayPick(ray, this.appObjects);
+            if (!(rayPick === null || rayPick === void 0 ? void 0 : rayPick.appObjectID)) {
+                this.selection.hoveredObjectId = null;
+                return;
+            }
+            const selectable = this.appObjects.getAppObjectComponent(rayPick.appObjectID, Selectable_1.Selectable.type);
+            if (!selectable) {
+                this.selection.hoveredObjectId = null;
+                return;
+            }
+            this.selection.hoveredObjectId = rayPick.appObjectID;
+        };
+        this.hoverSceneObject = (id, isHovered) => {
+            if (!this.selection)
+                return;
+            if (!this.allowHover())
+                return;
+            if (isHovered) {
+                this.selection.hoveredObjectId = id;
+            }
+            else if (id === this.selection.hoveredObjectId) {
+                this.selection.hoveredObjectId = null;
+            }
+        };
+        this.selection = appObject.getComponent(Selection_1.Selection.type);
+        if (!this.selection) {
+            console.warn("HoverAppObjectUCImp has been added to an App Object that does not have a Selection Entity. Add an Entity before adding the UC");
+        }
+    }
+}

package/lib/Components/Selection/UC/PressAppObjectUC.d.ts

@@ -0,0 +1,11 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+import { ParametricLine } from "../../../ValueObjects/ParametricLine";
+export declare abstract class PressAppObjectUC extends AppObjectUC {
+    static readonly type = "PressAppObjectUC";
+    abstract allowPress(): boolean;
+    abstract allowTryPress(): boolean;
+    abstract pressSceneObject: (id: string | null, isPressed: boolean) => void;
+    abstract tryPressSceneObject: (ray: ParametricLine) => string | null;
+}
+export declare function makePressAppObject(appObject: AppObject): PressAppObjectUC;

package/lib/Components/Selection/UC/PressAppObjectUC.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makePressAppObject = exports.PressAppObjectUC = void 0;
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const Babylon_1 = require("../../Babylon");
+const Selectable_1 = require("../Entities/Selectable");
+const Selection_1 = require("../Entities/Selection");
+class PressAppObjectUC extends AppObjectUC_1.AppObjectUC {
+}
+exports.PressAppObjectUC = PressAppObjectUC;
+PressAppObjectUC.type = "PressAppObjectUC";
+function makePressAppObject(appObject) {
+    return new PressAppObjectUCImp(appObject);
+}
+exports.makePressAppObject = makePressAppObject;
+class PressAppObjectUCImp extends PressAppObjectUC {
+    constructor(appObject) {
+        super(appObject, PressAppObjectUC.type);
+        this.allowPress = () => {
+            return true;
+        };
+        this.allowTryPress = () => {
+            return true;
+        };
+        this.tryPressSceneObject = (ray) => {
+            if (!this.selection)
+                return null;
+            if (!this.allowTryPress())
+                return null;
+            const rayPick = Babylon_1.sceneRayPick(ray, this.appObjects);
+            if (!(rayPick === null || rayPick === void 0 ? void 0 : rayPick.appObjectID)) {
+                this.selection.pressedObjectId = null;
+                return this.selection.pressedObjectId;
+            }
+            const selectable = this.appObjects.getAppObjectComponent(rayPick.appObjectID, Selectable_1.Selectable.type);
+            if (!selectable) {
+                this.selection.pressedObjectId = null;
+                return this.selection.pressedObjectId;
+            }
+            this.selection.pressedObjectId = rayPick.appObjectID;
+            return this.selection.pressedObjectId;
+        };
+        this.pressSceneObject = (id, isPressed) => {
+            if (!this.selection)
+                return;
+            if (!this.allowPress())
+                return;
+            if (isPressed) {
+                this.selection.pressedObjectId = id;
+            }
+            else if (id === this.selection.pressedObjectId) {
+                this.selection.pressedObjectId = null;
+            }
+        };
+        this.selection = appObject.getComponent(Selection_1.Selection.type);
+        if (!this.selection) {
+            console.warn("PressAppObjectUCImp has been added to an App Object that does not have a Selection Entity. Add an Entity before adding the UC");
+        }
+    }
+}

package/lib/Components/Selection/UC/SelectAppObjectUC.d.ts

@@ -0,0 +1,11 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+import { ParametricLine } from "../../../ValueObjects/ParametricLine";
+export declare abstract class SelectAppObjectUC extends AppObjectUC {
+    static readonly type = "SelectAppObjectUC";
+    abstract allowSelect(): boolean;
+    abstract allowTrySelect(): boolean;
+    abstract selectSceneObject: (id: string, isSelected: boolean) => void;
+    abstract trySelectSceneObject: (ray: ParametricLine) => void;
+}
+export declare function makeSelectAppObject(appObject: AppObject): SelectAppObjectUC;