@vived/app 3.8.0 → 3.9.1

package/lib/AppObjectComponents/TouchController/Mock/MockTouchInput.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockTouchInputEntity = void 0;
+const TouchInput_1 = require("../Entities/TouchInput");
+class MockTouchInputEntity extends TouchInput_1.TouchInputEntity {
+    constructor(appObject) {
+        super(appObject, TouchInput_1.TouchInputEntity.type);
+        this.setEventElement = jest.fn();
+        this.clearInputElement = jest.fn();
+        this.updateInputElementBounds = jest.fn();
+        this.registerController = jest.fn();
+        this.removeController = jest.fn();
+    }
+    get eventElement() {
+        return undefined;
+    }
+}
+exports.MockTouchInputEntity = MockTouchInputEntity;

package/lib/AppObjectComponents/TouchController/Mock/mockTouchInputEvent.d.ts

@@ -0,0 +1,3 @@
+import { Vector2 } from "../../../ValueObjects";
+import { TouchInputEvent } from "../Entities/TouchInput";
+export declare function mockTouchInputEvent(touchPositions: Vector2[]): TouchInputEvent;

package/lib/AppObjectComponents/TouchController/Mock/mockTouchInputEvent.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mockTouchInputEvent = void 0;
+const ValueObjects_1 = require("../../../ValueObjects");
+function mockTouchInputEvent(touchPositions) {
+    const mockEvt = new TouchEvent("");
+    const touchCount = touchPositions.length;
+    let sumPos = ValueObjects_1.Vector2.Zero();
+    const touches = touchPositions.map((pos, i) => {
+        sumPos = ValueObjects_1.Vector2.Add(sumPos, pos);
+        return {
+            id: i,
+            position: pos,
+        };
+    });
+    const avgPos = touchCount === 0
+        ? ValueObjects_1.Vector2.Zero()
+        : new ValueObjects_1.Vector2(sumPos.x / touchCount, sumPos.y / touchCount);
+    return {
+        event: mockEvt,
+        touchCenter: avgPos,
+        touchCount,
+        touches,
+    };
+}
+exports.mockTouchInputEvent = mockTouchInputEvent;

package/lib/AppObjectComponents/TouchController/index.d.ts

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

package/lib/AppObjectComponents/TouchController/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("./Entities/TouchInput"), exports);

package/lib/AppObjectComponents/UndoRedo/Controllers/clearUndoStack.d.ts

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

package/lib/AppObjectComponents/UndoRedo/Controllers/clearUndoStack.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearUndoStack = void 0;
+const App_1 = require("../../App");
+const UndoRedoEntity_1 = require("../Entities/UndoRedoEntity");
+function clearUndoStack(appObjects) {
+    const undoRedoEntity = UndoRedoEntity_1.UndoRedoEntity.get(appObjects);
+    if (!undoRedoEntity) {
+        App_1.submitWarning("clearUndoStack", "Unable to find UndoRedoEntity", appObjects);
+        return;
+    }
+    undoRedoEntity.clearStack();
+}
+exports.clearUndoStack = clearUndoStack;

package/lib/AppObjectComponents/UndoRedo/Controllers/doRedo.d.ts

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

package/lib/AppObjectComponents/UndoRedo/Controllers/doRedo.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.doRedo = void 0;
+const App_1 = require("../../App");
+const UndoRedoEntity_1 = require("../Entities/UndoRedoEntity");
+function doRedo(appObjects) {
+    const undoRedoEntity = UndoRedoEntity_1.UndoRedoEntity.get(appObjects);
+    if (!undoRedoEntity) {
+        App_1.submitWarning("doRedo", "Unable to find UndoRedoEntity", appObjects);
+        return;
+    }
+    undoRedoEntity.doRedo();
+}
+exports.doRedo = doRedo;

package/lib/AppObjectComponents/UndoRedo/Controllers/doUndo.d.ts

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

package/lib/AppObjectComponents/UndoRedo/Controllers/doUndo.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.doUndo = void 0;
+const App_1 = require("../../App");
+const UndoRedoEntity_1 = require("../Entities/UndoRedoEntity");
+function doUndo(appObjects) {
+    const undoRedoEntity = UndoRedoEntity_1.UndoRedoEntity.get(appObjects);
+    if (!undoRedoEntity) {
+        App_1.submitWarning("doUndo", "Unable to find UndoRedoEntity", appObjects);
+        return;
+    }
+    undoRedoEntity.doUndo();
+}
+exports.doUndo = doUndo;

package/lib/AppObjectComponents/UndoRedo/Entities/UndoRedoEntity.d.ts

@@ -0,0 +1,31 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectEntity } from "../../../AppObject/AppObjectEntity";
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+export interface UndoRedoAction {
+    undoAction: () => void;
+    redoAction: () => void;
+}
+export declare abstract class UndoRedoEntity extends AppObjectEntity {
+    static readonly type = "UndoRedoEntity";
+    abstract get hasUndo(): boolean;
+    abstract get hasRedo(): boolean;
+    abstract submitAction: (action: UndoRedoAction) => void;
+    abstract doUndo: () => void;
+    abstract doRedo: () => void;
+    abstract clearStack: () => void;
+    static get(appObjects: AppObjectRepo): UndoRedoEntity | undefined;
+}
+export declare function makeUndoRedoEntity(appObject: AppObject): UndoRedoEntityImp;
+export declare function submitUndoRedoAction(action: UndoRedoAction, appObjects: AppObjectRepo): void;
+declare class UndoRedoEntityImp extends UndoRedoEntity {
+    private undoStack;
+    private redoStack;
+    get hasUndo(): boolean;
+    get hasRedo(): boolean;
+    doUndo: () => void;
+    doRedo: () => void;
+    submitAction: (action: UndoRedoAction) => void;
+    clearStack: () => void;
+    constructor(appObject: AppObject);
+}
+export {};

package/lib/AppObjectComponents/UndoRedo/Entities/UndoRedoEntity.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.submitUndoRedoAction = exports.makeUndoRedoEntity = exports.UndoRedoEntity = void 0;
+const AppObjectEntity_1 = require("../../../AppObject/AppObjectEntity");
+const App_1 = require("../../App");
+class UndoRedoEntity extends AppObjectEntity_1.AppObjectEntity {
+    static get(appObjects) {
+        const components = appObjects.getAllComponents(UndoRedoEntity.type);
+        if (components.length === 0) {
+            App_1.submitWarning("UndoRedoEntity", `Unable to find component ${UndoRedoEntity.type}. Add one on Mount`, appObjects);
+            return undefined;
+        }
+        else if (components.length > 1) {
+            App_1.submitWarning("UndoRedoEntity", `Multiple ${UndoRedoEntity.type} found. There should only be one. Using the first one`, appObjects);
+        }
+        return components[0];
+    }
+}
+exports.UndoRedoEntity = UndoRedoEntity;
+UndoRedoEntity.type = "UndoRedoEntity";
+function makeUndoRedoEntity(appObject) {
+    return new UndoRedoEntityImp(appObject);
+}
+exports.makeUndoRedoEntity = makeUndoRedoEntity;
+function submitUndoRedoAction(action, appObjects) {
+    const undoRedoEntity = UndoRedoEntity.get(appObjects);
+    if (!undoRedoEntity) {
+        App_1.submitWarning("submitUndoRedoAction", "Unable to find UndoRedoEntity", appObjects);
+        return;
+    }
+    undoRedoEntity.submitAction(action);
+}
+exports.submitUndoRedoAction = submitUndoRedoAction;
+class UndoRedoEntityImp extends UndoRedoEntity {
+    constructor(appObject) {
+        super(appObject, UndoRedoEntity.type);
+        this.undoStack = [];
+        this.redoStack = [];
+        this.doUndo = () => {
+            const action = this.undoStack.pop();
+            if (!action) {
+                App_1.submitWarning("UndoRedoEntityImp", "Nothing to undo", this.appObject.appObjectRepo);
+                return;
+            }
+            action.undoAction();
+            this.redoStack.push(action);
+            this.notifyOnChange();
+        };
+        this.doRedo = () => {
+            const action = this.redoStack.pop();
+            if (!action) {
+                App_1.submitWarning("UndoRedoEntityImp", "Nothing to redo", this.appObject.appObjectRepo);
+                return;
+            }
+            action.redoAction();
+            this.undoStack.push(action);
+            this.notifyOnChange();
+        };
+        this.submitAction = (action) => {
+            this.undoStack.push(action);
+            this.redoStack = [];
+            this.notifyOnChange();
+        };
+        this.clearStack = () => {
+            this.redoStack = [];
+            this.undoStack = [];
+            this.notifyOnChange();
+        };
+    }
+    get hasUndo() {
+        return this.undoStack.length > 0;
+    }
+    get hasRedo() {
+        return this.redoStack.length > 0;
+    }
+}

package/lib/AppObjectComponents/UndoRedo/Factories/setupUndo.d.ts

@@ -0,0 +1,3 @@
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+import { UndoRedoEntity } from "../Entities/UndoRedoEntity";
+export declare function setupUndo(appObjects: AppObjectRepo): UndoRedoEntity;

package/lib/AppObjectComponents/UndoRedo/Factories/setupUndo.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupUndo = void 0;
+const UndoRedoEntity_1 = require("../Entities/UndoRedoEntity");
+const HasRedoPM_1 = require("../PresentationManager/HasRedoPM");
+const HasUndoPM_1 = require("../PresentationManager/HasUndoPM");
+function setupUndo(appObjects) {
+    const ao = appObjects.getOrCreate("UndoRedo");
+    const undoRedo = UndoRedoEntity_1.makeUndoRedoEntity(ao);
+    new HasRedoPM_1.HasRedoPM(ao);
+    new HasUndoPM_1.HasUndoPM(ao);
+    return undoRedo;
+}
+exports.setupUndo = setupUndo;

package/lib/AppObjectComponents/UndoRedo/PresentationManager/HasRedoPM.d.ts

@@ -0,0 +1,12 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectPM } from "../../../AppObject/AppObjectPM";
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+export declare class HasRedoPM extends AppObjectPM<boolean> {
+    static readonly type = "HasRedoPM";
+    private undoRedoEntity?;
+    static get(appObjects: AppObjectRepo): HasRedoPM | undefined;
+    vmsAreEqual(a: boolean, b: boolean): boolean;
+    dispose: () => void;
+    private onEntityChange;
+    constructor(appObject: AppObject);
+}

package/lib/AppObjectComponents/UndoRedo/PresentationManager/HasRedoPM.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HasRedoPM = void 0;
+const AppObjectPM_1 = require("../../../AppObject/AppObjectPM");
+const App_1 = require("../../App");
+const UndoRedoEntity_1 = require("../Entities/UndoRedoEntity");
+class HasRedoPM extends AppObjectPM_1.AppObjectPM {
+    constructor(appObject) {
+        super(appObject, HasRedoPM.type);
+        this.dispose = () => {
+            var _a;
+            super.dispose();
+            (_a = this.undoRedoEntity) === null || _a === void 0 ? void 0 : _a.removeChangeObserver(this.onEntityChange);
+        };
+        this.onEntityChange = () => {
+            if (!this.undoRedoEntity)
+                return;
+            this.doUpdateView(this.undoRedoEntity.hasRedo);
+        };
+        this.undoRedoEntity = appObject.getComponent(UndoRedoEntity_1.UndoRedoEntity.type);
+        if (this.undoRedoEntity) {
+            this.undoRedoEntity.addChangeObserver(this.onEntityChange);
+            this.onEntityChange();
+        }
+        else {
+            App_1.submitWarning("HasRedoPM", "HasRedoPM has been added to an app object that does not have UndoRedoEntity", appObject.appObjectRepo);
+        }
+    }
+    static get(appObjects) {
+        const components = appObjects.getAllComponents(HasRedoPM.type);
+        if (components.length === 0) {
+            App_1.submitWarning("HasRedoPM", `Unable to find component ${HasRedoPM.type}. Add one on Mount`, appObjects);
+            return undefined;
+        }
+        else if (components.length > 1) {
+            App_1.submitWarning("HasRedoPM", `Multiple ${HasRedoPM.type} found. There should only be one. Using the first one`, appObjects);
+        }
+        return components[0];
+    }
+    vmsAreEqual(a, b) {
+        return a === b;
+    }
+}
+exports.HasRedoPM = HasRedoPM;
+HasRedoPM.type = "HasRedoPM";

package/lib/AppObjectComponents/UndoRedo/PresentationManager/HasUndoPM.d.ts

@@ -0,0 +1,12 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectPM } from "../../../AppObject/AppObjectPM";
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+export declare class HasUndoPM extends AppObjectPM<boolean> {
+    static readonly type = "HasUndoPM";
+    private undoRedoEntity?;
+    static get(appObjects: AppObjectRepo): HasUndoPM | undefined;
+    vmsAreEqual(a: boolean, b: boolean): boolean;
+    dispose: () => void;
+    private onEntityChange;
+    constructor(appObject: AppObject);
+}

package/lib/AppObjectComponents/UndoRedo/PresentationManager/HasUndoPM.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HasUndoPM = void 0;
+const AppObjectPM_1 = require("../../../AppObject/AppObjectPM");
+const App_1 = require("../../App");
+const UndoRedoEntity_1 = require("../Entities/UndoRedoEntity");
+class HasUndoPM extends AppObjectPM_1.AppObjectPM {
+    constructor(appObject) {
+        super(appObject, HasUndoPM.type);
+        this.dispose = () => {
+            var _a;
+            super.dispose();
+            (_a = this.undoRedoEntity) === null || _a === void 0 ? void 0 : _a.removeChangeObserver(this.onEntityChange);
+        };
+        this.onEntityChange = () => {
+            if (!this.undoRedoEntity)
+                return;
+            this.doUpdateView(this.undoRedoEntity.hasUndo);
+        };
+        this.undoRedoEntity = appObject.getComponent(UndoRedoEntity_1.UndoRedoEntity.type);
+        if (this.undoRedoEntity) {
+            this.undoRedoEntity.addChangeObserver(this.onEntityChange);
+            this.onEntityChange();
+        }
+        else {
+            App_1.submitWarning("HasUndoPM", "HasUndoPM has been added to an app object that does not have UndoRedoEntity", appObject.appObjectRepo);
+        }
+    }
+    static get(appObjects) {
+        const components = appObjects.getAllComponents(HasUndoPM.type);
+        if (components.length === 0) {
+            App_1.submitWarning("HasUndoPM", `Unable to find component ${HasUndoPM.type}. Add one on Mount`, appObjects);
+            return undefined;
+        }
+        else if (components.length > 1) {
+            App_1.submitWarning("HasUndoPM", `Multiple ${HasUndoPM.type} found. There should only be one. Using the first one`, appObjects);
+        }
+        return components[0];
+    }
+    vmsAreEqual(a, b) {
+        return a === b;
+    }
+}
+exports.HasUndoPM = HasUndoPM;
+HasUndoPM.type = "HasUndoPM";

package/lib/AppObjectComponents/UndoRedo/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./Entities/UndoRedoEntity";
+export * from "./PresentationManager/HasRedoPM";
+export * from "./PresentationManager/HasUndoPM";
+export * from "./Controllers/clearUndoStack";
+export * from "./Controllers/doRedo";
+export * from "./Controllers/doUndo";
+export * from "./Factories/setupUndo";

package/lib/AppObjectComponents/UndoRedo/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Entities/UndoRedoEntity"), exports);
+__exportStar(require("./PresentationManager/HasRedoPM"), exports);
+__exportStar(require("./PresentationManager/HasUndoPM"), exports);
+__exportStar(require("./Controllers/clearUndoStack"), exports);
+__exportStar(require("./Controllers/doRedo"), exports);
+__exportStar(require("./Controllers/doUndo"), exports);
+__exportStar(require("./Factories/setupUndo"), exports);

package/lib/AppObjectComponents/XR/Entity/XREntity.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="webxr" />
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectEntity } from "../../../AppObject/AppObjectEntity";
+export interface OnXRFrameObserver {
+    onNewXRFrame: (frame: XRFrame) => void;
+}
+export declare abstract class XREntity extends AppObjectEntity {
+    static readonly type = "XREntity";
+    abstract xrReferenceSpace?: XRReferenceSpace;
+    abstract get lastXRFrame(): XRFrame | undefined;
+    abstract submitXRFrame: (frame: XRFrame) => void;
+}
+export declare function makeXREntity(appObj: AppObject): XREntity;

package/lib/AppObjectComponents/XR/Entity/XREntity.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeXREntity = exports.XREntity = void 0;
+const AppObjectEntity_1 = require("../../../AppObject/AppObjectEntity");
+class XREntity extends AppObjectEntity_1.AppObjectEntity {
+}
+exports.XREntity = XREntity;
+XREntity.type = "XREntity";
+function makeXREntity(appObj) {
+    return new XREntityImp(appObj);
+}
+exports.makeXREntity = makeXREntity;
+class XREntityImp extends XREntity {
+    constructor(appObj) {
+        super(appObj, XREntity.type);
+        this.submitXRFrame = (frame) => {
+            this._lastXRFrame = frame;
+            this.notifyOnChange();
+        };
+    }
+    get lastXRFrame() {
+        return this._lastXRFrame;
+    }
+}

package/lib/AppObjectComponents/XR/UseCase/RenderToXR.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="webxr" />
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+export declare abstract class RenderToXR extends AppObjectUC {
+    static readonly type = "RenderToXR";
+    abstract startRenderingXR(session: XRSession): void;
+    abstract stopRenderingXR(): void;
+}

package/lib/AppObjectComponents/XR/UseCase/RenderToXR.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RenderToXR = void 0;
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+class RenderToXR extends AppObjectUC_1.AppObjectUC {
+}
+exports.RenderToXR = RenderToXR;
+RenderToXR.type = "RenderToXR";

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

@@ -0,0 +1,2 @@
+export * from "./Entity/XREntity";
+export * from "./UseCase/RenderToXR";

package/lib/AppObjectComponents/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/XREntity"), exports);
+__exportStar(require("./UseCase/RenderToXR"), exports);

package/lib/AppObjectComponents/zSpace/Controllers/ZSpaceScaleRoot.d.ts

@@ -0,0 +1,14 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectController } from "../../../AppObject/AppObjectController";
+import { ZSpaceStylusButton, ZSpaceStylusController } from "../Entities/ZSpaceStylusEntity";
+export declare class ZSpaceScaleRoot 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/AppObjectComponents/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.SceneRoot.get(appObject.appObjectRepo);
+        this.scaleSceneRootWithRay = sceneRoot === null || sceneRoot === void 0 ? void 0 : sceneRoot.appObject.getComponent(ScaleSceneRootWithRay_1.ScaleSceneRootWithRay.type);
+        if (!this.stylus) {
+            console.error("StylusInputPointer Controller has been added to an app object that does not have a ZSpaceStylusEntity");
+        }
+        else if (!this.scaleSceneRootWithRay) {
+            console.error("StylusRootScaleSceneRootWithRay was not found on the Scene Root App Object");
+        }
+        else {
+            this.stylus.registerController(this);
+        }
+    }
+}
+exports.ZSpaceScaleRoot = ZSpaceScaleRoot;
+ZSpaceScaleRoot.type = "ZSpaceScaleRoot";

package/lib/AppObjectComponents/zSpace/Controllers/ZSpaceStylusRootMovement.d.ts

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

package/lib/AppObjectComponents/zSpace/Controllers/ZSpaceStylusRootMovement.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZSpaceStylusRootMovement = void 0;
+const AppObjectController_1 = require("../../../AppObject/AppObjectController");
+const ZSpaceStylusEntity_1 = require("../Entities/ZSpaceStylusEntity");
+const StylusRootMovementUC_1 = require("../UseCases/StylusRootMovementUC");
+class ZSpaceStylusRootMovement extends AppObjectController_1.AppObjectController {
+    constructor(appObject) {
+        super(appObject, ZSpaceStylusRootMovement.type);
+        this.allow = (button) => {
+            if (button === ZSpaceStylusEntity_1.ZSpaceStylusButton.PRIMARY)
+                return true;
+            return false;
+        };
+        this.onButtonDown = (button) => {
+            var _a;
+            if (!this.stylus)
+                return;
+            if (!this.allow(button))
+                return;
+            const pointerRay = this.stylus.pickRay;
+            (_a = this.stylusRootMovementUC) === null || _a === void 0 ? void 0 : _a.initialize(pointerRay);
+        };
+        this.onButtonUp = (button) => {
+            var _a;
+            if (!this.stylus)
+                return;
+            (_a = this.stylusRootMovementUC) === null || _a === void 0 ? void 0 : _a.stop();
+        };
+        this.onStylusMove = () => {
+            var _a;
+            if (!this.stylus)
+                return;
+            const pointerRay = this.stylus.pickRay;
+            (_a = this.stylusRootMovementUC) === null || _a === void 0 ? void 0 : _a.move(pointerRay);
+        };
+        this.stylus = appObject.getComponent(ZSpaceStylusEntity_1.ZSpaceStylusEntity.type);
+        this.stylusRootMovementUC = StylusRootMovementUC_1.StylusRootMovementUC.get(appObject.appObjectRepo);
+        if (!this.stylus) {
+            console.error("StylusInputPointer Controller has been added to an app object that does not have a ZSpaceStylusEntity");
+        }
+        else if (!this.stylusRootMovementUC) {
+            console.error("StylusRootMovementUC has not been found on any objects in the app object repo");
+        }
+        else {
+            this.stylus.registerController(this);
+        }
+    }
+}
+exports.ZSpaceStylusRootMovement = ZSpaceStylusRootMovement;
+ZSpaceStylusRootMovement.type = "ZSpaceStylusRootMovement";

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

@@ -0,0 +1,21 @@
+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;
+}
+export declare function makeZSpaceDisplayEntity(appObj: AppObject): ZSpaceDisplayEntity;