@vived/app 3.9.1 → 4.0.0

package/lib/Components/XR/Mocks/MockXRSession.d.ts

@@ -0,0 +1,28 @@
+/// <reference types="webxr" />
+/// <reference types="jest" />
+export declare class MockXRSession implements XRSession {
+    inputSources: XRInputSourceArray;
+    renderState: XRRenderState;
+    environmentBlendMode: XREnvironmentBlendMode;
+    visibilityState: XRVisibilityState;
+    isSystemKeyboardSupported: boolean;
+    cancelAnimationFrame(id: number): void;
+    end(): Promise<void>;
+    requestAnimationFrame(callback: XRFrameRequestCallback): number;
+    requestReferenceSpace(type: XRReferenceSpaceType): Promise<XRReferenceSpace | XRBoundedReferenceSpace>;
+    updateRenderState(renderStateInit?: XRRenderStateInit): Promise<void>;
+    updateTargetFrameRate(rate: number): Promise<void>;
+    onend: jest.Mock<any, any>;
+    oninputsourceschange: jest.Mock<any, any>;
+    onselect: jest.Mock<any, any>;
+    onselectstart: jest.Mock<any, any>;
+    onselectend: jest.Mock<any, any>;
+    onsqueeze: jest.Mock<any, any>;
+    onsqueezestart: jest.Mock<any, any>;
+    onsqueezeend: jest.Mock<any, any>;
+    onvisibilitychange: jest.Mock<any, any>;
+    onframeratechange: jest.Mock<any, any>;
+    addEventListener: jest.Mock<any, any>;
+    removeEventListener: jest.Mock<any, any>;
+    dispatchEvent(event: Event): boolean;
+}

package/lib/Components/XR/Mocks/MockXRSession.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockXRSession = void 0;
+class MockXRSession {
+    constructor() {
+        this.inputSources = [];
+        this.renderState = {
+            depthFar: 0,
+            depthNear: 0,
+        };
+        this.environmentBlendMode = "additive";
+        this.visibilityState = "hidden";
+        this.isSystemKeyboardSupported = true;
+        this.onend = jest.fn();
+        this.oninputsourceschange = jest.fn();
+        this.onselect = jest.fn();
+        this.onselectstart = jest.fn();
+        this.onselectend = jest.fn();
+        this.onsqueeze = jest.fn();
+        this.onsqueezestart = jest.fn();
+        this.onsqueezeend = jest.fn();
+        this.onvisibilitychange = jest.fn();
+        this.onframeratechange = jest.fn();
+        this.addEventListener = jest.fn();
+        this.removeEventListener = jest.fn();
+    }
+    cancelAnimationFrame(id) {
+        throw new Error("Method not implemented.");
+    }
+    end() {
+        throw new Error("Method not implemented.");
+    }
+    requestAnimationFrame(callback) {
+        throw new Error("Method not implemented.");
+    }
+    requestReferenceSpace(type) {
+        throw new Error("Method not implemented.");
+    }
+    updateRenderState(renderStateInit) {
+        throw new Error("Method not implemented.");
+    }
+    updateTargetFrameRate(rate) {
+        throw new Error("Method not implemented.");
+    }
+    dispatchEvent(event) {
+        throw new Error("Method not implemented.");
+    }
+}
+exports.MockXRSession = MockXRSession;

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

@@ -0,0 +1,2 @@
+export * from "./MockRenderToXR";
+export * from "./MockXRSession";

package/lib/Components/XR/Mocks/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("./MockRenderToXR"), exports);
+__exportStar(require("./MockXRSession"), exports);

package/lib/Components/XR/UC/index.d.ts

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

package/lib/Components/XR/UC/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("./RenderToXR"), exports);

package/lib/Components/XR/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./Entity";
+export * from "./UC";

package/lib/Components/XR/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("./Entity"), exports);
+__exportStar(require("./UC"), exports);

package/lib/Components/index.d.ts

@@ -0,0 +1,25 @@
+export * from "./App";
+export * from "./Babylon";
+export * from "./Camera";
+export * from "./ChannelModel";
+export * from "./Dispatcher";
+export * from "./Enablement";
+export * from "./FramedScreen";
+export * from "./Hideable";
+export * from "./KeyboardInput";
+export * from "./Label";
+export * from "./Mesh";
+export * from "./MouseInput";
+export * from "./OverlayColor";
+export * from "./Question";
+export * from "./RequestHandler";
+export * from "./SceneRoot";
+export * from "./StateMachine";
+export * from "./ThemeColors";
+export * from "./StoredView";
+export * from "./Tools";
+export * from "./TouchController";
+export * from "./Transform3D";
+export * from "./UndoRedo";
+export * from "./XR";
+export * from "./zSpace";

package/lib/Components/index.js

@@ -0,0 +1,37 @@
+"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("./App"), exports);
+__exportStar(require("./Babylon"), exports);
+__exportStar(require("./Camera"), exports);
+__exportStar(require("./ChannelModel"), exports);
+__exportStar(require("./Dispatcher"), exports);
+__exportStar(require("./Enablement"), exports);
+__exportStar(require("./FramedScreen"), exports);
+__exportStar(require("./Hideable"), exports);
+__exportStar(require("./KeyboardInput"), exports);
+__exportStar(require("./Label"), exports);
+__exportStar(require("./Mesh"), exports);
+__exportStar(require("./MouseInput"), exports);
+__exportStar(require("./OverlayColor"), exports);
+__exportStar(require("./Question"), exports);
+__exportStar(require("./RequestHandler"), exports);
+__exportStar(require("./SceneRoot"), exports);
+__exportStar(require("./StateMachine"), exports);
+__exportStar(require("./ThemeColors"), exports);
+__exportStar(require("./StoredView"), exports);
+__exportStar(require("./Tools"), exports);
+__exportStar(require("./TouchController"), exports);
+__exportStar(require("./Transform3D"), exports);
+__exportStar(require("./UndoRedo"), exports);
+__exportStar(require("./XR"), exports);
+__exportStar(require("./zSpace"), exports);

package/lib/Components/zSpace/Controllers/EmulateStylus.d.ts

@@ -0,0 +1,9 @@
+import { AppObject, AppObjectController } from "../../../AppObject";
+import { MouseController, MouseInputEvent } from "../../MouseInput";
+export default abstract class EmulateZSpaceStylus extends AppObjectController implements MouseController {
+    static readonly type = "EmulateZSpaceStylus";
+    abstract onDown: (e: MouseInputEvent) => void;
+    abstract onMove: (e: MouseInputEvent) => void;
+    abstract onUp: (e: MouseInputEvent) => void;
+}
+export declare function makeEmulateZSpaceStylus(appObject: AppObject): EmulateZSpaceStylus;

package/lib/Components/zSpace/Controllers/EmulateStylus.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeEmulateZSpaceStylus = void 0;
+const AppObject_1 = require("../../../AppObject");
+const ValueObjects_1 = require("../../../ValueObjects");
+const Babylon_1 = require("../../Babylon");
+const MouseInput_1 = require("../../MouseInput");
+const Entities_1 = require("../Entities/");
+const PM_1 = require("../PM");
+class EmulateZSpaceStylus extends AppObject_1.AppObjectController {
+}
+exports.default = EmulateZSpaceStylus;
+EmulateZSpaceStylus.type = "EmulateZSpaceStylus";
+function makeEmulateZSpaceStylus(appObject) {
+    return new EmulateZSpaceStylusImp(appObject);
+}
+exports.makeEmulateZSpaceStylus = makeEmulateZSpaceStylus;
+class EmulateZSpaceStylusImp extends EmulateZSpaceStylus {
+    constructor(appObject) {
+        super(appObject, EmulateZSpaceStylus.type);
+        this.emulationIsActive = false;
+        this.screenPlane = ValueObjects_1.ParametricPlane.FromPointNormal(ValueObjects_1.Vector3.Zero(), ValueObjects_1.Vector3.Backward());
+        this.onDown = (e) => {
+            if (!this.emulationIsActive)
+                return;
+            if (!this.stylus)
+                return;
+            this.stylus.updateButtonState(e.button, true);
+        };
+        this.onMove = (e) => {
+            if (!this.emulationIsActive)
+                return;
+            if (!this.stylusTransform)
+                return;
+            const ray = this.pixelToSceneRay(e.position);
+            const hit = this.screenPlane.intersectLine(ray);
+            if (!hit) {
+                return;
+            }
+            const direction = ValueObjects_1.Vector3.Subtract(hit, this.stylusTransform.localPosition);
+            this.stylusTransform.localRotation = ValueObjects_1.Quaternion.FromDirectionVector(direction);
+        };
+        this.onUp = (e) => {
+            if (!this.emulationIsActive)
+                return;
+            if (!this.stylus)
+                return;
+            this.stylus.updateButtonState(e.button, false);
+        };
+        this.onZpsaceEnabledChange = (enabled) => {
+            this.emulationIsActive = false;
+            if (!enabled)
+                return;
+            if (!this.zSpaceEntity)
+                return;
+            if (!this.zSpaceEntity.emulate)
+                return;
+            this.emulationIsActive = true;
+            if (this.stylusTransform) {
+                this.stylusTransform.localPosition = new ValueObjects_1.Vector3(0.05, -0.05, -0.5);
+            }
+        };
+        this.zSpaceEntity = Entities_1.ZSpaceEntity.get(this.appObjects);
+        if (!this.zSpaceEntity) {
+            this.warn("Unable to find ZSpaceEntity");
+            return;
+        }
+        const pm = this.zSpaceEntity.appObject.getComponent(PM_1.ZSpaceIsEnabledPM.type);
+        if (!pm) {
+            this.warn("Unable to find ZSpaceIsEnabledPM");
+            return;
+        }
+        this.stylus = appObject.getComponent(Entities_1.ZSpaceStylusEntity.type);
+        if (!this.stylus) {
+            this.warn("Controller has been added to an app object that does not have a ZSpaceStylusEntity");
+            return;
+        }
+        this.stylusTransform = this.stylus.transform;
+        const mouseInput = MouseInput_1.MouseInputEntity.get(appObject.appObjectRepo);
+        if (mouseInput) {
+            mouseInput.registerController(this);
+        }
+        else {
+            this.warn("Unable to find MouseInputEntity");
+            return;
+        }
+        mouseInput.registerController(this);
+        pm.addView(this.onZpsaceEnabledChange);
+    }
+    pixelToSceneRay(pixelPos) {
+        if (!this.pixelToSceneRayUC) {
+            this.pixelToSceneRayUC = Babylon_1.PixelToSceneRayUC.get(this.appObjects);
+            if (!this.pixelToSceneRayUC) {
+                this.warn("Unable to find PixelToSceneRayUC");
+                return ValueObjects_1.ParametricLine.Forward();
+            }
+        }
+        return this.pixelToSceneRayUC.pixelToSceneRay(pixelPos);
+    }
+}

package/lib/Components/zSpace/Controllers/ZSpaceScaleRoot.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZSpaceScaleRoot = void 0;
+const AppObjectController_1 = require("../../../AppObject/AppObjectController");
+const SceneRoot_1 = require("../../SceneRoot");
+const ScaleSceneRootWithRay_1 = require("../../SceneRoot/UC/ScaleSceneRootWithRay");
+const ZSpaceStylusEntity_1 = require("../Entities/ZSpaceStylusEntity");
+class ZSpaceScaleRoot extends AppObjectController_1.AppObjectController {
+    constructor(appObject) {
+        super(appObject, ZSpaceScaleRoot.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;
+        };
+        this.stylus = appObject.getComponent(ZSpaceStylusEntity_1.ZSpaceStylusEntity.type);
+        const sceneRoot = SceneRoot_1.SceneRootEntity.get(appObject.appObjectRepo);
+        this.scaleSceneRootWithRay = sceneRoot === null || sceneRoot === void 0 ? void 0 : sceneRoot.appObject.getComponent(ScaleSceneRootWithRay_1.ScaleSceneRootWithRay.type);
+        if (!this.stylus) {
+            this.warn("StylusInputPointer Controller has been added to an app object that does not have a ZSpaceStylusEntity");
+        }
+        else if (!this.scaleSceneRootWithRay) {
+            this.warn("StylusRootScaleSceneRootWithRay was not found on the Scene Root App Object");
+        }
+        else {
+            this.stylus.registerController(this);
+        }
+    }
+}
+exports.ZSpaceScaleRoot = ZSpaceScaleRoot;
+ZSpaceScaleRoot.type = "ZSpaceScaleRoot";

package/lib/Components/zSpace/Controllers/index.d.ts

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

package/lib/Components/zSpace/Controllers/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("./EmulateStylus"), exports);

package/lib/Components/zSpace/Entities/ZSpaceDisplayEntity.d.ts

@@ -0,0 +1,22 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectEntity } from "../../../AppObject/AppObjectEntity";
+import { Vector2 } from "../../../ValueObjects";
+import { Transform3D } from "../../Transform3D";
+export declare enum ZSpaceDevice {
+    MAKO = "MAKO",
+    INSPIRE = "INSPIRE",
+    AIO = "AIO"
+}
+export declare abstract class ZSpaceDisplayEntity extends AppObjectEntity {
+    static readonly type = "ZSpaceDisplayEntity";
+    abstract readonly transform: Transform3D;
+    abstract get displaySizeMeters(): Vector2;
+    abstract set displaySizeMeters(val: Vector2);
+    abstract get displaySizePixels(): Vector2;
+    abstract set displaySizePixels(val: Vector2);
+    abstract get metersPerPixel(): number;
+    abstract get pixelPerMeter(): number;
+    abstract setForDevice(device: ZSpaceDevice): void;
+    abstract setForSize(width: number, height: number): void;
+}
+export declare function makeZSpaceDisplayEntity(appObj: AppObject): ZSpaceDisplayEntity;

package/lib/Components/zSpace/Entities/ZSpaceDisplayEntity.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeZSpaceDisplayEntity = exports.ZSpaceDisplayEntity = exports.ZSpaceDevice = void 0;
+const AppObjectEntity_1 = require("../../../AppObject/AppObjectEntity");
+const Entities_1 = require("../../../Entities");
+const ValueObjects_1 = require("../../../ValueObjects");
+const Transform3D_1 = require("../../Transform3D");
+var ZSpaceDevice;
+(function (ZSpaceDevice) {
+    ZSpaceDevice["MAKO"] = "MAKO";
+    ZSpaceDevice["INSPIRE"] = "INSPIRE";
+    ZSpaceDevice["AIO"] = "AIO";
+})(ZSpaceDevice = exports.ZSpaceDevice || (exports.ZSpaceDevice = {}));
+class ZSpaceDisplayEntity extends AppObjectEntity_1.AppObjectEntity {
+}
+exports.ZSpaceDisplayEntity = ZSpaceDisplayEntity;
+ZSpaceDisplayEntity.type = "ZSpaceDisplayEntity";
+function makeZSpaceDisplayEntity(appObj) {
+    return new ZSpaceDisplayEntityImp(appObj);
+}
+exports.makeZSpaceDisplayEntity = makeZSpaceDisplayEntity;
+class ZSpaceDisplayEntityImp extends ZSpaceDisplayEntity {
+    constructor(appObject) {
+        super(appObject, ZSpaceDisplayEntity.type);
+        this.memoizedSizeMeters = new Entities_1.MemoizedVector2(ValueObjects_1.Vector2.One(), this.notifyOnChange);
+        this.memoizedSizePixels = new Entities_1.MemoizedVector2(ValueObjects_1.Vector2.One(), this.notifyOnChange);
+        this.transform = Transform3D_1.Transform3D.addIfMissing(appObject);
+    }
+    get displaySizeMeters() {
+        return this.memoizedSizeMeters.val;
+    }
+    set displaySizeMeters(val) {
+        this.memoizedSizeMeters.val = val;
+    }
+    get displaySizePixels() {
+        return this.memoizedSizePixels.val;
+    }
+    set displaySizePixels(val) {
+        this.memoizedSizePixels.val = val;
+    }
+    get metersPerPixel() {
+        if (this.memoizedSizePixels.val.x === 0)
+            return 0;
+        return this.memoizedSizeMeters.val.x / this.memoizedSizePixels.val.x;
+    }
+    get pixelPerMeter() {
+        if (this.memoizedSizeMeters.val.x === 0)
+            return 0;
+        return this.memoizedSizePixels.val.x / this.memoizedSizeMeters.val.x;
+    }
+    setForDevice(device) {
+        if (device === ZSpaceDevice.AIO) {
+            this.displaySizeMeters = new ValueObjects_1.Vector2(0.521, 0.293);
+        }
+        else {
+            this.displaySizeMeters = new ValueObjects_1.Vector2(0.344, 0.193);
+        }
+        this.displaySizePixels = new ValueObjects_1.Vector2(1920, 1080);
+    }
+    setForSize(width, height) {
+        this.displaySizeMeters = new ValueObjects_1.Vector2(width, height);
+        this.displaySizePixels = new ValueObjects_1.Vector2(1920, 1080);
+    }
+}

package/lib/Components/zSpace/Entities/ZSpaceEntity.d.ts

@@ -0,0 +1,26 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectEntity } from "../../../AppObject/AppObjectEntity";
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+import { ZSpaceDisplayEntity } from "./ZSpaceDisplayEntity";
+import { ZSpaceStylusEntity } from "./ZSpaceStylusEntity";
+import { ZSpaceViewEntity } from "./ZSpaceViewEntity";
+export declare const INSPIRE_WIDTH: number;
+export declare abstract class ZSpaceEntity extends AppObjectEntity {
+    static readonly type = "ZSpaceEntity";
+    abstract get isSupported(): boolean;
+    abstract set isSupported(val: boolean);
+    abstract get enabled(): boolean;
+    abstract set enabled(val: boolean);
+    abstract get emulate(): boolean;
+    abstract set emulate(val: boolean);
+    abstract get viewerScale(): number;
+    abstract set viewerScale(val: number);
+    abstract readonly stylus: ZSpaceStylusEntity;
+    abstract readonly headView: ZSpaceViewEntity;
+    abstract readonly leftEyeView: ZSpaceViewEntity;
+    abstract readonly rightEyeView: ZSpaceViewEntity;
+    abstract readonly display: ZSpaceDisplayEntity;
+    static get(appObjects: AppObjectRepo): ZSpaceEntity | undefined;
+}
+export declare function makeZSpaceEntity(appObj: AppObject): ZSpaceEntity;
+export declare const tempScaleCoef: number;

package/lib/Components/zSpace/Entities/ZSpaceEntity.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tempScaleCoef = exports.makeZSpaceEntity = exports.ZSpaceEntity = exports.INSPIRE_WIDTH = void 0;
+const AppObjectEntity_1 = require("../../../AppObject/AppObjectEntity");
+const Entities_1 = require("../../../Entities");
+const ZSpaceDisplayEntity_1 = require("./ZSpaceDisplayEntity");
+const ZSpaceStylusEntity_1 = require("./ZSpaceStylusEntity");
+const ZSpaceViewEntity_1 = require("./ZSpaceViewEntity");
+exports.INSPIRE_WIDTH = 0.344;
+class ZSpaceEntity extends AppObjectEntity_1.AppObjectEntity {
+    static get(appObjects) {
+        const selectionEntities = appObjects.getAllComponents(ZSpaceEntity.type);
+        if (selectionEntities.length === 0) {
+            console.warn("Unable to find a ZSpaceEntity. Add one on Mount");
+            return undefined;
+        }
+        else if (selectionEntities.length > 1) {
+            console.warn("Many ZSpaceEntity have been found. There should only be one. Using the first one");
+        }
+        return selectionEntities[0];
+    }
+}
+exports.ZSpaceEntity = ZSpaceEntity;
+ZSpaceEntity.type = "ZSpaceEntity";
+function makeZSpaceEntity(appObj) {
+    return new ZSpaceImp(appObj);
+}
+exports.makeZSpaceEntity = makeZSpaceEntity;
+exports.tempScaleCoef = 1; // 1 for Inspire, 1.52 for AIO
+class ZSpaceImp extends ZSpaceEntity {
+    constructor(appObj) {
+        super(appObj, ZSpaceEntity.type);
+        this.memoizedViewerScale = new Entities_1.MemoizedNumber(1, this.notifyOnChange); // 1 for Inspire, .65 for AIO
+        this.memoizedIsSupported = new Entities_1.MemoizedBoolean(false, this.notifyOnChange);
+        this.memoizedEnabled = new Entities_1.MemoizedBoolean(false, this.notifyOnChange);
+        this.memoizedEmulate = new Entities_1.MemoizedBoolean(false, this.notifyOnChange);
+        this.memoizedIsRendering = new Entities_1.MemoizedBoolean(false, this.notifyOnChange);
+        const headView = appObj.appObjectRepo.getOrCreate("zSpaceHeadView");
+        this.headView = ZSpaceViewEntity_1.makeZSpaceView(headView, ZSpaceViewEntity_1.ZSpaceViewType.CENTER);
+        const leftEye = appObj.appObjectRepo.getOrCreate("zSpaceLeftEyeView");
+        this.leftEyeView = ZSpaceViewEntity_1.makeZSpaceView(leftEye, ZSpaceViewEntity_1.ZSpaceViewType.LEFT);
+        const rightEye = appObj.appObjectRepo.getOrCreate("zSpaceRightEyeView");
+        this.rightEyeView = ZSpaceViewEntity_1.makeZSpaceView(rightEye, ZSpaceViewEntity_1.ZSpaceViewType.RIGHT);
+        const stylusAO = appObj.appObjectRepo.getOrCreate("zSpaceStylus");
+        this.stylus = ZSpaceStylusEntity_1.makeZSpaceStylus(stylusAO);
+        const displayAO = appObj.appObjectRepo.getOrCreate("zSpaceDisplay");
+        this.display = ZSpaceDisplayEntity_1.makeZSpaceDisplayEntity(displayAO);
+    }
+    get viewerScale() {
+        return this.memoizedViewerScale.val;
+    }
+    set viewerScale(val) {
+        this.memoizedViewerScale.val = val;
+    }
+    get isSupported() {
+        return this.memoizedIsSupported.val;
+    }
+    set isSupported(val) {
+        this.memoizedIsSupported.val = val;
+    }
+    get enabled() {
+        return this.memoizedEnabled.val;
+    }
+    set enabled(val) {
+        this.memoizedEnabled.val = val;
+    }
+    get emulate() {
+        return this.memoizedEmulate.val;
+    }
+    set emulate(val) {
+        this.memoizedEmulate.val = val;
+    }
+    get isRendering() {
+        return this.memoizedIsRendering.val;
+    }
+    set isRendering(val) {
+        this.memoizedIsRendering.val = val;
+    }
+}

package/lib/Components/zSpace/Entities/ZSpaceStylusEntity.d.ts

@@ -0,0 +1,27 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectEntity } from "../../../AppObject/AppObjectEntity";
+import { ParametricLine } from "../../../ValueObjects";
+import { Transform3D } from "../../Transform3D";
+export declare enum ZSpaceStylusButton {
+    PRIMARY = 0,
+    BACK_RIGHT = 1,
+    BACK_LEFT = 2
+}
+export interface ZSpaceStylusController {
+    onButtonDown?: (button: ZSpaceStylusButton) => void;
+    onButtonUp?: (button: ZSpaceStylusButton) => void;
+    onButtonClick?: (button: ZSpaceStylusButton) => void;
+    onStylusMove?: (transform: Transform3D) => void;
+}
+export declare abstract class ZSpaceStylusEntity extends AppObjectEntity {
+    static readonly type = "ZSpaceStylusEntity";
+    static clickMovementThreshold: number;
+    static clickTimeThresholdMS: number;
+    abstract registerController: (controller: ZSpaceStylusController) => void;
+    abstract updateButtonState: (button: ZSpaceStylusButton, isPressed: boolean) => void;
+    abstract readonly transform: Transform3D;
+    abstract readonly helperTransform: Transform3D;
+    abstract get pickRay(): ParametricLine;
+    abstract get isInUse(): boolean;
+}
+export declare function makeZSpaceStylus(appObj: AppObject): ZSpaceStylusEntity;