@vived/app 3.8.0 → 3.9.1

package/lib/AppObjectComponents/App/UseCase/submitError.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.submitError = void 0;
+const Dispatcher_1 = require("../../Dispatcher");
+const LogUC_1 = require("../../Dispatcher/UC/LogUC");
+function submitError(sender, message, appObjects, showAlert = true) {
+    const logUC = LogUC_1.LogUC.get(appObjects);
+    if (logUC) {
+        logUC.error(sender, message);
+    }
+    else {
+        console.error(`[${sender}]: ${message}`);
+    }
+    if (!showAlert)
+        return;
+    const alert = Dispatcher_1.ShowAlertUC.get(appObjects);
+    if (!alert)
+        return;
+    alert.showAlert({
+        title: "Error",
+        closeButtonLabel: "Close",
+        closeCallback: () => { },
+        message: `[${sender}]: ${message}`
+    });
+}
+exports.submitError = submitError;

package/lib/AppObjectComponents/App/UseCase/submitFatal.d.ts

@@ -0,0 +1,2 @@
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+export declare function submitFatal(sender: string, message: string, appObjects: AppObjectRepo, showAlert?: boolean): void;

package/lib/AppObjectComponents/App/UseCase/submitFatal.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.submitFatal = void 0;
+const Dispatcher_1 = require("../../Dispatcher");
+const LogUC_1 = require("../../Dispatcher/UC/LogUC");
+function submitFatal(sender, message, appObjects, showAlert = true) {
+    const logUC = LogUC_1.LogUC.get(appObjects);
+    if (logUC) {
+        logUC.fatal(sender, message);
+    }
+    else {
+        console.error(`[${sender}]: ${message}`);
+    }
+    if (!showAlert)
+        return;
+    const alert = Dispatcher_1.ShowAlertUC.get(appObjects);
+    if (!alert)
+        return;
+    alert.showAlert({
+        title: "Fatal Error",
+        closeButtonLabel: "Close",
+        closeCallback: () => { },
+        message: `[${sender}]: ${message}`
+    });
+}
+exports.submitFatal = submitFatal;

package/lib/AppObjectComponents/App/UseCase/submitLog.d.ts

@@ -0,0 +1,2 @@
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+export declare function submitLog(sender: string, message: string, appObjects: AppObjectRepo, showAlert?: boolean): void;

package/lib/AppObjectComponents/App/UseCase/submitLog.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.submitLog = void 0;
+const Dispatcher_1 = require("../../Dispatcher");
+const LogUC_1 = require("../../Dispatcher/UC/LogUC");
+function submitLog(sender, message, appObjects, showAlert = false) {
+    const logUC = LogUC_1.LogUC.get(appObjects);
+    if (logUC) {
+        logUC.log(sender, message);
+    }
+    else {
+        console.log(`[${sender}]: ${message}`);
+    }
+    if (!showAlert)
+        return;
+    const alert = Dispatcher_1.ShowAlertUC.get(appObjects);
+    if (!alert)
+        return;
+    alert.showAlert({
+        title: "Log",
+        closeButtonLabel: "Close",
+        closeCallback: () => { },
+        message: `[${sender}]: ${message}`
+    });
+}
+exports.submitLog = submitLog;

package/lib/AppObjectComponents/App/UseCase/submitRenderCanvas.d.ts

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

package/lib/AppObjectComponents/App/UseCase/submitRenderCanvas.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.submitRenderCanvas = void 0;
+const KeyboardInput_1 = require("../../KeyboardInput");
+const MouseInput_1 = require("../../MouseInput");
+const TouchController_1 = require("../../TouchController");
+const Babylon_1 = require("../../Babylon");
+function submitRenderCanvas(renderCanvas, appObjects) {
+    Babylon_1.submitRenderCanvasToBabylon(renderCanvas, appObjects);
+    const keyboardInput = KeyboardInput_1.KeyboardInputEntity.get(appObjects);
+    if (keyboardInput) {
+        keyboardInput.setEventElement(renderCanvas);
+    }
+    const touchInput = TouchController_1.TouchInputEntity.get(appObjects);
+    if (touchInput) {
+        touchInput.setEventElement(renderCanvas);
+    }
+    const mouseInput = MouseInput_1.MouseInputEntity.get(appObjects);
+    if (mouseInput) {
+        mouseInput.setEventElement(renderCanvas);
+    }
+    renderCanvas.addEventListener("contextmenu", function (e) {
+        e.preventDefault();
+    }, false);
+}
+exports.submitRenderCanvas = submitRenderCanvas;

package/lib/AppObjectComponents/App/UseCase/submitWarning.d.ts

@@ -0,0 +1,2 @@
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+export declare function submitWarning(sender: string, message: string, appObjects: AppObjectRepo, showAlert?: boolean): void;

package/lib/AppObjectComponents/App/UseCase/submitWarning.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.submitWarning = void 0;
+const Dispatcher_1 = require("../../Dispatcher");
+const LogUC_1 = require("../../Dispatcher/UC/LogUC");
+function submitWarning(sender, message, appObjects, showAlert = false) {
+    const logUC = LogUC_1.LogUC.get(appObjects);
+    if (logUC) {
+        logUC.warn(sender, message);
+    }
+    else {
+        console.warn(`[${sender}]: ${message}`);
+    }
+    if (!showAlert)
+        return;
+    const alert = Dispatcher_1.ShowAlertUC.get(appObjects);
+    if (!alert)
+        return;
+    alert.showAlert({
+        title: "Warning",
+        closeButtonLabel: "Close",
+        closeCallback: () => { },
+        message: `[${sender}]: ${message}`
+    });
+}
+exports.submitWarning = submitWarning;

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

@@ -0,0 +1,14 @@
+export * from "./Entity/BaseAppState";
+export * from "./UseCase/AppRenderingUC";
+export * from "./UseCase/EditSlideTextUC";
+export * from "./UseCase/RenderCanvasUC";
+export * from "./UseCase/submitError";
+export * from "./UseCase/submitFatal";
+export * from "./UseCase/submitLog";
+export * from "./UseCase/submitWarning";
+export * from "./PM/IsAuthoringPM";
+export * from "./PM/IsReviewingPM";
+export * from "./PM/SlideTextPM";
+export * from "./Controller/clickEditSlideText";
+export * from "./Controller/removeRenderCanvas";
+export * from "./Controller/submitRenderCanvas";

package/lib/AppObjectComponents/App/index.js

@@ -0,0 +1,26 @@
+"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/EditSlideTextUC"), 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("./PM/SlideTextPM"), exports);
+__exportStar(require("./Controller/clickEditSlideText"), 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;