@vived/app 3.8.0 → 3.9.1

package/lib/AppObjectComponents/App/Controller/clickEditSlideText.d.ts

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

package/lib/AppObjectComponents/App/Controller/clickEditSlideText.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clickEditSlideText = void 0;
+const EditSlideTextUC_1 = require("../UseCase/EditSlideTextUC");
+const submitWarning_1 = require("../UseCase/submitWarning");
+function clickEditSlideText(appObjects) {
+    const uc = EditSlideTextUC_1.EditSlideTextUC.get(appObjects);
+    if (!uc) {
+        submitWarning_1.submitWarning("clickEditSlideText", "Unable to find EditSlideTextUC", appObjects);
+        return;
+    }
+    uc.editSlideText();
+}
+exports.clickEditSlideText = clickEditSlideText;

package/lib/AppObjectComponents/App/Controller/removeRenderCanvas.d.ts

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

package/lib/AppObjectComponents/App/Controller/removeRenderCanvas.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeRenderCanvas = void 0;
+const RenderCanvasUC_1 = require("../UseCase/RenderCanvasUC");
+const submitWarning_1 = require("../UseCase/submitWarning");
+function removeRenderCanvas(appObjects) {
+    const uc = RenderCanvasUC_1.RenderCanvasUC.get(appObjects);
+    if (!uc) {
+        submitWarning_1.submitWarning("removeRenderCanvas", "Unable to find Render Canvas UC", appObjects);
+        return;
+    }
+    uc.clearCanvas();
+}
+exports.removeRenderCanvas = removeRenderCanvas;

package/lib/AppObjectComponents/App/Controller/startRenderingApp.d.ts

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

package/lib/AppObjectComponents/App/Controller/startRenderingApp.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startRenderingApp = void 0;
+const AppRenderingUC_1 = require("../UseCase/AppRenderingUC");
+const submitWarning_1 = require("../UseCase/submitWarning");
+function startRenderingApp(container, appObjects) {
+    const uc = AppRenderingUC_1.AppRenderingUC.get(appObjects);
+    if (!uc) {
+        submitWarning_1.submitWarning("startRenderingApp", "Unable to find AppRenderingUC", appObjects);
+        return;
+    }
+    uc.startRendering(container);
+}
+exports.startRenderingApp = startRenderingApp;

package/lib/AppObjectComponents/App/Controller/stopRenderingApp.d.ts

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

package/lib/AppObjectComponents/App/Controller/stopRenderingApp.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stopRenderingApp = void 0;
+const AppRenderingUC_1 = require("../UseCase/AppRenderingUC");
+const submitWarning_1 = require("../UseCase/submitWarning");
+function stopRenderingApp(appObjects) {
+    const uc = AppRenderingUC_1.AppRenderingUC.get(appObjects);
+    if (!uc) {
+        submitWarning_1.submitWarning("stopRenderingApp", "Unable to find AppRenderingUC", appObjects);
+        return;
+    }
+    uc.stopRendering();
+}
+exports.stopRenderingApp = stopRenderingApp;

package/lib/AppObjectComponents/App/Controller/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/Controller/submitRenderCanvas.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.submitRenderCanvas = void 0;
+const RenderCanvasUC_1 = require("../UseCase/RenderCanvasUC");
+const submitWarning_1 = require("../UseCase/submitWarning");
+function submitRenderCanvas(renderCanvas, appObjects) {
+    const uc = RenderCanvasUC_1.RenderCanvasUC.get(appObjects);
+    if (!uc) {
+        submitWarning_1.submitWarning("submitRenderCanvas", "Unable to find Render Canvas UC", appObjects);
+        return;
+    }
+    uc.submitCanvas(renderCanvas);
+}
+exports.submitRenderCanvas = submitRenderCanvas;

package/lib/AppObjectComponents/App/Entity/BaseAppState.d.ts

@@ -0,0 +1,14 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectEntity } from "../../../AppObject/AppObjectEntity";
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+export declare abstract class BaseAppState extends AppObjectEntity {
+    static readonly type = "BaseAppState";
+    abstract get isAuthoring(): boolean;
+    abstract set isAuthoring(val: boolean);
+    abstract get isReviewing(): boolean;
+    abstract set isReviewing(val: boolean);
+    abstract get slideText(): string;
+    abstract set slideText(text: string);
+    static get(appObjects: AppObjectRepo): BaseAppState | undefined;
+}
+export declare function makeBaseAppState(appObject: AppObject): BaseAppState;

package/lib/AppObjectComponents/App/Entity/BaseAppState.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeBaseAppState = exports.BaseAppState = void 0;
+const AppObjectEntity_1 = require("../../../AppObject/AppObjectEntity");
+const Entities_1 = require("../../../Entities");
+class BaseAppState extends AppObjectEntity_1.AppObjectEntity {
+    static get(appObjects) {
+        const selectionEntities = appObjects.getAllComponents(BaseAppState.type);
+        if (selectionEntities.length === 0) {
+            console.warn(`Unable to find component ${BaseAppState.type}. Add one on Mount`);
+            return undefined;
+        }
+        else if (selectionEntities.length > 1) {
+            console.warn(`Multiple ${BaseAppState.type} found. There should only be one. Using the first one`);
+        }
+        return selectionEntities[0];
+    }
+}
+exports.BaseAppState = BaseAppState;
+BaseAppState.type = "BaseAppState";
+function makeBaseAppState(appObject) {
+    return new AppStateImp(appObject);
+}
+exports.makeBaseAppState = makeBaseAppState;
+class AppStateImp extends BaseAppState {
+    constructor(appObject) {
+        super(appObject, BaseAppState.type);
+        this.memoizedIsAuthoring = new Entities_1.MemoizedBoolean(false, this.notifyOnChange);
+        this.memoizedIsReviewing = new Entities_1.MemoizedBoolean(false, this.notifyOnChange);
+        this.memoizedSlideText = new Entities_1.MemoizedString("", this.notifyOnChange);
+    }
+    get isAuthoring() {
+        return this.memoizedIsAuthoring.val;
+    }
+    set isAuthoring(val) {
+        this.memoizedIsAuthoring.val = val;
+    }
+    get isReviewing() {
+        return this.memoizedIsReviewing.val;
+    }
+    set isReviewing(val) {
+        this.memoizedIsReviewing.val = val;
+    }
+    get slideText() {
+        return this.memoizedSlideText.val;
+    }
+    set slideText(text) {
+        this.memoizedSlideText.val = text;
+    }
+}

package/lib/AppObjectComponents/App/Mocks/MockAppRenderingUC.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="jest" />
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppRenderingUC } from "../UseCase/AppRenderingUC";
+export declare class MockAppRenderingUC extends AppRenderingUC {
+    startRendering: jest.Mock<any, any>;
+    stopRendering: jest.Mock<any, any>;
+    constructor(appObject: AppObject);
+}

package/lib/AppObjectComponents/App/Mocks/MockAppRenderingUC.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockAppRenderingUC = void 0;
+const AppRenderingUC_1 = require("../UseCase/AppRenderingUC");
+class MockAppRenderingUC extends AppRenderingUC_1.AppRenderingUC {
+    constructor(appObject) {
+        super(appObject, MockAppRenderingUC.type);
+        this.startRendering = jest.fn();
+        this.stopRendering = jest.fn();
+    }
+}
+exports.MockAppRenderingUC = MockAppRenderingUC;

package/lib/AppObjectComponents/App/Mocks/MockRenderCanvasUC.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="jest" />
+import { AppObject } from "../../../AppObject/AppObject";
+import { RenderCanvasUC } from "../UseCase/RenderCanvasUC";
+export declare class MockRenderUC extends RenderCanvasUC {
+    submitCanvas: jest.Mock<any, any>;
+    clearCanvas: jest.Mock<any, any>;
+    constructor(appObject: AppObject);
+}

package/lib/AppObjectComponents/App/Mocks/MockRenderCanvasUC.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockRenderUC = void 0;
+const RenderCanvasUC_1 = require("../UseCase/RenderCanvasUC");
+class MockRenderUC extends RenderCanvasUC_1.RenderCanvasUC {
+    constructor(appObject) {
+        super(appObject, RenderCanvasUC_1.RenderCanvasUC.type);
+        this.submitCanvas = jest.fn();
+        this.clearCanvas = jest.fn();
+    }
+}
+exports.MockRenderUC = MockRenderUC;

package/lib/AppObjectComponents/App/PM/IsAuthoringPM.d.ts

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

package/lib/AppObjectComponents/App/PM/IsAuthoringPM.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsAuthoringPM = void 0;
+const AppObjectPM_1 = require("../../../AppObject/AppObjectPM");
+const BaseAppState_1 = require("../Entity/BaseAppState");
+const submitWarning_1 = require("../UseCase/submitWarning");
+class IsAuthoringPM extends AppObjectPM_1.AppObjectPM {
+    constructor(appObject) {
+        super(appObject, IsAuthoringPM.type);
+        this.onAppStateChange = () => {
+            if (!this.baseAppState)
+                return;
+            this.doUpdateView(this.baseAppState.isAuthoring);
+        };
+        this.baseAppState = appObject.getComponent(BaseAppState_1.BaseAppState.type);
+        if (!this.baseAppState) {
+            submitWarning_1.submitWarning("IsAuthoringPM", "IsAuthoringPM added to an app object that does not have a BaseAppState Entity. Add one first", this.appObject.appObjectRepo);
+            return;
+        }
+        this.baseAppState.addChangeObserver(this.onAppStateChange);
+    }
+    static get(appObjects) {
+        const components = appObjects.getAllComponents(IsAuthoringPM.type);
+        if (components.length === 0) {
+            submitWarning_1.submitWarning("IsAuthoringPM", `Unable to find component ${IsAuthoringPM.type}. Add one on Mount`, appObjects);
+            return undefined;
+        }
+        else if (components.length > 1) {
+            submitWarning_1.submitWarning("IsAuthoringPM", `Multiple ${IsAuthoringPM.type} found. There should only be one. Using the first one`, appObjects);
+        }
+        return components[0];
+    }
+    vmsAreEqual(a, b) {
+        return a === b;
+    }
+}
+exports.IsAuthoringPM = IsAuthoringPM;
+IsAuthoringPM.type = "IsAuthoringPM";

package/lib/AppObjectComponents/App/PM/IsReviewingPM.d.ts

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

package/lib/AppObjectComponents/App/PM/IsReviewingPM.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsReviewingPM = void 0;
+const AppObjectPM_1 = require("../../../AppObject/AppObjectPM");
+const BaseAppState_1 = require("../Entity/BaseAppState");
+const submitWarning_1 = require("../UseCase/submitWarning");
+class IsReviewingPM extends AppObjectPM_1.AppObjectPM {
+    constructor(appObject) {
+        super(appObject, IsReviewingPM.type);
+        this.onAppStateChange = () => {
+            if (!this.baseAppState)
+                return;
+            this.doUpdateView(this.baseAppState.isReviewing);
+        };
+        this.baseAppState = appObject.getComponent(BaseAppState_1.BaseAppState.type);
+        if (!this.baseAppState) {
+            submitWarning_1.submitWarning("IsReviewingPM", "IsReviewingPM added to an app object that does not have a BaseAppState Entity. Add one first", this.appObject.appObjectRepo);
+            return;
+        }
+        this.baseAppState.addChangeObserver(this.onAppStateChange);
+    }
+    static get(appObjects) {
+        const components = appObjects.getAllComponents(IsReviewingPM.type);
+        if (components.length === 0) {
+            submitWarning_1.submitWarning("IsReviewingPM", `Unable to find component ${IsReviewingPM.type}. Add one on Mount`, appObjects);
+            return undefined;
+        }
+        else if (components.length > 1) {
+            submitWarning_1.submitWarning("IsReviewingPM", `Multiple ${IsReviewingPM.type} found. There should only be one. Using the first one`, appObjects);
+        }
+        return components[0];
+    }
+    vmsAreEqual(a, b) {
+        return a === b;
+    }
+}
+exports.IsReviewingPM = IsReviewingPM;
+IsReviewingPM.type = "IsReviewingPM";

package/lib/AppObjectComponents/App/PM/SlideTextPM.d.ts

@@ -0,0 +1,11 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectPM } from "../../../AppObject/AppObjectPM";
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+export declare class SlideTextPM extends AppObjectPM<string> {
+    static readonly type = "SlideTextPM";
+    static get(appObjects: AppObjectRepo): SlideTextPM | undefined;
+    private baseAppState?;
+    vmsAreEqual(a: string, b: string): boolean;
+    private onAppStateChange;
+    constructor(appObject: AppObject);
+}

package/lib/AppObjectComponents/App/PM/SlideTextPM.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlideTextPM = void 0;
+const AppObjectPM_1 = require("../../../AppObject/AppObjectPM");
+const BaseAppState_1 = require("../Entity/BaseAppState");
+class SlideTextPM extends AppObjectPM_1.AppObjectPM {
+    constructor(appObject) {
+        super(appObject, SlideTextPM.type);
+        this.onAppStateChange = () => {
+            if (!this.baseAppState)
+                return;
+            this.doUpdateView(this.baseAppState.slideText);
+        };
+        this.baseAppState = appObject.getComponent(BaseAppState_1.BaseAppState.type);
+        if (!this.baseAppState) {
+            console.warn("SlideTextPM added to an app object that does not have an BaseAppState Entity. Add one first");
+            return;
+        }
+        this.baseAppState.addChangeObserver(this.onAppStateChange);
+    }
+    static get(appObjects) {
+        const selectionEntities = appObjects.getAllComponents(SlideTextPM.type);
+        if (selectionEntities.length === 0) {
+            console.warn(`Unable to find component ${SlideTextPM.type}. Add one on Mount`);
+            return undefined;
+        }
+        else if (selectionEntities.length > 1) {
+            console.warn(`Multiple ${SlideTextPM.type} found. There should only be one. Using the first one`);
+        }
+        return selectionEntities[0];
+    }
+    vmsAreEqual(a, b) {
+        return a === b;
+    }
+}
+exports.SlideTextPM = SlideTextPM;
+SlideTextPM.type = "SlideTextPM";

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

@@ -0,0 +1,8 @@
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+export declare abstract class AppRenderingUC extends AppObjectUC {
+    static readonly type = "AppRenderingUC";
+    abstract startRendering(container: HTMLElement): void;
+    abstract stopRendering(): void;
+    static get(appObjects: AppObjectRepo): AppRenderingUC | undefined;
+}

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

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

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

@@ -0,0 +1,17 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+export declare abstract class EditSlideTextUC extends AppObjectUC {
+    static readonly type = "EditSlideTextUC";
+    abstract editSlideText(): void;
+    static get(appObjects: AppObjectRepo): EditSlideTextUC | undefined;
+}
+export declare function makeEditSlideTextUC(appObject: AppObject): EditSlideTextUCImp;
+declare class EditSlideTextUCImp extends EditSlideTextUC {
+    private baseApp?;
+    private appObjects;
+    submitCallback: (text: string) => void;
+    editSlideText: () => void;
+    constructor(appObject: AppObject);
+}
+export {};

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

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeEditSlideTextUC = exports.EditSlideTextUC = void 0;
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const DispatchStateChangeUC_1 = require("../../Dispatcher/UC/DispatchStateChangeUC");
+const ShowMarkdownEditorUC_1 = require("../../Dispatcher/UC/ShowMarkdownEditorUC");
+const BaseAppState_1 = require("../Entity/BaseAppState");
+const submitWarning_1 = require("./submitWarning");
+class EditSlideTextUC extends AppObjectUC_1.AppObjectUC {
+    static get(appObjects) {
+        const selectionEntities = appObjects.getAllComponents(EditSlideTextUC.type);
+        if (selectionEntities.length === 0) {
+            console.warn(`Unable to find component ${EditSlideTextUC.type}. Add one on Mount`);
+            return undefined;
+        }
+        else if (selectionEntities.length > 1) {
+            console.warn(`Multiple ${EditSlideTextUC.type} found. There should only be one. Using the first one`);
+        }
+        return selectionEntities[0];
+    }
+}
+exports.EditSlideTextUC = EditSlideTextUC;
+EditSlideTextUC.type = "EditSlideTextUC";
+function makeEditSlideTextUC(appObject) {
+    return new EditSlideTextUCImp(appObject);
+}
+exports.makeEditSlideTextUC = makeEditSlideTextUC;
+class EditSlideTextUCImp extends EditSlideTextUC {
+    constructor(appObject) {
+        super(appObject, EditSlideTextUC.type);
+        this.submitCallback = (text) => {
+            const appState = BaseAppState_1.BaseAppState.get(this.appObjects);
+            if (!appState) {
+                console.warn("Unable to find AppState");
+                return;
+            }
+            const prevText = appState.slideText;
+            if (prevText === text) {
+                return;
+            }
+            appState.slideText = text;
+            DispatchStateChangeUC_1.dispatchStateChange(this.appObjects);
+        };
+        this.editSlideText = () => {
+            if (!this.baseApp) {
+                submitWarning_1.submitWarning("EditSlideTextUC", "Unable to find AppState", this.appObjects);
+                return;
+            }
+            const showMDUC = ShowMarkdownEditorUC_1.ShowMarkdownEditorUC.get(this.appObjects);
+            if (!showMDUC) {
+                submitWarning_1.submitWarning("EditSlideTextUC", "Unable to find ShowMarkdownEditorUC", this.appObjects);
+                return;
+            }
+            const slideText = this.baseApp.slideText;
+            const dto = {
+                initialText: slideText,
+                submitCallback: this.submitCallback,
+            };
+            showMDUC.showMarkdownEditor(dto);
+        };
+        this.appObjects = appObject.appObjectRepo;
+        this.baseApp = appObject.getComponent(BaseAppState_1.BaseAppState.type);
+        if (!this.baseApp) {
+            submitWarning_1.submitWarning("EditSlideTextUCImp", "EditSlideTextUCImp UC has been added to an App Object that does not have a AppState Entity. Add one before adding the UC", this.appObjects);
+        }
+    }
+}

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

@@ -0,0 +1,10 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+export declare abstract class RenderCanvasUC extends AppObjectUC {
+    static readonly type = "RenderCanvasUC";
+    abstract submitCanvas(canvas: HTMLCanvasElement): void;
+    abstract clearCanvas(): void;
+    static get(appObjects: AppObjectRepo): RenderCanvasUC | undefined;
+}
+export declare function makeRenderCanvasUC(appObject: AppObject): RenderCanvasUC;

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

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeRenderCanvasUC = exports.RenderCanvasUC = void 0;
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const Babylon_1 = require("../../Babylon");
+const KeyboardInput_1 = require("../../KeyboardInput");
+const MouseInput_1 = require("../../MouseInput");
+const TouchController_1 = require("../../TouchController");
+const submitWarning_1 = require("./submitWarning");
+class RenderCanvasUC extends AppObjectUC_1.AppObjectUC {
+    static get(appObjects) {
+        const components = appObjects.getAllComponents(RenderCanvasUC.type);
+        if (components.length === 0) {
+            submitWarning_1.submitWarning("RenderCanvasUC", `Unable to find component ${RenderCanvasUC.type}. Add one on Mount`, appObjects);
+            return undefined;
+        }
+        else if (components.length > 1) {
+            submitWarning_1.submitWarning("AppIsReadyUC", `Multiple ${RenderCanvasUC.type} found. There should only be one. Using the first one`, appObjects);
+        }
+        return components[0];
+    }
+}
+exports.RenderCanvasUC = RenderCanvasUC;
+RenderCanvasUC.type = "RenderCanvasUC";
+function makeRenderCanvasUC(appObject) {
+    return new RenderCanvasUCImp(appObject);
+}
+exports.makeRenderCanvasUC = makeRenderCanvasUC;
+class RenderCanvasUCImp extends RenderCanvasUC {
+    submitCanvas(canvas) {
+        const appObjects = this.appObject.appObjectRepo;
+        const keyboardInput = KeyboardInput_1.KeyboardInputEntity.get(appObjects);
+        if (keyboardInput) {
+            keyboardInput.setEventElement(canvas);
+        }
+        else {
+            this.warn("Unable to find KeyboardInputEntity");
+        }
+        const touchInput = TouchController_1.TouchInputEntity.get(appObjects);
+        if (touchInput) {
+            touchInput.setEventElement(canvas);
+        }
+        else {
+            this.warn("Unable to find TouchInputEntity");
+        }
+        const mouseInput = MouseInput_1.MouseInputEntity.get(appObjects);
+        if (mouseInput) {
+            mouseInput.setEventElement(canvas);
+        }
+        else {
+            this.warn("Unable to find MouseInputEntity");
+        }
+        const babylonRendering = Babylon_1.BabylonRenderingUC.get(appObjects);
+        if (babylonRendering) {
+            babylonRendering.submitRenderCanvas(canvas);
+        }
+        else {
+            this.warn("Unable to find BabylonRenderingUC");
+        }
+        canvas.addEventListener("contextmenu", function (e) {
+            e.preventDefault();
+        }, false);
+    }
+    clearCanvas() {
+        const appObjects = this.appObject.appObjectRepo;
+        const keyboardInput = KeyboardInput_1.KeyboardInputEntity.get(appObjects);
+        if (keyboardInput) {
+            keyboardInput.clearInputElement();
+        }
+        else {
+            this.warn("Unable to find KeyboardInputEntity");
+        }
+        const touchInput = TouchController_1.TouchInputEntity.get(appObjects);
+        if (touchInput) {
+            touchInput.clearInputElement();
+        }
+        else {
+            this.warn("Unable to find TouchInputEntity");
+        }
+        const mouseInput = MouseInput_1.MouseInputEntity.get(appObjects);
+        if (mouseInput) {
+            mouseInput.clearInputElement();
+        }
+        else {
+            this.warn("Unable to find MouseInputEntity");
+        }
+        const babylonRendering = Babylon_1.BabylonRenderingUC.get(appObjects);
+        if (babylonRendering) {
+            babylonRendering.clearRenderCanvas();
+        }
+        else {
+            this.warn("Unable to find BabylonRenderingUC");
+        }
+    }
+    warn(msg) {
+        submitWarning_1.submitWarning("RenderCanvasUCImp", msg, this.appObject.appObjectRepo);
+    }
+    constructor(appObject) {
+        super(appObject, RenderCanvasUC.type);
+    }
+}

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

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

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeRenderCanvas = void 0;
+const Babylon_1 = require("../../Babylon");
+const KeyboardInput_1 = require("../../KeyboardInput");
+const MouseInput_1 = require("../../MouseInput");
+const TouchController_1 = require("../../TouchController");
+function removeRenderCanvas(appObjects) {
+    Babylon_1.clearBabylonRenderCanvas(appObjects);
+    const keyboardInput = KeyboardInput_1.KeyboardInputEntity.get(appObjects);
+    if (keyboardInput) {
+        keyboardInput.clearInputElement();
+    }
+    const touchInput = TouchController_1.TouchInputEntity.get(appObjects);
+    if (touchInput) {
+        touchInput.clearInputElement();
+    }
+    const mouseInput = MouseInput_1.MouseInputEntity.get(appObjects);
+    if (mouseInput) {
+        mouseInput.clearInputElement();
+    }
+}
+exports.removeRenderCanvas = removeRenderCanvas;

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

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