@vived/app 2.20.1 → 2.21.0

package/lib/Entities/WorkPlane.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeWorkPlane = exports.WorkplaneShape = exports.WorkPlaneUnits = void 0;
+const ValueObjects_1 = require("../ValueObjects");
+const TransformNode_1 = require("./TransformNode");
+var WorkPlaneUnits;
+(function (WorkPlaneUnits) {
+    WorkPlaneUnits[WorkPlaneUnits["INCHES"] = 0] = "INCHES";
+    WorkPlaneUnits[WorkPlaneUnits["METERS"] = 1] = "METERS";
+    WorkPlaneUnits[WorkPlaneUnits["FEET"] = 2] = "FEET";
+})(WorkPlaneUnits = exports.WorkPlaneUnits || (exports.WorkPlaneUnits = {}));
+var WorkplaneShape;
+(function (WorkplaneShape) {
+    WorkplaneShape[WorkplaneShape["RECTANGE"] = 0] = "RECTANGE";
+    WorkplaneShape[WorkplaneShape["CIRCLE"] = 1] = "CIRCLE";
+    WorkplaneShape[WorkplaneShape["UNKNOWN"] = 2] = "UNKNOWN";
+})(WorkplaneShape = exports.WorkplaneShape || (exports.WorkplaneShape = {}));
+function makeWorkPlane() {
+    return new WorkPlaneImp();
+}
+exports.makeWorkPlane = makeWorkPlane;
+class WorkPlaneImp {
+    constructor() {
+        this._workPlaneHalfSize = ValueObjects_1.Vector2.One();
+        this.showWorkPlane = true;
+        this.transform = TransformNode_1.makeTransformNode();
+        this.id = "workplane";
+        this._units = WorkPlaneUnits.METERS;
+        this._workplaneShape = WorkplaneShape.UNKNOWN;
+        this.setWorkplaneSize = (size) => {
+            this._workPlaneSize = size;
+            this._workPlaneHalfSize = new ValueObjects_1.Vector2(0.5 * size.x, 0.5 * size.y);
+            this._workplaneShape = WorkplaneShape.RECTANGE;
+        };
+        this.setWorkplaneRadius = (radius) => {
+            this._workPlaneRadius = radius;
+            this._workplaneShape = WorkplaneShape.CIRCLE;
+        };
+        this.pickOnWorkplane = (ray, unconstrained = false) => {
+            const worldPos = this.transform.worldPosition;
+            const worldUp = this.transform.localDirectionToWorld(ValueObjects_1.Vector3.Up());
+            const pickPlane = ValueObjects_1.ParametricPlane.FromPointNormal(worldPos, worldUp);
+            const worldPick = pickPlane.intersectLine(ray);
+            if (worldPick === undefined) {
+                return undefined;
+            }
+            const localPick = this.transform.worldPointToLocal(worldPick);
+            const workPlanePick = new ValueObjects_1.Vector2(localPick.x, localPick.z);
+            if (unconstrained) {
+                return workPlanePick;
+            }
+            if (this._workplaneShape === WorkplaneShape.CIRCLE) {
+                return this.constrainToRadius(workPlanePick);
+            }
+            else if (this._workplaneShape === WorkplaneShape.RECTANGE) {
+                return this.constrainToSize(workPlanePick);
+            }
+            else {
+                return workPlanePick;
+            }
+        };
+    }
+    get workPlaneRadius() {
+        return this._workPlaneRadius;
+    }
+    get workPlaneSize() {
+        return this._workPlaneSize;
+    }
+    get units() {
+        return this._units;
+    }
+    set units(val) {
+        if (val === this._units)
+            return;
+        this._units = val;
+        const scale = 1 / this.conversionFactor;
+        this.transform.localScale = new ValueObjects_1.Vector3(scale, scale, scale);
+    }
+    get workplaneShape() {
+        return this._workplaneShape;
+    }
+    get conversionFactor() {
+        switch (this.units) {
+            case WorkPlaneUnits.FEET:
+                return 3.28084;
+            case WorkPlaneUnits.INCHES:
+                return 39.3701;
+            case WorkPlaneUnits.METERS:
+                return 1;
+            default:
+                console.warn("[WorkPlane] Unknown units " + this.units);
+                return 1;
+        }
+    }
+    constrainToRadius(workPlanePick) {
+        if (!this.workPlaneRadius)
+            return workPlanePick;
+        const pickRadius = workPlanePick.magnitued;
+        if (pickRadius <= this.workPlaneRadius) {
+            return workPlanePick;
+        }
+        else {
+            return undefined;
+        }
+    }
+    constrainToSize(workPlanePick) {
+        if (!this._workPlaneHalfSize)
+            return workPlanePick;
+        const x = workPlanePick.x;
+        const maxX = this._workPlaneHalfSize.x;
+        const minX = -this._workPlaneHalfSize.x;
+        const y = workPlanePick.y;
+        const maxY = this._workPlaneHalfSize.y;
+        const minY = -this._workPlaneHalfSize.y;
+        if (x >= minX && x <= maxX && y >= minY && y <= maxY) {
+            return workPlanePick;
+        }
+        else {
+            return undefined;
+        }
+    }
+}

package/lib/Entities/index.d.ts

@@ -10,8 +10,11 @@ export * from "./MemoizedVector3";
 export * from "./ObserverList";
 export * from "./FocusCamera";
 export * from "./StateMachine";
+export * from "./TransformNode";
 export * from "./UndoRedo";
 export * from "./MouseInput";
 export * from "./TouchInput";
 export * from "./QuestionChallengeAnswer";
 export * from "./QuestionChallenge";
+export * from "./SceneRoot";
+export * from "./WorkPlane";

package/lib/Entities/index.js

@@ -22,8 +22,11 @@ __exportStar(require("./MemoizedVector3"), exports);
 __exportStar(require("./ObserverList"), exports);
 __exportStar(require("./FocusCamera"), exports);
 __exportStar(require("./StateMachine"), exports);
+__exportStar(require("./TransformNode"), exports);
 __exportStar(require("./UndoRedo"), exports);
 __exportStar(require("./MouseInput"), exports);
 __exportStar(require("./TouchInput"), exports);
 __exportStar(require("./QuestionChallengeAnswer"), exports);
 __exportStar(require("./QuestionChallenge"), exports);
+__exportStar(require("./SceneRoot"), exports);
+__exportStar(require("./WorkPlane"), exports);

package/lib/Interface/Controllers/appHandler.d.ts

@@ -0,0 +1,12 @@
+import { AppPayloadVersions, Handler } from "@vived/app-host-boundary";
+export declare const appPayloadVersions: AppPayloadVersions;
+export interface AppHandlerFunctions {
+    showBabylonInspector: (show: boolean) => void;
+    setIsAuthoring: (isAuthoring: boolean) => void;
+    disposeApp: () => void;
+    stopApp: () => void;
+    startApp: (container: HTMLElement) => void;
+    setState: (finalState: string, duration?: number) => void;
+    setDevicePreview: (x: number, y: number) => void;
+}
+export declare function makeAppHandler(functions: AppHandlerFunctions): Handler;

package/lib/Interface/Controllers/appHandler.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeAppHandler = exports.appPayloadVersions = void 0;
+const app_host_boundary_1 = require("@vived/app-host-boundary");
+const verbose = false;
+exports.appPayloadVersions = {
+    disposeApp: 1,
+    setDevicePreview: 1,
+    setIsAuthoring: 1,
+    showBabylonInspector: 1,
+    startApp: 2,
+    stopApp: 1,
+    setState: 2,
+};
+function makeAppHandler(functions) {
+    const handler = (request) => {
+        switch (request.type) {
+            case app_host_boundary_1.SHOW_BABYLON_INSPECTOR:
+                if (request.version === exports.appPayloadVersions.showBabylonInspector) {
+                    const payload = request.payload;
+                    functions.showBabylonInspector(payload.showBabylonInspector);
+                }
+                else {
+                    throw new app_host_boundary_1.UnsupportedRequestVerion(request.type, request.version);
+                }
+                break;
+            case app_host_boundary_1.SET_IS_AUTHORING:
+                if (request.version === exports.appPayloadVersions.setIsAuthoring) {
+                    const payload = request.payload;
+                    functions.setIsAuthoring(payload.isAuthoring);
+                }
+                else {
+                    throw new app_host_boundary_1.UnsupportedRequestVerion(request.type, request.version);
+                }
+                break;
+            case app_host_boundary_1.DISPOSE_APP:
+                if (request.version === exports.appPayloadVersions.disposeApp) {
+                    functions.disposeApp();
+                }
+                else {
+                    throw new app_host_boundary_1.UnsupportedRequestVerion(request.type, request.version);
+                }
+                break;
+            case app_host_boundary_1.STOP_APP:
+                if (request.version === exports.appPayloadVersions.stopApp) {
+                    functions.stopApp();
+                }
+                else {
+                    throw new app_host_boundary_1.UnsupportedRequestVerion(request.type, request.version);
+                }
+                break;
+            case app_host_boundary_1.SET_DEVICE_PREVIEW:
+                if (request.version === exports.appPayloadVersions.setDevicePreview) {
+                    const payload = request.payload;
+                    functions.setDevicePreview(payload.x, payload.y);
+                }
+                else {
+                    throw new app_host_boundary_1.UnsupportedRequestVerion(request.type, request.version);
+                }
+                break;
+            case app_host_boundary_1.START_APP:
+                if (request.version === exports.appPayloadVersions.startApp) {
+                    const payload = request.payload;
+                    functions.startApp(payload.container);
+                }
+                else {
+                    throw new app_host_boundary_1.UnsupportedRequestVerion(request.type, request.version);
+                }
+                break;
+            case app_host_boundary_1.SET_APP_STATE:
+                if (request.version === exports.appPayloadVersions.setState) {
+                    const payload = request.payload;
+                    functions.setState(payload.finalState, payload.duration);
+                }
+                else {
+                    throw new app_host_boundary_1.UnsupportedRequestVerion(request.type, request.version);
+                }
+                break;
+            case app_host_boundary_1.GET_APP_PAYLOAD_VERSIONS:
+                if (request.version === 1) {
+                    const payload = request.payload;
+                    payload.callback(exports.appPayloadVersions);
+                }
+                else {
+                    throw new app_host_boundary_1.UnsupportedRequestVerion(request.type, request.version);
+                }
+                break;
+            default:
+                throw new app_host_boundary_1.UnsupportedRequestTypeError(request.type);
+        }
+    };
+    return handler;
+}
+exports.makeAppHandler = makeAppHandler;

package/lib/Interface/Controllers/defaultAppHanlderFunctions.d.ts

@@ -0,0 +1,3 @@
+import { BaseAppUC } from "../../Core";
+import { AppHandlerFunctions } from "./makeAppHandler";
+export declare function defaultAppHandlerFunctions(baseApp: BaseAppUC, startRendering: (container: HTMLElement) => void, stopRendering: () => void): AppHandlerFunctions;

package/lib/Interface/Controllers/defaultAppHanlderFunctions.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultAppHandlerFunctions = void 0;
+const setDevicePreview_1 = require("./setDevicePreview");
+const setIsAuthoring_1 = require("./setIsAuthoring");
+const setState_1 = require("./setState");
+const showBabylonInspector_1 = require("./showBabylonInspector");
+const startApp_1 = require("./startApp");
+const stopApp_1 = require("./stopApp");
+function defaultAppHandlerFunctions(baseApp, startRendering, stopRendering) {
+    const showBabylonInspector = showBabylonInspector_1.makeShowBabylonInspector(baseApp);
+    const disposeApp = () => {
+        // Todo, override this in your app if you have something to dispose.
+    };
+    const setDevicePreview = setDevicePreview_1.makeSetDevicePreview(baseApp);
+    const setIsAuthoring = setIsAuthoring_1.makeSetIsAuthoring(baseApp);
+    const startApp = startApp_1.makeStartApp(startRendering);
+    const stopApp = stopApp_1.makeStopApp(baseApp, stopRendering);
+    const setState = setState_1.makeSetState(baseApp);
+    const appHandlerFunctions = {
+        showBabylonInspector,
+        disposeApp,
+        setDevicePreview,
+        setIsAuthoring,
+        startApp,
+        stopApp,
+        setState,
+    };
+    return appHandlerFunctions;
+}
+exports.defaultAppHandlerFunctions = defaultAppHandlerFunctions;

package/lib/Interface/Controllers/dispatchStateChange.d.ts

@@ -0,0 +1,2 @@
+import { BaseAppUC } from "../../Core";
+export declare function makeDispatchStateChange(baseApp: BaseAppUC): () => void;

package/lib/Interface/Controllers/dispatchStateChange.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeDispatchStateChange = void 0;
+function makeDispatchStateChange(baseApp) {
+    return function dispatchStateChange() {
+        const state = baseApp.getSerializedState();
+        baseApp.dispatchOnStateChange(state);
+    };
+}
+exports.makeDispatchStateChange = makeDispatchStateChange;

package/lib/Interface/Controllers/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./dispatchStateChange";
+export * from "./setDevicePreview";
+export * from "./setIsAuthoring";
+export * from "./showBabylonInspector";
+export * from "./startApp";
+export * from "./stopApp";
+export * from "./makeAppHandler";
+export * from "./defaultAppHanlderFunctions";
+export * from "./setState";

package/lib/Interface/Controllers/index.js

@@ -0,0 +1,21 @@
+"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("./dispatchStateChange"), exports);
+__exportStar(require("./setDevicePreview"), exports);
+__exportStar(require("./setIsAuthoring"), exports);
+__exportStar(require("./showBabylonInspector"), exports);
+__exportStar(require("./startApp"), exports);
+__exportStar(require("./stopApp"), exports);
+__exportStar(require("./makeAppHandler"), exports);
+__exportStar(require("./defaultAppHanlderFunctions"), exports);
+__exportStar(require("./setState"), exports);

package/lib/Interface/Controllers/makeAppHandler.d.ts

@@ -0,0 +1,12 @@
+import { AppPayloadVersions, Handler } from "@vived/app-host-boundary";
+export declare const appPayloadVersions: AppPayloadVersions;
+export interface AppHandlerFunctions {
+    showBabylonInspector: (show: boolean) => void;
+    setIsAuthoring: (isAuthoring: boolean) => void;
+    disposeApp: () => void;
+    stopApp: () => void;
+    startApp: (container: HTMLElement) => void;
+    setState: (finalState: string, duration?: number) => void;
+    setDevicePreview: (x: number, y: number) => void;
+}
+export declare function makeAppHandler(functions: AppHandlerFunctions, verbose?: boolean): Handler;

package/lib/Interface/Controllers/makeAppHandler.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeAppHandler = exports.appPayloadVersions = void 0;
+const app_host_boundary_1 = require("@vived/app-host-boundary");
+exports.appPayloadVersions = {
+    disposeApp: 1,
+    setDevicePreview: 1,
+    setIsAuthoring: 1,
+    showBabylonInspector: 1,
+    startApp: 2,
+    stopApp: 1,
+    setState: 2,
+};
+function makeAppHandler(functions, verbose = false) {
+    const handler = (request) => {
+        if (verbose) {
+            console.log(request);
+        }
+        switch (request.type) {
+            case 'SHOW_BABYLON_INSPECTOR':
+                if (request.version === exports.appPayloadVersions.showBabylonInspector) {
+                    const payload = request.payload;
+                    functions.showBabylonInspector(payload.showBabylonInspector);
+                }
+                else {
+                    throw new app_host_boundary_1.UnsupportedRequestVerion(request.type, request.version);
+                }
+                break;
+            case 'SET_IS_AUTHORING':
+                if (request.version === exports.appPayloadVersions.setIsAuthoring) {
+                    const payload = request.payload;
+                    functions.setIsAuthoring(payload.isAuthoring);
+                }
+                else {
+                    throw new app_host_boundary_1.UnsupportedRequestVerion(request.type, request.version);
+                }
+                break;
+            case 'DISPOSE_APP':
+                if (request.version === exports.appPayloadVersions.disposeApp) {
+                    functions.disposeApp();
+                }
+                else {
+                    throw new app_host_boundary_1.UnsupportedRequestVerion(request.type, request.version);
+                }
+                break;
+            case 'STOP_APP':
+                if (request.version === exports.appPayloadVersions.stopApp) {
+                    functions.stopApp();
+                }
+                else {
+                    throw new app_host_boundary_1.UnsupportedRequestVerion(request.type, request.version);
+                }
+                break;
+            case 'SET_DEVICE_PREVIEW':
+                if (request.version === exports.appPayloadVersions.setDevicePreview) {
+                    const payload = request.payload;
+                    functions.setDevicePreview(payload.x, payload.y);
+                }
+                else {
+                    throw new app_host_boundary_1.UnsupportedRequestVerion(request.type, request.version);
+                }
+                break;
+            case 'START_APP':
+                if (request.version === exports.appPayloadVersions.startApp) {
+                    const payload = request.payload;
+                    functions.startApp(payload.container);
+                }
+                else {
+                    throw new app_host_boundary_1.UnsupportedRequestVerion(request.type, request.version);
+                }
+                break;
+            case 'SET_APP_STATE':
+                if (request.version === exports.appPayloadVersions.setState) {
+                    const payload = request.payload;
+                    functions.setState(payload.finalState, payload.duration);
+                }
+                else {
+                    throw new app_host_boundary_1.UnsupportedRequestVerion(request.type, request.version);
+                }
+                break;
+            case 'GET_APP_PAYLOAD_VERSION':
+                if (request.version === 1) {
+                    const payload = request.payload;
+                    payload.callback(exports.appPayloadVersions);
+                }
+                else {
+                    throw new app_host_boundary_1.UnsupportedRequestVerion(request.type, request.version);
+                }
+                break;
+            default:
+                throw new app_host_boundary_1.UnsupportedRequestTypeError(request.type);
+        }
+    };
+    return handler;
+}
+exports.makeAppHandler = makeAppHandler;

package/lib/Interface/Controllers/setDevicePreview.d.ts

@@ -0,0 +1,2 @@
+import { BaseAppUC } from "../../Core";
+export declare function makeSetDevicePreview(devicePreviewUC: BaseAppUC): (x: number, y: number) => void;

package/lib/Interface/Controllers/setDevicePreview.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSetDevicePreview = void 0;
+function makeSetDevicePreview(devicePreviewUC) {
+    return function setDevicePreview(x, y) {
+        if (x < 0 || y < 0) {
+            devicePreviewUC.clearDevicePreview();
+        }
+        else {
+            devicePreviewUC.setDevicePreview(x, y);
+        }
+    };
+}
+exports.makeSetDevicePreview = makeSetDevicePreview;

package/lib/Interface/Controllers/setIsAuthoring.d.ts

@@ -0,0 +1,2 @@
+import { BaseAppUC } from "../../Core";
+export declare function makeSetIsAuthoring(appStateUC: BaseAppUC): (isAuthoring: boolean) => void;

package/lib/Interface/Controllers/setIsAuthoring.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSetIsAuthoring = void 0;
+const dispatchStateChange_1 = require("./dispatchStateChange");
+function makeSetIsAuthoring(appStateUC) {
+    const dispatchStateChange = dispatchStateChange_1.makeDispatchStateChange(appStateUC);
+    return function setIsAuthoring(isAuthoring) {
+        appStateUC.setIsAuthoring(isAuthoring);
+        if (isAuthoring) {
+            dispatchStateChange();
+        }
+    };
+}
+exports.makeSetIsAuthoring = makeSetIsAuthoring;

package/lib/Interface/Controllers/setState.d.ts

@@ -0,0 +1,2 @@
+import { BaseAppUC } from "../../Core";
+export declare function makeSetState(baseApp: BaseAppUC): (state: string | null, duration?: number) => void;

package/lib/Interface/Controllers/setState.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSetState = void 0;
+function makeSetState(baseApp) {
+    return function setState(state, duration = 0) {
+        if (state) {
+            try {
+                const stateObj = JSON.parse(state);
+                baseApp.setSerializedState(stateObj, duration);
+            }
+            catch (e) {
+                baseApp.setDefaultState(duration);
+                console.warn("[setState] Failed to deserialize state string: " + e);
+            }
+        }
+        else {
+            baseApp.setDefaultState(duration);
+        }
+    };
+}
+exports.makeSetState = makeSetState;

package/lib/Interface/Controllers/showBabylonInspector.d.ts

@@ -0,0 +1,2 @@
+import { BaseAppUC } from "../../Core";
+export declare function makeShowBabylonInspector(appStateUC: BaseAppUC): (showInspector: boolean) => void;

package/lib/Interface/Controllers/showBabylonInspector.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeShowBabylonInspector = void 0;
+function makeShowBabylonInspector(appStateUC) {
+    return function showBabylonInspector(showInspector) {
+        appStateUC.setShowBabylonInspector(showInspector);
+    };
+}
+exports.makeShowBabylonInspector = makeShowBabylonInspector;

package/lib/Interface/Controllers/startApp.d.ts

@@ -0,0 +1 @@
+export declare function makeStartApp(startRendering: (container: HTMLElement) => void): (container: HTMLElement) => void;

package/lib/Interface/Controllers/startApp.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeStartApp = void 0;
+function makeStartApp(startRendering) {
+    return function startApp(container) {
+        startRendering(container);
+    };
+}
+exports.makeStartApp = makeStartApp;

package/lib/Interface/Controllers/stopApp.d.ts

@@ -0,0 +1,2 @@
+import { BaseAppUC } from "../../Core";
+export declare function makeStopApp(appStateUC: BaseAppUC, stopRendering: () => void): () => void;

package/lib/Interface/Controllers/stopApp.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeStopApp = void 0;
+function makeStopApp(appStateUC, stopRendering) {
+    return function stopApp() {
+        stopRendering();
+        appStateUC.setIsAuthoring(false);
+    };
+}
+exports.makeStopApp = makeStopApp;

package/lib/Interface/PresentationManagers/DevicePreviewPM.d.ts

@@ -0,0 +1,13 @@
+import { BaseAppStateObserver, BaseAppUC } from "../../Core";
+export interface DevicePreviewVM {
+    x: number;
+    y: number;
+    useDevicePreview: boolean;
+}
+export declare class DevicePreviewPM implements BaseAppStateObserver {
+    devicePreviewUC: BaseAppUC;
+    updateView: (vm: DevicePreviewVM) => void;
+    constructor(baseAppUC: BaseAppUC, updateView: (vm: DevicePreviewVM) => void);
+    onBaseAppChange: () => void;
+    dispose(): void;
+}

package/lib/Interface/PresentationManagers/DevicePreviewPM.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DevicePreviewPM = void 0;
+class DevicePreviewPM {
+    constructor(baseAppUC, updateView) {
+        this.onBaseAppChange = () => {
+            const useDevicePreview = this.devicePreviewUC.getUseDevicePreview();
+            const x = this.devicePreviewUC.getDevicePreviewSize().x;
+            const y = this.devicePreviewUC.getDevicePreviewSize().y;
+            this.updateView({
+                x,
+                y,
+                useDevicePreview,
+            });
+        };
+        this.devicePreviewUC = baseAppUC;
+        this.updateView = updateView;
+        this.onBaseAppChange();
+        this.devicePreviewUC.addObserver(this);
+    }
+    dispose() {
+        this.devicePreviewUC.removeObserver(this);
+    }
+}
+exports.DevicePreviewPM = DevicePreviewPM;

package/lib/Interface/PresentationManagers/IsAuthoringPM.d.ts

@@ -0,0 +1,10 @@
+import { BaseAppStateObserver, BaseAppUC } from "../../Core";
+export declare class IsAuthoringPM implements BaseAppStateObserver {
+    private appStateUC;
+    private updateView;
+    private lastSetState?;
+    constructor(baseAppStateUC: BaseAppUC, updateView: (isAuthoring: boolean) => void);
+    dispose(): void;
+    onBaseAppChange: () => void;
+    private doUpdateView;
+}

package/lib/Interface/PresentationManagers/IsAuthoringPM.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsAuthoringPM = void 0;
+class IsAuthoringPM {
+    constructor(baseAppStateUC, updateView) {
+        this.onBaseAppChange = this.doUpdateView;
+        this.appStateUC = baseAppStateUC;
+        this.updateView = updateView;
+        this.doUpdateView();
+        this.appStateUC.addObserver(this);
+    }
+    dispose() {
+        this.appStateUC.removeObserver(this);
+    }
+    doUpdateView() {
+        const isAuthoring = this.appStateUC.getIsAuthoring();
+        if (isAuthoring === this.lastSetState)
+            return;
+        this.updateView(isAuthoring);
+        this.lastSetState = isAuthoring;
+    }
+}
+exports.IsAuthoringPM = IsAuthoringPM;

package/lib/Interface/PresentationManagers/ShowBabylonInspectorPM.d.ts

@@ -0,0 +1,10 @@
+import { BaseAppStateObserver, BaseAppUC } from "../../Core";
+export declare class ShowBabylonInspectorPM implements BaseAppStateObserver {
+    private appStateUC;
+    private updateView;
+    private lastSetState?;
+    constructor(baseAppStateUC: BaseAppUC, updateView: (showInspector: boolean) => void);
+    dispose(): void;
+    onBaseAppChange: () => void;
+    private doUpdateView;
+}