@vived/app 3.9.2 → 4.0.1

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

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeZSpaceStylus = exports.ZSpaceStylusEntity = exports.ZSpaceStylusButton = void 0;
+const AppObjectEntity_1 = require("../../../AppObject/AppObjectEntity");
+const Entities_1 = require("../../../Entities");
+const ValueObjects_1 = require("../../../ValueObjects");
+const Transform3D_1 = require("../../Transform3D");
+var ZSpaceStylusButton;
+(function (ZSpaceStylusButton) {
+    ZSpaceStylusButton[ZSpaceStylusButton["PRIMARY"] = 0] = "PRIMARY";
+    ZSpaceStylusButton[ZSpaceStylusButton["BACK_RIGHT"] = 1] = "BACK_RIGHT";
+    ZSpaceStylusButton[ZSpaceStylusButton["BACK_LEFT"] = 2] = "BACK_LEFT";
+})(ZSpaceStylusButton = exports.ZSpaceStylusButton || (exports.ZSpaceStylusButton = {}));
+class ZSpaceStylusEntity extends AppObjectEntity_1.AppObjectEntity {
+}
+exports.ZSpaceStylusEntity = ZSpaceStylusEntity;
+ZSpaceStylusEntity.type = "ZSpaceStylusEntity";
+ZSpaceStylusEntity.clickMovementThreshold = 0.32;
+ZSpaceStylusEntity.clickTimeThresholdMS = 350;
+function makeZSpaceStylus(appObj) {
+    const transform = Transform3D_1.Transform3D.addIfMissing(appObj);
+    return new StylusImp(appObj, transform);
+}
+exports.makeZSpaceStylus = makeZSpaceStylus;
+class StylusImp extends ZSpaceStylusEntity {
+    constructor(appObject, transform) {
+        super(appObject, ZSpaceStylusEntity.type);
+        this.controllers = [];
+        this.buttonStates = [false, false, false];
+        this.pressPosition = ValueObjects_1.Vector3.Zero();
+        this.pressTime = 0;
+        this.registerController = (controller) => {
+            this.controllers.push(controller);
+        };
+        this.updateButtonState = (button, isPressed) => {
+            if (this.buttonStates[button] === isPressed)
+                return;
+            this.controllers.forEach((controller) => {
+                if (isPressed) {
+                    if (controller.onButtonDown) {
+                        controller.onButtonDown(button);
+                    }
+                    this.lassPressedButton = button;
+                    this.pressPosition = this.transform.localPosition;
+                    this.pressTime = Date.now();
+                }
+                else {
+                    if (controller.onButtonUp) {
+                        controller.onButtonUp(button);
+                    }
+                    if (this.isClick(button) && controller.onButtonClick) {
+                        controller.onButtonClick(button);
+                    }
+                }
+            });
+            this.buttonStates[button] = isPressed;
+            this.notifyOnChange();
+        };
+        this.isClick = (button) => {
+            const buttonIsCorrect = button === this.lassPressedButton;
+            const movement = ValueObjects_1.Vector3.Subtract(this.transform.localPosition, this.pressPosition).magnitude;
+            const movementIsSmallEnough = movement < ZSpaceStylusEntity.clickMovementThreshold;
+            const passedTime = Date.now() - this.pressTime;
+            const pressTimeIsShortEnough = passedTime < ZSpaceStylusEntity.clickTimeThresholdMS;
+            if (buttonIsCorrect && movementIsSmallEnough && pressTimeIsShortEnough) {
+                return true;
+            }
+            else {
+                return false;
+            }
+        };
+        this.onTransformUpdate = () => {
+            this.checkIfStylusIsInUse(this.transform.worldMatrix);
+            this.controllers.forEach((controller) => {
+                if (controller.onStylusMove) {
+                    controller.onStylusMove(this.transform);
+                }
+            });
+            this.notifyOnChange();
+        };
+        this.memoizedIsInUse = new Entities_1.MemoizedBoolean(false, this.notifyOnChange);
+        this.transform = transform;
+        this.transform.addChangeObserver(this.onTransformUpdate);
+        const helperTransformAO = appObject.appObjectRepo.getOrCreate("StylusHelper");
+        this.helperTransform = Transform3D_1.Transform3D.addIfMissing(helperTransformAO);
+        this.helperTransform.parent = this.transform;
+    }
+    get pickRay() {
+        return ValueObjects_1.ParametricLine.FromPointDirection(this.transform.worldPosition, this.transform.localDirectionToWorld(ValueObjects_1.Vector3.Forward()));
+    }
+    get isInUse() {
+        return this.memoizedIsInUse.val;
+    }
+    checkIfStylusIsInUse(worldMatrix) {
+        const m = worldMatrix.m;
+        if (m[1] === 0 &&
+            m[2] === 0 &&
+            m[3] === 0 &&
+            m[4] === 0 &&
+            m[7] === 0 &&
+            m[8] === 0 &&
+            m[11] === 0 &&
+            m[12] === 0 &&
+            m[15] === 1) {
+            this.memoizedIsInUse.val = false;
+        }
+        else {
+            this.memoizedIsInUse.val = true;
+        }
+    }
+}

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

@@ -0,0 +1,25 @@
+/// <reference types="webxr" />
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectEntity } from "../../../AppObject/AppObjectEntity";
+import { Matrix, Quaternion, Vector3 } from "../../../ValueObjects";
+import { Transform3D } from "../../Transform3D";
+export interface UpdateDTO {
+    position: Vector3;
+    rotation: Quaternion;
+    projectionMatrix: Matrix;
+    view?: XRView;
+}
+export declare enum ZSpaceViewType {
+    CENTER = "Center",
+    LEFT = "Left",
+    RIGHT = "Right"
+}
+export declare abstract class ZSpaceViewEntity extends AppObjectEntity {
+    static readonly type = "ZSpaceViewEntity";
+    abstract update(data: UpdateDTO): void;
+    abstract get view(): XRView | undefined;
+    abstract readonly transform: Transform3D;
+    abstract get projectionMatrix(): Matrix;
+    abstract readonly viewType: ZSpaceViewType;
+}
+export declare function makeZSpaceView(appObj: AppObject, viewType: ZSpaceViewType): ZSpaceViewEntity;

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

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeZSpaceView = exports.ZSpaceViewEntity = exports.ZSpaceViewType = void 0;
+const AppObjectEntity_1 = require("../../../AppObject/AppObjectEntity");
+const ValueObjects_1 = require("../../../ValueObjects");
+const Transform3D_1 = require("../../Transform3D");
+var ZSpaceViewType;
+(function (ZSpaceViewType) {
+    ZSpaceViewType["CENTER"] = "Center";
+    ZSpaceViewType["LEFT"] = "Left";
+    ZSpaceViewType["RIGHT"] = "Right";
+})(ZSpaceViewType = exports.ZSpaceViewType || (exports.ZSpaceViewType = {}));
+class ZSpaceViewEntity extends AppObjectEntity_1.AppObjectEntity {
+}
+exports.ZSpaceViewEntity = ZSpaceViewEntity;
+ZSpaceViewEntity.type = "ZSpaceViewEntity";
+function makeZSpaceView(appObj, viewType) {
+    const transform = Transform3D_1.Transform3D.addIfMissing(appObj);
+    return new ZSpaceViewImp(appObj, viewType, transform);
+}
+exports.makeZSpaceView = makeZSpaceView;
+class ZSpaceViewImp extends ZSpaceViewEntity {
+    constructor(appObject, viewType, transform) {
+        super(appObject, ZSpaceViewEntity.type);
+        this._projectionMatrix = ValueObjects_1.Matrix.Identity();
+        this.viewType = viewType;
+        this.transform = transform;
+        this.transform.addChangeObserver(this.notifyOnChange);
+    }
+    update(data) {
+        this.transform.localPosition = data.position;
+        this.transform.localRotation = data.rotation;
+        this._projectionMatrix = data.projectionMatrix;
+        this._view = data.view;
+        this.notifyOnChange();
+    }
+    get view() {
+        return this._view;
+    }
+    submitView(view) {
+        this._view = view;
+        this.notifyOnChange();
+    }
+    get projectionMatrix() {
+        return this._projectionMatrix;
+    }
+}

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

@@ -0,0 +1,4 @@
+export * from "./ZSpaceDisplayEntity";
+export * from "./ZSpaceEntity";
+export * from "./ZSpaceStylusEntity";
+export * from "./ZSpaceViewEntity";

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

@@ -0,0 +1,16 @@
+"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("./ZSpaceDisplayEntity"), exports);
+__exportStar(require("./ZSpaceEntity"), exports);
+__exportStar(require("./ZSpaceStylusEntity"), exports);
+__exportStar(require("./ZSpaceViewEntity"), exports);

package/lib/Components/zSpace/Mocks/MockCheckZSpaceDisplaySizeUC.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="jest" />
+import { AppObject } from "../../../AppObject";
+import { CheckZSpaceDisplaySizeUC } from "../UC";
+export declare class MockCheckZSpaceDisplaySizeUC extends CheckZSpaceDisplaySizeUC {
+    checkDisplayFromXRSession: jest.Mock<any, any>;
+    checkDisplayFromSize: jest.Mock<any, any>;
+    constructor(appObject: AppObject);
+}

package/lib/Components/zSpace/Mocks/MockCheckZSpaceDisplaySizeUC.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockCheckZSpaceDisplaySizeUC = void 0;
+const UC_1 = require("../UC");
+class MockCheckZSpaceDisplaySizeUC extends UC_1.CheckZSpaceDisplaySizeUC {
+    constructor(appObject) {
+        super(appObject, UC_1.CheckZSpaceDisplaySizeUC.type);
+        this.checkDisplayFromXRSession = jest.fn();
+        this.checkDisplayFromSize = jest.fn();
+    }
+}
+exports.MockCheckZSpaceDisplaySizeUC = MockCheckZSpaceDisplaySizeUC;

package/lib/Components/zSpace/PM/StylusColorLengthPM.d.ts

@@ -0,0 +1,13 @@
+import { AppObject, AppObjectPM } from "../../../AppObject";
+import { Color } from "../../../ValueObjects";
+export interface StylusColorLengthVM {
+    color: Color;
+    length: number;
+}
+export declare abstract class StylusColorLengthPM extends AppObjectPM<StylusColorLengthVM> {
+    static readonly type = "StylusColorLengthPM";
+    abstract rayColorNoPick: Color;
+    abstract rayColorPick: Color;
+    abstract defaultLength: number;
+}
+export declare function makeStylusColorLengthPM(appObject: AppObject): StylusColorLengthPM;

package/lib/Components/zSpace/PM/StylusColorLengthPM.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeStylusColorLengthPM = exports.StylusColorLengthPM = void 0;
+const AppObject_1 = require("../../../AppObject");
+const ValueObjects_1 = require("../../../ValueObjects");
+const Babylon_1 = require("../../Babylon");
+const ZSpaceStylusEntity_1 = require("../Entities/ZSpaceStylusEntity");
+class StylusColorLengthPM extends AppObject_1.AppObjectPM {
+}
+exports.StylusColorLengthPM = StylusColorLengthPM;
+StylusColorLengthPM.type = "StylusColorLengthPM";
+function makeStylusColorLengthPM(appObject) {
+    return new StylusColorLengthPMImp(appObject);
+}
+exports.makeStylusColorLengthPM = makeStylusColorLengthPM;
+class StylusColorLengthPMImp extends StylusColorLengthPM {
+    constructor(appObject) {
+        super(appObject, StylusColorLengthPM.type);
+        this.defaultLength = 1;
+        this.rayColorNoPick = ValueObjects_1.Color.RGB(128, 128, 128);
+        this.rayColorPick = ValueObjects_1.Color.RGB(0, 255, 0);
+        this.onEntityChange = () => {
+            if (!this.stylus || !this.stylus.isInUse) {
+                this.setDefaultVM();
+                return;
+            }
+            const pickRay = this.stylus.pickRay;
+            const scenePickUC = Babylon_1.SceneRayPickUC.get(this.appObject.appObjectRepo);
+            if (!scenePickUC) {
+                this.setDefaultVM();
+                return;
+            }
+            const scenePick = scenePickUC.sceneRayPick(pickRay);
+            let color = this.rayColorNoPick;
+            let length = this.defaultLength;
+            if (scenePick && (scenePick === null || scenePick === void 0 ? void 0 : scenePick.hit) && scenePick.worldPickPoint) {
+                color = this.rayColorPick;
+                length = Math.abs(ValueObjects_1.Vector3.Subtract(this.stylus.transform.worldPosition, scenePick.worldPickPoint).magnitude);
+            }
+            const vm = {
+                color,
+                length,
+            };
+            this.doUpdateView(vm);
+        };
+        this.dispose = () => {
+            var _a, _b;
+            super.dispose();
+            (_a = this.stylus) === null || _a === void 0 ? void 0 : _a.removeChangeObserver(this.onEntityChange);
+            (_b = this.stylus) === null || _b === void 0 ? void 0 : _b.removeOnDisposeObserver(this.dispose);
+        };
+        this.stylus = appObject.getComponent(ZSpaceStylusEntity_1.ZSpaceStylusEntity.type);
+        if (this.stylus) {
+            this.stylus.addChangeObserver(this.onEntityChange);
+            this.stylus.addOnDisposeObserver(() => {
+                this.dispose();
+            });
+            this.onEntityChange();
+        }
+        else {
+            this.warn("App Object does not have a Stylus Entity");
+        }
+    }
+    vmsAreEqual(a, b) {
+        if (ValueObjects_1.Color.Equal(a.color, b.color) && a.length === b.length) {
+            return true;
+        }
+        return false;
+    }
+    setDefaultVM() {
+        const vm = {
+            color: this.rayColorNoPick,
+            length: 0,
+        };
+        this.doUpdateView(vm);
+    }
+}

package/lib/Components/zSpace/PM/StylusIsInUsePM.d.ts

@@ -0,0 +1,6 @@
+import { AppObject, AppObjectPM, AppObjectRepo } from "../../../AppObject";
+export declare abstract class StylusIsInUsePM extends AppObjectPM<boolean> {
+    static readonly type = "StylusIsInUsePM";
+    static get: (appObjects: AppObjectRepo) => StylusIsInUsePM | undefined;
+}
+export declare function makeStylusIsInUsePM(appObject: AppObject): StylusIsInUsePM;

package/lib/Components/zSpace/PM/StylusIsInUsePM.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeStylusIsInUsePM = exports.StylusIsInUsePM = void 0;
+const AppObject_1 = require("../../../AppObject");
+const Entities_1 = require("../Entities");
+class StylusIsInUsePM extends AppObject_1.AppObjectPM {
+}
+exports.StylusIsInUsePM = StylusIsInUsePM;
+StylusIsInUsePM.type = "StylusIsInUsePM";
+StylusIsInUsePM.get = (appObjects) => AppObject_1.getSingletonComponent(StylusIsInUsePM.type, appObjects);
+function makeStylusIsInUsePM(appObject) {
+    return new StylusIsInUsePMImp(appObject);
+}
+exports.makeStylusIsInUsePM = makeStylusIsInUsePM;
+class StylusIsInUsePMImp extends StylusIsInUsePM {
+    constructor(appObject) {
+        super(appObject, StylusIsInUsePM.type);
+        this.onRepoChange = () => {
+            if (!this.stylus)
+                return;
+            this.doUpdateView(this.stylus.isInUse);
+        };
+        this.dispose = () => {
+            var _a, _b;
+            super.dispose();
+            (_a = this.stylus) === null || _a === void 0 ? void 0 : _a.removeChangeObserver(this.onRepoChange);
+            (_b = this.stylus) === null || _b === void 0 ? void 0 : _b.removeOnDisposeObserver(this.dispose);
+        };
+        this.stylus = appObject.getComponent(Entities_1.ZSpaceStylusEntity.type);
+        if (this.stylus) {
+            this.stylus.addChangeObserver(this.onRepoChange);
+            this.stylus.addOnDisposeObserver(() => this.dispose());
+            this.onRepoChange();
+        }
+        else {
+            this.warn("App Object does not have a ZSpace Stylus Entity");
+        }
+    }
+    vmsAreEqual(a, b) {
+        return a === b;
+    }
+}

package/lib/Components/zSpace/PM/ZSpaceDisplayPM.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeZSpaceDisplayPM = exports.ZSpaceDisplayPM = void 0;
+const AppObjectPM_1 = require("../../../AppObject/AppObjectPM");
+const ValueObjects_1 = require("../../../ValueObjects");
+const ZSpaceDisplayEntity_1 = require("../Entities/ZSpaceDisplayEntity");
+const ZSpaceEntity_1 = require("../Entities/ZSpaceEntity");
+class ZSpaceDisplayPM extends AppObjectPM_1.AppObjectPM {
+}
+exports.ZSpaceDisplayPM = ZSpaceDisplayPM;
+ZSpaceDisplayPM.type = "ZSpaceDisplayPM";
+function makeZSpaceDisplayPM(appObject) {
+    return new ZSpaceDisplayPMImp(appObject);
+}
+exports.makeZSpaceDisplayPM = makeZSpaceDisplayPM;
+class ZSpaceDisplayPMImp extends ZSpaceDisplayPM {
+    constructor(appObject) {
+        super(appObject, ZSpaceDisplayPM.type);
+        this.onEntityChange = () => {
+            var _a, _b;
+            if (!this.zSpaceDisplay)
+                return;
+            const show = (_b = (_a = this.zSpaceEntity) === null || _a === void 0 ? void 0 : _a.enabled) !== null && _b !== void 0 ? _b : false;
+            const vm = {
+                show,
+                pixelSize: this.zSpaceDisplay.displaySizePixels,
+                worldSize: this.zSpaceDisplay.displaySizeMeters,
+            };
+            this.doUpdateView(vm);
+        };
+        this.dispose = () => {
+            var _a, _b, _c, _d;
+            super.dispose();
+            (_a = this.zSpaceDisplay) === null || _a === void 0 ? void 0 : _a.removeChangeObserver(this.onEntityChange);
+            (_b = this.zSpaceDisplay) === null || _b === void 0 ? void 0 : _b.removeOnDisposeObserver(this.dispose);
+            (_c = this.zSpaceEntity) === null || _c === void 0 ? void 0 : _c.removeChangeObserver(this.onEntityChange);
+            (_d = this.zSpaceEntity) === null || _d === void 0 ? void 0 : _d.removeOnDisposeObserver(this.dispose);
+        };
+        this.zSpaceDisplay = appObject.getComponent(ZSpaceDisplayEntity_1.ZSpaceDisplayEntity.type);
+        if (!this.zSpaceDisplay) {
+            this.warn("App Object does not have a ZSpace Display Entity");
+            return;
+        }
+        this.zSpaceEntity = ZSpaceEntity_1.ZSpaceEntity.get(appObject.appObjectRepo);
+        if (!this.zSpaceEntity) {
+            this.warn("Could not find a ZSpace Entity");
+            return;
+        }
+        this.zSpaceDisplay.addChangeObserver(this.onEntityChange);
+        this.zSpaceDisplay.addOnDisposeObserver(this.dispose);
+        this.zSpaceEntity.addChangeObserver(this.onEntityChange);
+        this.zSpaceEntity.addOnDisposeObserver(this.dispose);
+        this.onEntityChange();
+    }
+    vmsAreEqual(a, b) {
+        if (a.show === b.show &&
+            ValueObjects_1.Vector2.Equal(a.pixelSize, b.pixelSize) &&
+            ValueObjects_1.Vector2.Equal(a.worldSize, b.worldSize)) {
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+}

package/lib/Components/zSpace/PM/ZSpaceIsEnabledPM.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeZSpaceIsEnabledPM = exports.ZSpaceIsEnabledPM = void 0;
+const AppObjectPM_1 = require("../../../AppObject/AppObjectPM");
+const ZSpaceEntity_1 = require("../Entities/ZSpaceEntity");
+class ZSpaceIsEnabledPM extends AppObjectPM_1.AppObjectPM {
+}
+exports.ZSpaceIsEnabledPM = ZSpaceIsEnabledPM;
+ZSpaceIsEnabledPM.type = "ZSpaceIsEnabledPM";
+function makeZSpaceIsEnabledPM(appObject) {
+    return new ZSpaceIsEnabledPMImp(appObject);
+}
+exports.makeZSpaceIsEnabledPM = makeZSpaceIsEnabledPM;
+class ZSpaceIsEnabledPMImp extends ZSpaceIsEnabledPM {
+    constructor(appObject) {
+        super(appObject, ZSpaceIsEnabledPM.type);
+        this.onRepoChange = () => {
+            if (!this.zSpace)
+                return;
+            this.doUpdateView(this.zSpace.enabled);
+        };
+        this.dispose = () => {
+            var _a, _b;
+            super.dispose();
+            (_a = this.zSpace) === null || _a === void 0 ? void 0 : _a.removeChangeObserver(this.onRepoChange);
+            (_b = this.zSpace) === null || _b === void 0 ? void 0 : _b.removeOnDisposeObserver(this.dispose);
+        };
+        this.zSpace = appObject.getComponent(ZSpaceEntity_1.ZSpaceEntity.type);
+        if (this.zSpace) {
+            this.zSpace.addChangeObserver(this.onRepoChange);
+            this.zSpace.addOnDisposeObserver(() => this.dispose());
+            this.onRepoChange();
+        }
+        else {
+            this.warn("App Object does not have a ZSpace Entity");
+        }
+    }
+    vmsAreEqual(a, b) {
+        return a === b;
+    }
+}

package/lib/Components/zSpace/PM/ZSpaceIsSupportedPM.d.ts

@@ -0,0 +1,8 @@
+import { AppObjectRepo } from "../../../AppObject";
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectPM } from "../../../AppObject/AppObjectPM";
+export declare abstract class ZSpaceIsSupportedPM extends AppObjectPM<boolean> {
+    static readonly type = "ZSpaceIsSupportedPM";
+    static get: (appObjects: AppObjectRepo) => ZSpaceIsSupportedPM | undefined;
+}
+export declare function makeZSpaceIsSupportedPM(appObject: AppObject): ZSpaceIsSupportedPM;

package/lib/Components/zSpace/PM/ZSpaceIsSupportedPM.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeZSpaceIsSupportedPM = exports.ZSpaceIsSupportedPM = void 0;
+const AppObject_1 = require("../../../AppObject");
+const AppObjectPM_1 = require("../../../AppObject/AppObjectPM");
+const ZSpaceEntity_1 = require("../Entities/ZSpaceEntity");
+class ZSpaceIsSupportedPM extends AppObjectPM_1.AppObjectPM {
+}
+exports.ZSpaceIsSupportedPM = ZSpaceIsSupportedPM;
+ZSpaceIsSupportedPM.type = "ZSpaceIsSupportedPM";
+ZSpaceIsSupportedPM.get = (appObjects) => AppObject_1.getSingletonComponent(ZSpaceIsSupportedPM.type, appObjects);
+function makeZSpaceIsSupportedPM(appObject) {
+    return new ZSpaceIsSupportedPMImp(appObject);
+}
+exports.makeZSpaceIsSupportedPM = makeZSpaceIsSupportedPM;
+class ZSpaceIsSupportedPMImp extends ZSpaceIsSupportedPM {
+    constructor(appObject) {
+        super(appObject, ZSpaceIsSupportedPM.type);
+        this.onRepoChange = () => {
+            if (!this.zSpace)
+                return;
+            this.doUpdateView(this.zSpace.isSupported);
+        };
+        this.dispose = () => {
+            var _a, _b;
+            super.dispose();
+            (_a = this.zSpace) === null || _a === void 0 ? void 0 : _a.removeChangeObserver(this.onRepoChange);
+            (_b = this.zSpace) === null || _b === void 0 ? void 0 : _b.removeOnDisposeObserver(this.dispose);
+        };
+        this.zSpace = appObject.getComponent(ZSpaceEntity_1.ZSpaceEntity.type);
+        if (this.zSpace) {
+            this.zSpace.addChangeObserver(this.onRepoChange);
+            this.zSpace.addOnDisposeObserver(() => this.dispose());
+            this.onRepoChange();
+        }
+        else {
+            this.warn("App Object does not have a ZSpace Entity");
+        }
+    }
+    vmsAreEqual(a, b) {
+        return a === b;
+    }
+}

package/lib/Components/zSpace/PM/ZSpaceViewerScalePM.d.ts

@@ -0,0 +1,5 @@
+import { AppObject, AppObjectPM } from "../../../AppObject";
+export declare abstract class ZSpaceViewerScalePM extends AppObjectPM<number> {
+    static readonly type = "ZSpaceViewerScalePM";
+}
+export declare function makeZSpaceViewerScalePM(appObject: AppObject): ZSpaceViewerScalePM;

package/lib/Components/zSpace/PM/ZSpaceViewerScalePM.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeZSpaceViewerScalePM = exports.ZSpaceViewerScalePM = void 0;
+const AppObject_1 = require("../../../AppObject");
+const ZSpaceEntity_1 = require("../Entities/ZSpaceEntity");
+class ZSpaceViewerScalePM extends AppObject_1.AppObjectPM {
+}
+exports.ZSpaceViewerScalePM = ZSpaceViewerScalePM;
+ZSpaceViewerScalePM.type = "ZSpaceViewerScalePM";
+function makeZSpaceViewerScalePM(appObject) {
+    return new ZSpaceViewerScalePMImp(appObject);
+}
+exports.makeZSpaceViewerScalePM = makeZSpaceViewerScalePM;
+class ZSpaceViewerScalePMImp extends ZSpaceViewerScalePM {
+    constructor(appObject) {
+        super(appObject, ZSpaceViewerScalePM.type);
+        this.onRepoChange = () => {
+            if (!this.zSpace)
+                return;
+            this.doUpdateView(this.zSpace.viewerScale);
+        };
+        this.dispose = () => {
+            var _a, _b;
+            super.dispose();
+            (_a = this.zSpace) === null || _a === void 0 ? void 0 : _a.removeChangeObserver(this.onRepoChange);
+            (_b = this.zSpace) === null || _b === void 0 ? void 0 : _b.removeOnDisposeObserver(this.dispose);
+        };
+        this.zSpace = appObject.getComponent(ZSpaceEntity_1.ZSpaceEntity.type);
+        if (this.zSpace) {
+            this.zSpace.addChangeObserver(this.onRepoChange);
+            this.zSpace.addOnDisposeObserver(() => this.dispose());
+            this.onRepoChange();
+        }
+        else {
+            this.warn("App Object does not have a ZSpace Entity");
+        }
+    }
+    vmsAreEqual(a, b) {
+        return a === b;
+    }
+}

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

@@ -0,0 +1,6 @@
+export * from "./StylusColorLengthPM";
+export * from "./StylusIsInUsePM";
+export * from "./ZSpaceDisplayPM";
+export * from "./ZSpaceIsEnabledPM";
+export * from "./ZSpaceIsSupportedPM";
+export * from "./ZSpaceViewerScalePM";

package/lib/Components/zSpace/PM/index.js

@@ -0,0 +1,18 @@
+"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("./StylusColorLengthPM"), exports);
+__exportStar(require("./StylusIsInUsePM"), exports);
+__exportStar(require("./ZSpaceDisplayPM"), exports);
+__exportStar(require("./ZSpaceIsEnabledPM"), exports);
+__exportStar(require("./ZSpaceIsSupportedPM"), exports);
+__exportStar(require("./ZSpaceViewerScalePM"), exports);

package/lib/Components/zSpace/UC/CheckZSpaceDisplaySizeUC.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="webxr" />
+import { AppObjectUC } from "../../../AppObject";
+export interface DisplaySize {
+    width: number;
+    height: number;
+}
+export declare abstract class CheckZSpaceDisplaySizeUC extends AppObjectUC {
+    static readonly type = "CheckZSpaceDisplaySizeUC";
+    abstract checkDisplayFromXRSession(xrSession: XRSession): void;
+    abstract checkDisplayFromSize(displaySize: DisplaySize): void;
+}

package/lib/Components/zSpace/UC/CheckZSpaceDisplaySizeUC.js

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

package/lib/Components/zSpace/UC/EmulateDisplaySizeHook.d.ts

@@ -0,0 +1,5 @@
+import { AppObject, AppObjectUC } from "../../../AppObject";
+export declare abstract class EmulateDisplaySizeHook extends AppObjectUC {
+    static readonly type = "EmulateDisplaySizeHook";
+}
+export declare function makeEmulateDisplaySizeHook(appObject: AppObject): EmulateDisplaySizeHook;