@vived/app 4.26.2 → 4.27.1

package/lib/Components/App/PM/HasNextPreviousStatePM.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultHasNextPreviousStateVM = exports.HasNextPreviousStatePM = void 0;
+const AppObject_1 = require("../../../AppObject");
+const Entity_1 = require("../Entity");
+class HasNextPreviousStatePM extends AppObject_1.AppObjectPM {
+    constructor(appObject) {
+        super(appObject, HasNextPreviousStatePM.type);
+        this.onAppStateChange = () => {
+            if (!this.baseAppState)
+                return;
+            const hasNextState = this.baseAppState.hasNextState;
+            const hasPreviousState = this.baseAppState.hasPreviousState;
+            const vm = { hasNextState, hasPreviousState };
+            this.doUpdateView(vm);
+        };
+        this.baseAppState = appObject.getComponent(Entity_1.BaseAppState.type);
+        if (!this.baseAppState) {
+            this.warn("HasNextPreviousStatePM added to an app object that does not have a BaseAppState Entity. Add one first");
+            return;
+        }
+        this.baseAppState.addChangeObserver(this.onAppStateChange);
+        this.onAppStateChange();
+    }
+    vmsAreEqual(a, b) {
+        if (a.hasNextState !== b.hasNextState)
+            return false;
+        if (a.hasPreviousState !== b.hasPreviousState)
+            return false;
+        return true;
+    }
+    dispose() {
+        var _a;
+        super.dispose();
+        (_a = this.baseAppState) === null || _a === void 0 ? void 0 : _a.removeChangeObserver(this.onAppStateChange);
+    }
+}
+exports.HasNextPreviousStatePM = HasNextPreviousStatePM;
+HasNextPreviousStatePM.type = "HasNextPreviousStatePM";
+HasNextPreviousStatePM.get = (appObjects) => AppObject_1.getSingletonComponent(HasNextPreviousStatePM.type, appObjects);
+exports.defaultHasNextPreviousStateVM = {
+    hasNextState: true,
+    hasPreviousState: false,
+};

package/lib/Components/ChannelModel/Controllers/setModelObjectLabel.js

@@ -5,7 +5,7 @@ const Entities_1 = require("../Entities");
 function setModelObjectLabel(label, id, appObjects) {
     const entity = Entities_1.ChannelModelObject.get(id, appObjects);
     if (entity) {
-        entity.label.custom = label;
+        entity.label = label;
     }
     else {
         appObjects.submitWarning("setModelObjectLabel", "Unable to find object by ID");

package/lib/Components/ChannelModel/UC/ProcessChannelModelUC.d.ts

@@ -0,0 +1,6 @@
+import { AppObjectRepo, AppObjectUC } from "../../../AppObject";
+export declare abstract class ProcessChannelModelUC extends AppObjectUC {
+    static readonly type: string;
+    abstract processChannelModel: (modelAssetID: string) => Promise<void>;
+    static get: (appObjects: AppObjectRepo) => ProcessChannelModelUC | undefined;
+}

package/lib/Components/ChannelModel/UC/ProcessChannelModelUC.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProcessChannelModelUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+class ProcessChannelModelUC extends AppObject_1.AppObjectUC {
+}
+exports.ProcessChannelModelUC = ProcessChannelModelUC;
+ProcessChannelModelUC.type = "ProcessChannelModelUC";
+ProcessChannelModelUC.get = (appObjects) => AppObject_1.getSingletonComponent(ProcessChannelModelUC.type, appObjects);

package/lib/Components/ChannelModel/UC/SetupChannelModelUC.d.ts

@@ -0,0 +1,10 @@
+import { AppObject, AppObjectRepo, AppObjectUC } from "../../../AppObject";
+import { ChannelModel } from "../Entities";
+export declare const SCENE_MODEL_DATA_ASSET_LINK_TYPE = "default_model_data";
+export declare abstract class SetupChannelModelUC extends AppObjectUC {
+    static readonly type: string;
+    static readonly SCENE_MODEL_DATA_ASSET_LINK_TYPE = "default_model_data";
+    abstract setupChannelModel(modelID: string): Promise<ChannelModel>;
+    static get: (appObjects: AppObjectRepo) => SetupChannelModelUC | undefined;
+}
+export declare function makeSetupChannelModelUC(appObject: AppObject): SetupChannelModelUC;

package/lib/Components/ChannelModel/UC/SetupChannelModelUC.js

@@ -0,0 +1,141 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSetupChannelModelUC = exports.SetupChannelModelUC = exports.SCENE_MODEL_DATA_ASSET_LINK_TYPE = void 0;
+const AppObject_1 = require("../../../AppObject");
+const ValueObjects_1 = require("../../../ValueObjects");
+const Dispatcher_1 = require("../../Dispatcher");
+const Label_1 = require("../../Label");
+const Mesh_1 = require("../../Mesh");
+const Entities_1 = require("../Entities");
+const ProcessChannelModelUC_1 = require("./ProcessChannelModelUC");
+exports.SCENE_MODEL_DATA_ASSET_LINK_TYPE = "default_model_data";
+class SetupChannelModelUC extends AppObject_1.AppObjectUC {
+}
+exports.SetupChannelModelUC = SetupChannelModelUC;
+SetupChannelModelUC.type = "SetupChannelModelUC";
+SetupChannelModelUC.SCENE_MODEL_DATA_ASSET_LINK_TYPE = "default_model_data";
+SetupChannelModelUC.get = (appObjects) => AppObject_1.getSingletonComponent(SetupChannelModelUC.type, appObjects);
+function makeSetupChannelModelUC(appObject) {
+    return new SetupChannelModelUCImp(appObject);
+}
+exports.makeSetupChannelModelUC = makeSetupChannelModelUC;
+class SetupChannelModelUCImp extends SetupChannelModelUC {
+    constructor(appObject) {
+        super(appObject, SetupChannelModelUC.type);
+        this.setupChannelModel = (modelID) => __awaiter(this, void 0, void 0, function* () {
+            const channelModelRepo = this.appObject.getComponent(Entities_1.ChannelModelRepo.type);
+            if (!channelModelRepo) {
+                this.warn("Unable to get channelModelRepo from the model repo App Object");
+                return Promise.reject(new Error("No Channel Model Repo"));
+            }
+            const processModel = ProcessChannelModelUC_1.ProcessChannelModelUC.get(this.appObjects);
+            if (!processModel) {
+                return Promise.reject(new Error("No Process ModelUC"));
+            }
+            const appObj = this.appObjects.getOrCreate(modelID);
+            const channelModel = channelModelRepo.makeIfMissing(appObj);
+            if (channelModel.state === Entities_1.ChannelModelState.LOADING) {
+                return Promise.resolve(channelModel);
+            }
+            if (channelModel.state === Entities_1.ChannelModelState.READY) {
+                return Promise.resolve(channelModel);
+            }
+            channelModel.modelError = undefined;
+            channelModel.state = Entities_1.ChannelModelState.LOADING;
+            channelModelRepo.isLoadingChannelModel = true;
+            const spinner = Dispatcher_1.ShowSpinnerUC.get(this.appObjects);
+            let closeSpinner = () => {
+                // done
+            };
+            if (spinner) {
+                closeSpinner = yield spinner.showSpinner("Loading active model and data", "Loading...");
+            }
+            try {
+                const { bounds_max, bounds_min, defaultPosition, defaultRotation, defaultScale, name, objects, } = yield this.modelDataLoader(modelID);
+                channelModel.name = name;
+                channelModel.bounds_max = ValueObjects_1.Vector3.FromDTO(bounds_max);
+                channelModel.bounds_min = ValueObjects_1.Vector3.FromDTO(bounds_min);
+                channelModel.defaultPosition = ValueObjects_1.Vector3.FromDTO(defaultPosition);
+                channelModel.defaultScale = defaultScale;
+                channelModel.defaultRotation = ValueObjects_1.Quaternion.FromDTO(defaultRotation);
+                const meshes = [];
+                objects.forEach((mesh) => {
+                    const { id, label, meshPaths } = mesh;
+                    meshes.push(mesh.id);
+                    this.setupMeshObject(id, label, meshPaths);
+                });
+                channelModel.meshList = meshes;
+                yield processModel.processChannelModel(modelID);
+                channelModel.state = Entities_1.ChannelModelState.READY;
+                channelModelRepo.isLoadingChannelModel = false;
+                Dispatcher_1.dispatchStateChange(this.appObjects);
+                closeSpinner();
+                return Promise.resolve(channelModel);
+            }
+            catch (e) {
+                const error = e;
+                if (channelModelRepo) {
+                    channelModelRepo.isLoadingChannelModel = false;
+                }
+                channelModel.modelError = error;
+                closeSpinner();
+                const alertDTO = {
+                    title: "Load Error",
+                    message: `Failed to Load the Model and Data. Error message: ${error.message}`,
+                    closeButtonLabel: "OK",
+                    closeCallback: () => {
+                        // done
+                    },
+                };
+                const showAlertUC = Dispatcher_1.ShowAlertUC.get(this.appObjects);
+                if (showAlertUC) {
+                    showAlertUC.showAlert(alertDTO);
+                }
+                else {
+                    this.warn(alertDTO.message);
+                }
+                return Promise.reject(error);
+            }
+        });
+    }
+    setupMeshObject(id, label, meshPaths) {
+        const appObj = this.appObjects.getOrCreate(id);
+        const labelEntity = Label_1.Label.addIfMissing(appObj);
+        labelEntity.default = label;
+        const meshEntity = Mesh_1.Mesh.addIfMissing(appObj);
+        meshPaths.forEach((meshPath) => {
+            meshEntity.addSubMesh({
+                meshPath,
+                neutralPosition: ValueObjects_1.Vector3.Zero(),
+                neutralRotation: ValueObjects_1.Quaternion.Identity(),
+                neutralScale: ValueObjects_1.Vector3.One(),
+            });
+        });
+    }
+    modelDataLoader(modelID) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const dataAssets = yield Dispatcher_1.getLinkedAssets(modelID, SetupChannelModelUC.SCENE_MODEL_DATA_ASSET_LINK_TYPE, this.appObjects);
+                if (dataAssets.length === 0) {
+                    return Promise.reject(new Error("Model asset does not have data"));
+                }
+                const dataFileBlobURL = yield Dispatcher_1.getAssetBlobURL(dataAssets[0].id, this.appObjects);
+                const fetchDataResp = yield fetch(dataFileBlobURL);
+                const modelJSONData = yield fetchDataResp.json();
+                return Promise.resolve(modelJSONData);
+            }
+            catch (e) {
+                return Promise.reject(e);
+            }
+        });
+    }
+}

package/lib/Components/Hideable/UCs/SerializeHideableObjects.d.ts

@@ -0,0 +1,23 @@
+import { SerializedSystem } from "../../StateMachine/Entities/StateMachineEntity";
+import { AppObjectUC, AppObject } from "../../../AppObject";
+export declare abstract class SerializeHideableObjects extends AppObjectUC implements SerializedSystem {
+    static readonly type = "SerializeHideableObjects";
+    name: string;
+    abstract seriliziationVersion: number;
+    abstract getSystemState(): object;
+    abstract applySystemState(state: object, version: number, transitionDuration: number): void;
+    abstract applyDefaultState(transitionDuration: number): void;
+}
+export declare function makeSerializeHideableObjects(appObject: AppObject): SerializeHideableObjects;
+export declare class SerializeHideableObjectsImp extends SerializeHideableObjects {
+    seriliziationVersion: number;
+    selectChannelModelUC: () => void;
+    getSystemState(): object;
+    applySystemState(state: object, version: number, durationS: number): Promise<void> | void;
+    private applyStateV1;
+    applyDefaultState(): void;
+    constructor(appObj: AppObject);
+}
+export interface SerializedHideableObjectsV1 {
+    hiddenObjects: string[];
+}

package/lib/Components/Hideable/UCs/SerializeHideableObjects.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SerializeHideableObjectsImp = exports.makeSerializeHideableObjects = exports.SerializeHideableObjects = void 0;
+const Hideable_1 = require("../Entities/Hideable");
+const StateMachineEntity_1 = require("../../StateMachine/Entities/StateMachineEntity");
+const AppObject_1 = require("../../../AppObject");
+class SerializeHideableObjects extends AppObject_1.AppObjectUC {
+    constructor() {
+        super(...arguments);
+        this.name = "hideable-objects";
+    }
+}
+exports.SerializeHideableObjects = SerializeHideableObjects;
+SerializeHideableObjects.type = "SerializeHideableObjects";
+function makeSerializeHideableObjects(appObject) {
+    return new SerializeHideableObjectsImp(appObject);
+}
+exports.makeSerializeHideableObjects = makeSerializeHideableObjects;
+class SerializeHideableObjectsImp extends SerializeHideableObjects {
+    constructor(appObj) {
+        super(appObj, SerializeHideableObjects.type);
+        this.seriliziationVersion = 1;
+        this.selectChannelModelUC = () => {
+            console.warn("[SerializeHideableObjects] Select Channel Model UC was not setup");
+        };
+        const stateMachine = this.appObjects.getSingleton(StateMachineEntity_1.StateMachineEntity.type);
+        if (stateMachine) {
+            stateMachine.registerSerializedSystem(this);
+        }
+        else {
+            this.warn("Unable to find StateMachineEntity");
+        }
+    }
+    getSystemState() {
+        const hiddenObjects = [];
+        const allHideables = this.appObjects.getAllComponents(Hideable_1.Hideable.type);
+        allHideables.forEach((hideable) => {
+            if (hideable.isHidden)
+                hiddenObjects.push(hideable.appObject.id);
+        });
+        const state = {
+            hiddenObjects,
+        };
+        return state;
+    }
+    applySystemState(state, version, durationS) {
+        if (version === 1) {
+            return this.applyStateV1(state, durationS);
+        }
+        else {
+            this.applyDefaultState();
+        }
+    }
+    applyStateV1(state, durationS) {
+        const { hiddenObjects } = state;
+        let hiddenObjectsIds = [];
+        if (hiddenObjects !== undefined && hiddenObjects.length > 0) {
+            hiddenObjectsIds = [...hiddenObjects];
+        }
+        else {
+            this.applyDefaultState();
+            return;
+        }
+        const allHideables = this.appObjects.getAllComponents(Hideable_1.Hideable.type);
+        allHideables.forEach((hideable) => {
+            const appObjectId = hideable.appObject.id;
+            if (hiddenObjectsIds.includes(appObjectId)) {
+                hideable.isHidden = true;
+                const index = hiddenObjectsIds.indexOf(appObjectId);
+                if (index !== -1) {
+                    hiddenObjectsIds.splice(index, 1);
+                }
+            }
+        });
+        hiddenObjectsIds.forEach((remainingObjectId) => {
+            const appObject = this.appObjects.get(remainingObjectId);
+            if (appObject) {
+                const hideable = Hideable_1.Hideable.addIfMissing(appObject);
+                hideable.isHidden = true;
+            }
+        });
+    }
+    applyDefaultState() {
+        const allHideables = this.appObjects.getAllComponents(Hideable_1.Hideable.type);
+        allHideables.forEach((hideable) => {
+            hideable.isHidden = false;
+        });
+    }
+}
+exports.SerializeHideableObjectsImp = SerializeHideableObjectsImp;

package/lib/Components/Hideable/UCs/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./HideUC";
 export * from "./TryHideWithPickUC";
+export * from "./SerializeHideableObjects";

package/lib/Components/Hideable/UCs/index.js

@@ -12,3 +12,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./HideUC"), exports);
 __exportStar(require("./TryHideWithPickUC"), exports);
+__exportStar(require("./SerializeHideableObjects"), exports);

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

@@ -1,10 +1,9 @@
-import { AppObject, AppObjectEntity, AppObjectRepo } from "../../../AppObject";
+import { AppObject, AppObjectEntity } from "../../../AppObject";
 export declare class Label extends AppObjectEntity {
     static maxLabelLength: number;
     static readonly type = "LABEL";
     static addIfMissing(appObj: AppObject): Label;
     static get(appObj: AppObject): Label | undefined;
-    static getByID(id: string, appObjects: AppObjectRepo): Label | undefined;
     private memoizedDefault;
     get default(): string;
     set default(val: string);

package/lib/Components/Label/Entities/Label.js

@@ -21,12 +21,6 @@ class Label extends AppObject_1.AppObjectEntity {
     static get(appObj) {
         return appObj.getComponent(this.type);
     }
-    static getByID(id, appObjects) {
-        const appObj = appObjects.get(id);
-        if (!appObj)
-            return;
-        return appObj.getComponent(this.type);
-    }
     get default() {
         return this.memoizedDefault.val;
     }

package/lib/Components/Landmarks/UseCases/AddLandmarkUC.js

@@ -28,7 +28,7 @@ class AddLandmarkUCImp extends AddLandmarkUC {
             this.warn("Transform3D App Object has not been added. Add to the Transform3D App Object before Adding Landmark.");
             return;
         }
-        this.label = appObject.getComponent(Label_1.LabelEntity.type); // Not required
+        this.label = appObject.getComponent(Label_1.Label.type); // Not required
     }
     addFromData(data) {
         if (!this.landmarkRepo || !this.transform3D)

package/lib/Components/SceneRoot/Controllers/StylusMove.d.ts

@@ -0,0 +1,14 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectController } from "../../../AppObject/AppObjectController";
+import { ZSpaceStylusButton, ZSpaceStylusController } from "../../zSpace/Entities/ZSpaceStylusEntity";
+export declare class StylusMove extends AppObjectController implements ZSpaceStylusController {
+    static readonly type = "StylusMove";
+    private stylus?;
+    private stylusRootMovementUC?;
+    private isMoving;
+    allow: (button: ZSpaceStylusButton) => boolean;
+    onButtonDown: (button: ZSpaceStylusButton) => void;
+    onButtonUp: () => void;
+    onStylusMove: () => void;
+    constructor(appObject: AppObject);
+}

package/lib/Components/SceneRoot/Controllers/StylusMove.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StylusMove = void 0;
+const AppObjectController_1 = require("../../../AppObject/AppObjectController");
+const ZSpaceStylusEntity_1 = require("../../zSpace/Entities/ZSpaceStylusEntity");
+const StylusMoveTransformUC_1 = require("../../Transform3D/UC/StylusMoveTransformUC");
+const zSpace_1 = require("../../zSpace");
+class StylusMove extends AppObjectController_1.AppObjectController {
+    constructor(appObject) {
+        super(appObject, StylusMove.type);
+        this.isMoving = false;
+        this.allow = (button) => {
+            if (button === ZSpaceStylusEntity_1.ZSpaceStylusButton.PRIMARY)
+                return true;
+            return false;
+        };
+        this.onButtonDown = (button) => {
+            var _a;
+            this.isMoving = false;
+            if (!this.stylus)
+                return;
+            if (!this.allow(button))
+                return;
+            (_a = this.stylusRootMovementUC) === null || _a === void 0 ? void 0 : _a.initialize();
+            this.isMoving = true;
+        };
+        this.onButtonUp = () => {
+            var _a;
+            this.isMoving = true;
+            if (!this.stylus)
+                return;
+            (_a = this.stylusRootMovementUC) === null || _a === void 0 ? void 0 : _a.stop();
+        };
+        this.onStylusMove = () => {
+            var _a;
+            if (!this.stylus || !this.isMoving)
+                return;
+            (_a = this.stylusRootMovementUC) === null || _a === void 0 ? void 0 : _a.move();
+        };
+        const zSpaceEntity = zSpace_1.ZSpaceEntity.get(this.appObject.appObjectRepo);
+        if (!zSpaceEntity) {
+            this.warn("Unable to find ZSpaceEntity");
+            return;
+        }
+        this.stylus = zSpaceEntity.stylus;
+        this.stylusRootMovementUC = appObject.getComponent(StylusMoveTransformUC_1.StylusMoveTransformUC.type);
+        if (!this.stylusRootMovementUC) {
+            this.warn("StylusMoveSceneRoot has been added to an App Object that does not have a StylusMoveTransformUC");
+        }
+        else {
+            this.stylus.registerController(this);
+        }
+    }
+}
+exports.StylusMove = StylusMove;
+StylusMove.type = "StylusMove";

package/lib/Components/SceneRoot/Controllers/StylusScale.d.ts

@@ -0,0 +1,14 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectController } from "../../../AppObject/AppObjectController";
+import { ZSpaceStylusButton, ZSpaceStylusController } from "../../zSpace/Entities/ZSpaceStylusEntity";
+export declare class StylusScale extends AppObjectController implements ZSpaceStylusController {
+    static readonly type = "ZSpaceScaleRoot";
+    private stylus?;
+    private scaleSceneRootWithRay?;
+    private isScaling;
+    allow: (button: ZSpaceStylusButton) => boolean;
+    onButtonDown: (button: ZSpaceStylusButton) => void;
+    onStylusMove: () => void;
+    onButtonUp: () => void;
+    constructor(appObject: AppObject);
+}

package/lib/Components/SceneRoot/Controllers/StylusScale.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StylusScale = void 0;
+const AppObjectController_1 = require("../../../AppObject/AppObjectController");
+const ScaleSceneRootWithRay_1 = require("../UC/ScaleSceneRootWithRay");
+const ZSpaceStylusEntity_1 = require("../../zSpace/Entities/ZSpaceStylusEntity");
+const zSpace_1 = require("../../zSpace");
+class StylusScale extends AppObjectController_1.AppObjectController {
+    constructor(appObject) {
+        super(appObject, StylusScale.type);
+        this.isScaling = false;
+        this.allow = (button) => {
+            if (button === ZSpaceStylusEntity_1.ZSpaceStylusButton.BACK_RIGHT)
+                return true;
+            return false;
+        };
+        this.onButtonDown = (button) => {
+            var _a;
+            this.isScaling = false;
+            if (!this.stylus)
+                return;
+            if (!this.allow(button))
+                return;
+            const pointerRay = this.stylus.pickRay;
+            const rayStart = this.stylus.transform.localPosition;
+            (_a = this.scaleSceneRootWithRay) === null || _a === void 0 ? void 0 : _a.initializeScale(pointerRay, rayStart);
+            this.isScaling = true;
+        };
+        this.onStylusMove = () => {
+            var _a;
+            if (!this.stylus)
+                return;
+            if (!this.isScaling)
+                return;
+            const pointerRay = this.stylus.pickRay;
+            const rayStart = this.stylus.transform.localPosition;
+            (_a = this.scaleSceneRootWithRay) === null || _a === void 0 ? void 0 : _a.doScale(pointerRay, rayStart);
+        };
+        this.onButtonUp = () => {
+            this.isScaling = false;
+        };
+        const zSpaceEntity = zSpace_1.ZSpaceEntity.get(this.appObject.appObjectRepo);
+        if (!zSpaceEntity) {
+            this.warn("Unable to find ZSpaceEntity");
+            return;
+        }
+        this.stylus = zSpaceEntity.stylus;
+        this.scaleSceneRootWithRay = appObject.getComponent(ScaleSceneRootWithRay_1.ScaleSceneRootWithRay.type);
+        if (!this.scaleSceneRootWithRay) {
+            this.warn("StylusMoveSceneRoot has been added to an App Object that does not have a scaleSceneRootWithRay");
+        }
+        else {
+            this.stylus.registerController(this);
+        }
+    }
+}
+exports.StylusScale = StylusScale;
+StylusScale.type = "ZSpaceScaleRoot";

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

@@ -0,0 +1,11 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectController } from "../../../AppObject/AppObjectController";
+import { ZSpaceStylusController } from "../../zSpace/Entities/ZSpaceStylusEntity";
+export declare class StylusHoverOnAppObject extends AppObjectController implements ZSpaceStylusController {
+    static readonly type = "StylusHoverOnAppObject";
+    private stylus?;
+    private hoverUC?;
+    allow: () => boolean;
+    onStylusMove: () => void;
+    constructor(appObject: AppObject);
+}

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

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StylusHoverOnAppObject = void 0;
+const AppObjectController_1 = require("../../../AppObject/AppObjectController");
+const ZSpaceEntity_1 = require("../../zSpace/Entities/ZSpaceEntity");
+const HoverAppObjectUC_1 = require("../UC/HoverAppObjectUC");
+class StylusHoverOnAppObject extends AppObjectController_1.AppObjectController {
+    constructor(appObject) {
+        super(appObject, StylusHoverOnAppObject.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.tryHoverSceneObject(pointerRay);
+        };
+        const zSpaceEntity = ZSpaceEntity_1.ZSpaceEntity.get(this.appObjects);
+        if (!zSpaceEntity) {
+            this.warn("Unable to find ZSpaceEntity");
+            return;
+        }
+        this.stylus = zSpaceEntity.stylus;
+        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.StylusHoverOnAppObject = StylusHoverOnAppObject;
+StylusHoverOnAppObject.type = "StylusHoverOnAppObject";

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

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