@vived/app 3.8.0 → 3.9.0

package/lib/AppObjectComponents/App/index.js

@@ -0,0 +1,23 @@
+"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/BaseAppState"), exports);
+__exportStar(require("./UseCase/AppRenderingUC"), exports);
+__exportStar(require("./UseCase/RenderCanvasUC"), exports);
+__exportStar(require("./UseCase/submitError"), exports);
+__exportStar(require("./UseCase/submitFatal"), exports);
+__exportStar(require("./UseCase/submitLog"), exports);
+__exportStar(require("./UseCase/submitWarning"), exports);
+__exportStar(require("./PM/IsAuthoringPM"), exports);
+__exportStar(require("./PM/IsReviewingPM"), exports);
+__exportStar(require("./Controller/removeRenderCanvas"), exports);
+__exportStar(require("./Controller/submitRenderCanvas"), exports);

package/lib/AppObjectComponents/Babylon/Entities/BabylonEntity.d.ts

@@ -0,0 +1,16 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectEntity } from "../../../AppObject/AppObjectEntity";
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+export declare abstract class BabylonEntity extends AppObjectEntity {
+    static readonly type = "BabylonEntity";
+    abstract engine: unknown;
+    abstract scene: unknown;
+    abstract workingCanvas?: HTMLCanvasElement;
+    abstract showInspector: boolean;
+    abstract renderCanvas?: HTMLCanvasElement;
+    abstract isRendering: boolean;
+    abstract makeAppObjectMeta: (id: string) => object;
+    abstract getAppObjectIDFromMeta: (meta: object | undefined) => string | undefined;
+    static get(appObjects: AppObjectRepo): BabylonEntity | undefined;
+}
+export declare function makeBabylonEntity(appObject: AppObject): BabylonEntity;

package/lib/AppObjectComponents/Babylon/Entities/BabylonEntity.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeBabylonEntity = exports.BabylonEntity = void 0;
+const AppObjectEntity_1 = require("../../../AppObject/AppObjectEntity");
+const Entities_1 = require("../../../Entities");
+const ValueObjects_1 = require("../../../ValueObjects");
+class BabylonEntity extends AppObjectEntity_1.AppObjectEntity {
+    static get(appObjects) {
+        const selectionEntities = appObjects.getAllComponents(BabylonEntity.type);
+        if (selectionEntities.length === 0) {
+            console.warn(`Unable to find component ${BabylonEntity.type}. Add one on Mount`);
+            return undefined;
+        }
+        else if (selectionEntities.length > 1) {
+            console.warn(`Multiple ${BabylonEntity.type} found. There should only be one. Using the first one`);
+        }
+        return selectionEntities[0];
+    }
+}
+exports.BabylonEntity = BabylonEntity;
+BabylonEntity.type = "BabylonEntity";
+function makeBabylonEntity(appObject) {
+    return new BabylonEntityImp(appObject);
+}
+exports.makeBabylonEntity = makeBabylonEntity;
+class BabylonEntityImp extends BabylonEntity {
+    constructor(appObject) {
+        super(appObject, BabylonEntity.type);
+        this.memoizedShowInspector = new Entities_1.MemoizedBoolean(false, this.notifyOnChange);
+        this.memoizedCanvasSize = new Entities_1.MemoizedVector2(ValueObjects_1.Vector2.One(), this.notifyOnChange);
+        this.memoizedIsRendering = new Entities_1.MemoizedBoolean(false, this.notifyOnChange);
+        this.makeAppObjectMeta = (id) => {
+            return { appObjectID: id };
+        };
+        this.getAppObjectIDFromMeta = (meta) => {
+            if (meta === null || meta === void 0 ? void 0 : meta.hasOwnProperty("appObjectID")) {
+                return meta.appObjectID;
+            }
+            else {
+                return;
+            }
+        };
+    }
+    get workingCanvas() {
+        return this._workingCanvas;
+    }
+    set workingCanvas(canvas) {
+        if (canvas === this._workingCanvas)
+            return;
+        this._workingCanvas = canvas;
+        this.notifyOnChange();
+    }
+    get renderCanvas() {
+        return this._renderCanvas;
+    }
+    set renderCanvas(canvas) {
+        if (canvas === this._renderCanvas)
+            return;
+        this._renderCanvas = canvas;
+        this.notifyOnChange();
+    }
+    get showInspector() {
+        return this.memoizedShowInspector.val;
+    }
+    set showInspector(val) {
+        this.memoizedShowInspector.val = val;
+    }
+    get canvasSize() {
+        return this.memoizedCanvasSize.val;
+    }
+    set canvasSize(val) {
+        this.memoizedCanvasSize.val = val;
+    }
+    get isRendering() {
+        return this.memoizedIsRendering.val;
+    }
+    set isRendering(val) {
+        this.memoizedIsRendering.val = val;
+    }
+}

package/lib/AppObjectComponents/Babylon/Factory/makeBabylon.d.ts

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

package/lib/AppObjectComponents/Babylon/Factory/makeBabylon.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeBabylon = void 0;
+const BabylonEntity_1 = require("../Entities/BabylonEntity");
+const ShowBabylonInspectorPM_1 = require("../PresentationManangers/ShowBabylonInspectorPM");
+function makeBabylon(appObjects) {
+    const appObj = appObjects.getOrCreate("Babylon");
+    BabylonEntity_1.makeBabylonEntity(appObj);
+    new ShowBabylonInspectorPM_1.ShowBabylonInspectorPM(appObj);
+}
+exports.makeBabylon = makeBabylon;

package/lib/AppObjectComponents/Babylon/Mocks/MockBabylonRenderingUC.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="jest" />
+import { AppObject } from "../../../AppObject/AppObject";
+import { BabylonRenderingUC } from "../UseCases/BabylonRenderingUC";
+export declare class MockBabylonRenderingUC extends BabylonRenderingUC {
+    submitRenderCanvas: jest.Mock<any, any>;
+    clearRenderCanvas: jest.Mock<any, any>;
+    resize: jest.Mock<any, any>;
+    constructor(appObject: AppObject);
+}

package/lib/AppObjectComponents/Babylon/Mocks/MockBabylonRenderingUC.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockBabylonRenderingUC = void 0;
+const BabylonRenderingUC_1 = require("../UseCases/BabylonRenderingUC");
+class MockBabylonRenderingUC extends BabylonRenderingUC_1.BabylonRenderingUC {
+    constructor(appObject) {
+        super(appObject, BabylonRenderingUC_1.BabylonRenderingUC.type);
+        this.submitRenderCanvas = jest.fn();
+        this.clearRenderCanvas = jest.fn();
+        this.resize = jest.fn();
+    }
+}
+exports.MockBabylonRenderingUC = MockBabylonRenderingUC;

package/lib/AppObjectComponents/Babylon/PresentationManangers/ShowBabylonInspectorPM.d.ts

@@ -0,0 +1,8 @@
+import { AppObject, AppObjectPM } from "../../../AppObject";
+export declare class ShowBabylonInspectorPM extends AppObjectPM<boolean> {
+    static readonly type = "ShowBabylonInspectorPM";
+    private babylon?;
+    vmsAreEqual(a: boolean, b: boolean): boolean;
+    onBabylonChange: () => void;
+    constructor(appObject: AppObject);
+}

package/lib/AppObjectComponents/Babylon/PresentationManangers/ShowBabylonInspectorPM.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShowBabylonInspectorPM = void 0;
+const AppObject_1 = require("../../../AppObject");
+const AppObjectComponents_1 = require("../../../AppObjectComponents");
+const BabylonEntity_1 = require("../Entities/BabylonEntity");
+class ShowBabylonInspectorPM extends AppObject_1.AppObjectPM {
+    constructor(appObject) {
+        super(appObject, ShowBabylonInspectorPM.type);
+        this.onBabylonChange = () => {
+            if (!this.babylon)
+                return;
+            this.doUpdateView(this.babylon.showInspector);
+        };
+        this.babylon = appObject.getComponent(BabylonEntity_1.BabylonEntity.type);
+        if (!this.babylon) {
+            AppObjectComponents_1.submitWarning("ShowBabylonInspectorPM", "Unable to find BabylonEntity", appObject.appObjectRepo);
+            return;
+        }
+        this.babylon.addChangeObserver(this.onBabylonChange);
+        this.onBabylonChange();
+    }
+    vmsAreEqual(a, b) {
+        return a === b;
+    }
+}
+exports.ShowBabylonInspectorPM = ShowBabylonInspectorPM;
+ShowBabylonInspectorPM.type = "ShowBabylonInspectorPM";

package/lib/AppObjectComponents/Babylon/UseCases/BabylonRenderingUC.d.ts

@@ -0,0 +1,9 @@
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+export declare abstract class BabylonRenderingUC extends AppObjectUC {
+    static readonly type = "BabylonRenderingUC";
+    abstract submitRenderCanvas: (canvas: HTMLCanvasElement) => void;
+    abstract clearRenderCanvas: () => void;
+    abstract resize: () => void;
+    static get(appObjects: AppObjectRepo): BabylonRenderingUC | undefined;
+}

package/lib/AppObjectComponents/Babylon/UseCases/BabylonRenderingUC.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BabylonRenderingUC = void 0;
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const App_1 = require("../../App");
+class BabylonRenderingUC extends AppObjectUC_1.AppObjectUC {
+    static get(appObjects) {
+        const selectionEntities = appObjects.getAllComponents(BabylonRenderingUC.type);
+        if (selectionEntities.length === 0) {
+            App_1.submitWarning(BabylonRenderingUC.type, `Unable to find component ${BabylonRenderingUC.type}. Add one on Mount`, appObjects);
+            return undefined;
+        }
+        else if (selectionEntities.length > 1) {
+            App_1.submitWarning(BabylonRenderingUC.type, `Multiple ${BabylonRenderingUC.type} found. There should only be one. Using the first one`, appObjects);
+        }
+        return selectionEntities[0];
+    }
+}
+exports.BabylonRenderingUC = BabylonRenderingUC;
+BabylonRenderingUC.type = "BabylonRenderingUC";

package/lib/AppObjectComponents/Babylon/UseCases/PixelToSceneRayUC.d.ts

@@ -0,0 +1,9 @@
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+import { ParametricLine, Vector2 } from "../../../ValueObjects";
+export declare abstract class PixelToSceneRayUC extends AppObjectUC {
+    static readonly type = "PixelToSceneRayUC";
+    abstract pixelToSceneRay: (pixelPos: Vector2) => ParametricLine;
+    static get(appObjects: AppObjectRepo): PixelToSceneRayUC | undefined;
+}
+export declare function pixelToSceneRay(pixelPos: Vector2, appObjects: AppObjectRepo): ParametricLine;

package/lib/AppObjectComponents/Babylon/UseCases/PixelToSceneRayUC.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pixelToSceneRay = exports.PixelToSceneRayUC = void 0;
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const ValueObjects_1 = require("../../../ValueObjects");
+const App_1 = require("../../App");
+class PixelToSceneRayUC extends AppObjectUC_1.AppObjectUC {
+    static get(appObjects) {
+        const components = appObjects.getAllComponents(PixelToSceneRayUC.type);
+        if (components.length === 0) {
+            App_1.submitWarning(PixelToSceneRayUC.type, `Unable to find component ${PixelToSceneRayUC.type}. Add one on Mount`, appObjects);
+            return undefined;
+        }
+        else if (components.length > 1) {
+            App_1.submitWarning(PixelToSceneRayUC.type, `Multiple ${PixelToSceneRayUC.type} found. There should only be one. Using the first one`, appObjects);
+        }
+        return components[0];
+    }
+}
+exports.PixelToSceneRayUC = PixelToSceneRayUC;
+PixelToSceneRayUC.type = "PixelToSceneRayUC";
+function pixelToSceneRay(pixelPos, appObjects) {
+    const uc = PixelToSceneRayUC.get(appObjects);
+    if (!uc) {
+        App_1.submitWarning("pixelToSceneRay", "Unable to find PixelToSceneRayUC", appObjects);
+        return ValueObjects_1.ParametricLine.Forward();
+    }
+    return uc.pixelToSceneRay(pixelPos);
+}
+exports.pixelToSceneRay = pixelToSceneRay;

package/lib/AppObjectComponents/Babylon/UseCases/ScenePixelPickUC.d.ts

@@ -0,0 +1,17 @@
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+import { ParametricLine, Vector2, Vector3 } from "../../../ValueObjects";
+export interface ScenePixelPick {
+    sceneRay: ParametricLine;
+    hit: boolean;
+    worldPickPoint?: Vector3;
+    objectPickMeta?: object;
+    appObjectID?: string;
+    normal?: Vector3;
+}
+export declare abstract class ScenePixelPickUC extends AppObjectUC {
+    static readonly type = "ScenePixelPickUC";
+    abstract scenePixelPick: (pixelPos: Vector2) => ScenePixelPick | undefined;
+    static get(appObjects: AppObjectRepo): ScenePixelPickUC | undefined;
+}
+export declare function scenePixelPick(pixelPos: Vector2, appObjects: AppObjectRepo): ScenePixelPick | undefined;

package/lib/AppObjectComponents/Babylon/UseCases/ScenePixelPickUC.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scenePixelPick = exports.ScenePixelPickUC = void 0;
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const App_1 = require("../../App");
+class ScenePixelPickUC extends AppObjectUC_1.AppObjectUC {
+    static get(appObjects) {
+        const components = appObjects.getAllComponents(ScenePixelPickUC.type);
+        if (components.length === 0) {
+            App_1.submitWarning(ScenePixelPickUC.type, `Unable to find component ${ScenePixelPickUC.type}. Add one on Mount`, appObjects);
+            return undefined;
+        }
+        else if (components.length > 1) {
+            App_1.submitWarning(ScenePixelPickUC.type, `Multiple ${ScenePixelPickUC.type} found. There should only be one. Using the first one`, appObjects);
+        }
+        return components[0];
+    }
+}
+exports.ScenePixelPickUC = ScenePixelPickUC;
+ScenePixelPickUC.type = "ScenePixelPickUC";
+function scenePixelPick(pixelPos, appObjects) {
+    const uc = ScenePixelPickUC.get(appObjects);
+    if (!uc) {
+        App_1.submitWarning("scenePixelPick", "Unable to find ScenePixelPickUC", appObjects);
+        return;
+    }
+    return uc.scenePixelPick(pixelPos);
+}
+exports.scenePixelPick = scenePixelPick;

package/lib/AppObjectComponents/Babylon/UseCases/SceneRayPickUC.d.ts

@@ -0,0 +1,16 @@
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+import { ParametricLine, Vector3 } from "../../../ValueObjects";
+export interface SceneRayPick {
+    hit: boolean;
+    worldPickPoint?: Vector3;
+    objectPickMeta?: object;
+    appObjectID?: string;
+    normal?: Vector3;
+}
+export declare abstract class SceneRayPickUC extends AppObjectUC {
+    static readonly type = "SceneRayPickUC";
+    abstract sceneRayPick: (ray: ParametricLine) => SceneRayPick | undefined;
+    static get(appObjects: AppObjectRepo): SceneRayPickUC | undefined;
+}
+export declare function sceneRayPick(ray: ParametricLine, appObjects: AppObjectRepo): SceneRayPick | undefined;

package/lib/AppObjectComponents/Babylon/UseCases/SceneRayPickUC.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sceneRayPick = exports.SceneRayPickUC = void 0;
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const App_1 = require("../../App");
+class SceneRayPickUC extends AppObjectUC_1.AppObjectUC {
+    static get(appObjects) {
+        const selectionEntities = appObjects.getAllComponents(SceneRayPickUC.type);
+        if (selectionEntities.length === 0) {
+            App_1.submitWarning(SceneRayPickUC.type, `Unable to find component ${SceneRayPickUC.type}. Add one on Mount`, appObjects);
+            return undefined;
+        }
+        else if (selectionEntities.length > 1) {
+            App_1.submitWarning(SceneRayPickUC.type, `Multiple ${SceneRayPickUC.type} found. There should only be one. Using the first one`, appObjects);
+        }
+        return selectionEntities[0];
+    }
+}
+exports.SceneRayPickUC = SceneRayPickUC;
+SceneRayPickUC.type = "SceneRayPickUC";
+function sceneRayPick(ray, appObjects) {
+    const uc = SceneRayPickUC.get(appObjects);
+    if (!uc) {
+        App_1.submitWarning("sceneRayPick", "Unable to find SceneRayPickUC", appObjects);
+        return;
+    }
+    return uc.sceneRayPick(ray);
+}
+exports.sceneRayPick = sceneRayPick;

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

@@ -0,0 +1,7 @@
+export * from "./Entities/BabylonEntity";
+export * from "./UseCases/PixelToSceneRayUC";
+export * from "./UseCases/ScenePixelPickUC";
+export * from "./UseCases/SceneRayPickUC";
+export * from "./UseCases/BabylonRenderingUC";
+export * from "./PresentationManangers/ShowBabylonInspectorPM";
+export * from "./Factory/makeBabylon";

package/lib/AppObjectComponents/Babylon/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/BabylonEntity"), exports);
+__exportStar(require("./UseCases/PixelToSceneRayUC"), exports);
+__exportStar(require("./UseCases/ScenePixelPickUC"), exports);
+__exportStar(require("./UseCases/SceneRayPickUC"), exports);
+__exportStar(require("./UseCases/BabylonRenderingUC"), exports);
+__exportStar(require("./PresentationManangers/ShowBabylonInspectorPM"), exports);
+__exportStar(require("./Factory/makeBabylon"), exports);

package/lib/AppObjectComponents/ChannelModel/UseCases/ProcessChannelModelUC.d.ts

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

package/lib/AppObjectComponents/ChannelModel/UseCases/ProcessChannelModelUC.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProcessChannelModelUC = void 0;
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+class ProcessChannelModelUC extends AppObjectUC_1.AppObjectUC {
+    static get(appObjects) {
+        const selectionEntities = appObjects.getAllComponents(ProcessChannelModelUC.type);
+        if (selectionEntities.length === 0) {
+            console.warn(`Unable to find component ${ProcessChannelModelUC.type}. Add one on Mount`);
+            return undefined;
+        }
+        else if (selectionEntities.length > 1) {
+            console.warn(`Multiple ${ProcessChannelModelUC.type} found. There should only be one. Using the first one`);
+        }
+        return selectionEntities[0];
+    }
+}
+exports.ProcessChannelModelUC = ProcessChannelModelUC;
+ProcessChannelModelUC.type = "ProcessChannelModelUC";

package/lib/AppObjectComponents/ChannelModel/UseCases/SelectChannelModelUC.d.ts

@@ -0,0 +1,9 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+export declare abstract class SelectChannelModelUC extends AppObjectUC {
+    static readonly type: string;
+    abstract selectChannelModel: () => Promise<string>;
+    static get(appObjects: AppObjectRepo): SelectChannelModelUC | undefined;
+}
+export declare function makeSelectChannelModelUC(appObject: AppObject): SelectChannelModelUC;

package/lib/AppObjectComponents/ChannelModel/UseCases/SelectChannelModelUC.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSelectChannelModelUC = exports.SelectChannelModelUC = void 0;
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const Dispatcher_1 = require("../../Dispatcher");
+const SceneRoot_1 = require("../../SceneRoot");
+const SetupChannelModelUC_1 = require("./SetupChannelModelUC");
+class SelectChannelModelUC extends AppObjectUC_1.AppObjectUC {
+    static get(appObjects) {
+        const selectionEntities = appObjects.getAllComponents(SelectChannelModelUC.type);
+        if (selectionEntities.length === 0) {
+            console.warn(`Unable to find component ${SelectChannelModelUC.type}. Add one on Mount`);
+            return undefined;
+        }
+        else if (selectionEntities.length > 1) {
+            console.warn(`Multiple ${SelectChannelModelUC.type} found. There should only be one. Using the first one`);
+        }
+        return selectionEntities[0];
+    }
+}
+exports.SelectChannelModelUC = SelectChannelModelUC;
+SelectChannelModelUC.type = "SelectChannelModelUC";
+function makeSelectChannelModelUC(appObject) {
+    return new SelectChannelModelUCImp(appObject);
+}
+exports.makeSelectChannelModelUC = makeSelectChannelModelUC;
+class SelectChannelModelUCImp extends SelectChannelModelUC {
+    constructor(appObject) {
+        super(appObject, SelectChannelModelUC.type);
+        this.selectChannelModel = () => {
+            return new Promise((resolve, reject) => {
+                const appObjects = this.appObject.appObjectRepo;
+                const setupChannelModelUC = SetupChannelModelUC_1.SetupChannelModelUC.get(appObjects);
+                if (!setupChannelModelUC) {
+                    console.warn("Unable to get setupChannelModelUC from the model repo App Object");
+                    reject(new Error("Unable to get setupChannelModelUC from the model repo App Object"));
+                    return;
+                }
+                const showSelectModel = Dispatcher_1.ShowSelectModelUC.get(appObjects);
+                if (!showSelectModel) {
+                    console.warn("Unable to find show select model UC");
+                    reject(new Error("Unable to find show select model UC"));
+                    return;
+                }
+                let modelID = "";
+                showSelectModel.doDispatch().then(resp => {
+                    modelID = resp.modelId;
+                    return setupChannelModelUC.setupChannelModel(modelID);
+                }).then(channelModel => {
+                    const sceneRoot = SceneRoot_1.SceneRoot.get(appObjects);
+                    if (!sceneRoot)
+                        return;
+                    sceneRoot.position = channelModel.defaultPosition;
+                    sceneRoot.rotation = channelModel.defaultRotation;
+                    sceneRoot.scale = channelModel.defaultScale;
+                    resolve(modelID);
+                }).catch(e => {
+                    reject(e);
+                });
+            });
+        };
+    }
+}

package/lib/AppObjectComponents/ChannelModel/UseCases/SetupChannelModelUC.d.ts

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

package/lib/AppObjectComponents/ChannelModel/UseCases/SetupChannelModelUC.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetupChannelModelUC = exports.SCENE_MODEL_DATA_ASSET_LINK_TYPE = void 0;
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+exports.SCENE_MODEL_DATA_ASSET_LINK_TYPE = "default_model_data";
+class SetupChannelModelUC extends AppObjectUC_1.AppObjectUC {
+    static get(appObjects) {
+        const selectionEntities = appObjects.getAllComponents(SetupChannelModelUC.type);
+        if (selectionEntities.length === 0) {
+            console.warn(`Unable to find component ${SetupChannelModelUC.type}. Add one on Mount`);
+            return undefined;
+        }
+        else if (selectionEntities.length > 1) {
+            console.warn(`Multiple ${SetupChannelModelUC.type} found. There should only be one. Using the first one`);
+        }
+        return selectionEntities[0];
+    }
+}
+exports.SetupChannelModelUC = SetupChannelModelUC;
+SetupChannelModelUC.type = "SetupChannelModelUC";
+SetupChannelModelUC.SCENE_MODEL_DATA_ASSET_LINK_TYPE = "default_model_data";

package/lib/AppObjectComponents/Dispatcher/Mocks/MockDispatchStateChange.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="jest" />
+import { AppObject } from "../../../AppObject/AppObject";
+import { DispatchStateChangeUC } from "../UC/DispatchStateChangeUC";
+export declare class MockDispatchStateChange extends DispatchStateChangeUC {
+    validateState: jest.Mock<any, any>;
+    getStateAssets: jest.Mock<any, any>;
+    doDispatch: jest.Mock<any, any>;
+    constructor(appObject: AppObject);
+}

package/lib/AppObjectComponents/Dispatcher/Mocks/MockDispatchStateChange.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockDispatchStateChange = void 0;
+const DispatchStateChangeUC_1 = require("../UC/DispatchStateChangeUC");
+class MockDispatchStateChange extends DispatchStateChangeUC_1.DispatchStateChangeUC {
+    constructor(appObject) {
+        super(appObject, DispatchStateChangeUC_1.DispatchStateChangeUC.type);
+        this.validateState = jest.fn();
+        this.getStateAssets = jest.fn();
+        this.doDispatch = jest.fn();
+    }
+}
+exports.MockDispatchStateChange = MockDispatchStateChange;

package/lib/AppObjectComponents/Dispatcher/Mocks/MockDispatcher.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="jest" />
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppDispatcher } from "../Entities/AppDispatcher";
+export declare class MockDispatcher extends AppDispatcher {
+    dispatch: jest.Mock<any, any>;
+    formRequestAndDispatch: jest.Mock<any, any>;
+    constructor(appObject: AppObject);
+}

package/lib/AppObjectComponents/Dispatcher/Mocks/MockDispatcher.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockDispatcher = void 0;
+const AppDispatcher_1 = require("../Entities/AppDispatcher");
+class MockDispatcher extends AppDispatcher_1.AppDispatcher {
+    constructor(appObject) {
+        super(appObject, AppDispatcher_1.AppDispatcher.type);
+        this.dispatch = jest.fn();
+        this.formRequestAndDispatch = jest.fn();
+    }
+}
+exports.MockDispatcher = MockDispatcher;

package/lib/AppObjectComponents/Dispatcher/Mocks/MockLogUC.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="jest" />
+import { AppObject } from "../../../AppObject/AppObject";
+import { LogUC } from "../UC/LogUC";
+export declare class MockLogUC extends LogUC {
+    log: jest.Mock<any, any>;
+    warn: jest.Mock<any, any>;
+    error: jest.Mock<any, any>;
+    fatal: jest.Mock<any, any>;
+    constructor(appObject: AppObject);
+}

package/lib/AppObjectComponents/Dispatcher/Mocks/MockLogUC.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockLogUC = void 0;
+const LogUC_1 = require("../UC/LogUC");
+class MockLogUC extends LogUC_1.LogUC {
+    constructor(appObject) {
+        super(appObject, LogUC_1.LogUC.type);
+        this.log = jest.fn();
+        this.warn = jest.fn();
+        this.error = jest.fn();
+        this.fatal = jest.fn();
+    }
+}
+exports.MockLogUC = MockLogUC;

package/lib/AppObjectComponents/Dispatcher/UC/AppIsReadyUC.d.ts

@@ -0,0 +1,11 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+export declare abstract class AppIsReadyUC extends AppObjectUC {
+    static readonly type = "AppIsReadyUC";
+    readonly requestType = "APP_IS_READY";
+    abstract doDispatch(): void;
+    static get(appObjects: AppObjectRepo): AppIsReadyUC | undefined;
+}
+export declare function makeAppIsReadyUC(appObject: AppObject): AppIsReadyUC;
+export declare function appIsReady(appObjects: AppObjectRepo): void;