@vived/app 3.9.1 → 4.0.0

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

@@ -0,0 +1,10 @@
+import { AppObject, AppObjectPM, AppObjectRepo } from "../../../AppObject";
+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;
+    dispose(): void;
+    constructor(appObject: AppObject);
+}

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsAuthoringPM = void 0;
+const AppObject_1 = require("../../../AppObject");
+const Entity_1 = require("../Entity");
+class IsAuthoringPM extends AppObject_1.AppObjectPM {
+    constructor(appObject) {
+        super(appObject, IsAuthoringPM.type);
+        this.onAppStateChange = () => {
+            if (!this.baseAppState)
+                return;
+            this.doUpdateView(this.baseAppState.isAuthoring);
+        };
+        this.baseAppState = appObject.getComponent(Entity_1.BaseAppState.type);
+        if (!this.baseAppState) {
+            this.warn("IsAuthoringPM added to an app object that does not have a BaseAppState Entity. Add one first");
+            return;
+        }
+        this.baseAppState.addChangeObserver(this.onAppStateChange);
+        this.onAppStateChange();
+    }
+    vmsAreEqual(a, b) {
+        return a === b;
+    }
+    dispose() {
+        var _a;
+        super.dispose();
+        (_a = this.baseAppState) === null || _a === void 0 ? void 0 : _a.removeChangeObserver(this.onAppStateChange);
+    }
+}
+exports.IsAuthoringPM = IsAuthoringPM;
+IsAuthoringPM.type = "IsAuthoringPM";
+IsAuthoringPM.get = (appObjects) => AppObject_1.getSingletonComponent(IsAuthoringPM.type, appObjects);

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

@@ -0,0 +1,10 @@
+import { AppObject, AppObjectPM, AppObjectRepo } from "../../../AppObject";
+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;
+    dispose(): void;
+    constructor(appObject: AppObject);
+}

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsReviewingPM = void 0;
+const AppObject_1 = require("../../../AppObject");
+const Entity_1 = require("../Entity");
+class IsReviewingPM extends AppObject_1.AppObjectPM {
+    constructor(appObject) {
+        super(appObject, IsReviewingPM.type);
+        this.onAppStateChange = () => {
+            if (!this.baseAppState)
+                return;
+            this.doUpdateView(this.baseAppState.isReviewing);
+        };
+        this.baseAppState = appObject.getComponent(Entity_1.BaseAppState.type);
+        if (!this.baseAppState) {
+            this.warn("IsReviewingPM added to an app object that does not have a BaseAppState Entity. Add one first");
+            return;
+        }
+        this.baseAppState.addChangeObserver(this.onAppStateChange);
+        this.onAppStateChange();
+    }
+    vmsAreEqual(a, b) {
+        return a === b;
+    }
+    dispose() {
+        var _a;
+        super.dispose();
+        (_a = this.baseAppState) === null || _a === void 0 ? void 0 : _a.removeChangeObserver(this.onAppStateChange);
+    }
+}
+exports.IsReviewingPM = IsReviewingPM;
+IsReviewingPM.type = "IsReviewingPM";
+IsReviewingPM.get = (appObjects) => AppObject_1.getSingletonComponent(IsReviewingPM.type, appObjects);

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

@@ -0,0 +1,9 @@
+import { AppObject, AppObjectPM, AppObjectRepo } from "../../../AppObject";
+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/Components/App/PM/SlideTextPM.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlideTextPM = void 0;
+const AppObject_1 = require("../../../AppObject");
+const Entity_1 = require("../Entity");
+class SlideTextPM extends AppObject_1.AppObjectPM {
+    constructor(appObject) {
+        super(appObject, SlideTextPM.type);
+        this.onAppStateChange = () => {
+            if (!this.baseAppState)
+                return;
+            this.doUpdateView(this.baseAppState.slideText);
+        };
+        this.baseAppState = appObject.getComponent(Entity_1.BaseAppState.type);
+        if (!this.baseAppState) {
+            this.warn("IsReviewingPM added to an app object that does not have a BaseAppState Entity. Add one first");
+            return;
+        }
+        this.baseAppState.addChangeObserver(this.onAppStateChange);
+    }
+    vmsAreEqual(a, b) {
+        return a === b;
+    }
+}
+exports.SlideTextPM = SlideTextPM;
+SlideTextPM.type = "SlideTextPM";
+SlideTextPM.get = (appObjects) => AppObject_1.getSingletonComponent(SlideTextPM.type, appObjects);

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

@@ -0,0 +1,4 @@
+export * from "./HasNextPreviousStatePM";
+export * from "./IsAuthoringPM";
+export * from "./IsReviewingPM";
+export * from "./SlideTextPM";

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

@@ -0,0 +1,16 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./HasNextPreviousStatePM"), exports);
+__exportStar(require("./IsAuthoringPM"), exports);
+__exportStar(require("./IsReviewingPM"), exports);
+__exportStar(require("./SlideTextPM"), exports);

package/lib/Components/App/UC/AppRenderingUC.d.ts

@@ -0,0 +1,7 @@
+import { AppObjectRepo, AppObjectUC } from "../../../AppObject";
+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/Components/App/UC/AppRenderingUC.js

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

package/lib/Components/App/UC/EditSlideTextUC.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 EditSlideTextUC extends AppObjectUC {
+    static readonly type = "EditSlideTextUC";
+    abstract editSlideText(): void;
+    static get: (appObjects: AppObjectRepo) => EditSlideTextUC | undefined;
+}
+export declare function makeEditSlideTextUC(appObject: AppObject): EditSlideTextUC;

package/lib/Components/App/UC/EditSlideTextUC.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeEditSlideTextUC = exports.EditSlideTextUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+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 UndoRedoEditSlideText_1 = require("./UndoRedoEditSlideText");
+class EditSlideTextUC extends AppObjectUC_1.AppObjectUC {
+}
+exports.EditSlideTextUC = EditSlideTextUC;
+EditSlideTextUC.type = "EditSlideTextUC";
+EditSlideTextUC.get = (appObjects) => AppObject_1.getSingletonComponent(EditSlideTextUC.type, appObjects);
+function makeEditSlideTextUC(appObject) {
+    return new EditSlideTextUCImp(appObject);
+}
+exports.makeEditSlideTextUC = makeEditSlideTextUC;
+class EditSlideTextUCImp extends EditSlideTextUC {
+    constructor(appObject) {
+        super(appObject, EditSlideTextUC.type);
+        this.submitCallback = (text) => {
+            if (!this.baseApp) {
+                this.warn("Unable to find AppState");
+                return;
+            }
+            const prevText = this.baseApp.slideText;
+            if (prevText === text) {
+                return;
+            }
+            this.baseApp.slideText = text;
+            DispatchStateChangeUC_1.dispatchStateChange(this.appObjects);
+            new UndoRedoEditSlideText_1.UndoRedoEditSlideText(prevText, this.appObjects);
+        };
+        this.editSlideText = () => {
+            if (!this.baseApp) {
+                this.warn("Unable to find AppState");
+                return;
+            }
+            const showMDUC = ShowMarkdownEditorUC_1.ShowMarkdownEditorUC.get(this.appObjects);
+            if (!showMDUC) {
+                this.warn("Unable to find ShowMarkdownEditorUC");
+                return;
+            }
+            const slideText = this.baseApp.slideText;
+            const dto = {
+                initialText: slideText,
+                submitCallback: this.submitCallback,
+            };
+            showMDUC.showMarkdownEditor(dto);
+        };
+        this.baseApp = appObject.getComponent(BaseAppState_1.BaseAppState.type);
+        if (!this.baseApp) {
+            this.warn("EditSlideTextUCImp UC has been added to an App Object that does not have a AppState Entity. Add one before adding the UC");
+        }
+    }
+}

package/lib/Components/App/UC/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/Components/App/UC/RenderCanvasUC.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeRenderCanvasUC = exports.RenderCanvasUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+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");
+class RenderCanvasUC extends AppObjectUC_1.AppObjectUC {
+}
+exports.RenderCanvasUC = RenderCanvasUC;
+RenderCanvasUC.type = "RenderCanvasUC";
+RenderCanvasUC.get = (appObjects) => AppObject_1.getSingletonComponent(RenderCanvasUC.type, appObjects);
+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", (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");
+        }
+    }
+    constructor(appObject) {
+        super(appObject, RenderCanvasUC.type);
+    }
+}

package/lib/Components/App/UC/UndoRedoEditSlideText.d.ts

@@ -0,0 +1,11 @@
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+import { UndoRedoAction } from "../../UndoRedo/Entities/UndoRedoEntity";
+export declare class UndoRedoEditSlideText implements UndoRedoAction {
+    private initialText;
+    private baseAppState?;
+    private dispatchStateChange?;
+    private finalText?;
+    undoAction: () => void;
+    redoAction: () => void;
+    constructor(initialText: string, appObjects: AppObjectRepo);
+}

package/lib/Components/App/UC/UndoRedoEditSlideText.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UndoRedoEditSlideText = void 0;
+const DispatchStateChangeUC_1 = require("../../Dispatcher/UC/DispatchStateChangeUC");
+const UndoRedoEntity_1 = require("../../UndoRedo/Entities/UndoRedoEntity");
+const BaseAppState_1 = require("../Entity/BaseAppState");
+class UndoRedoEditSlideText {
+    constructor(initialText, appObjects) {
+        this.initialText = initialText;
+        this.undoAction = () => {
+            if (!this.baseAppState || !this.dispatchStateChange)
+                return;
+            this.baseAppState.slideText = this.initialText;
+            this.dispatchStateChange.doDispatch();
+        };
+        this.redoAction = () => {
+            if (!this.baseAppState || !this.dispatchStateChange || !this.finalText)
+                return;
+            this.baseAppState.slideText = this.finalText;
+            this.dispatchStateChange.doDispatch();
+        };
+        this.baseAppState = BaseAppState_1.BaseAppState.get(appObjects);
+        if (!this.baseAppState) {
+            appObjects.submitWarning("UndoEditSlideText", "Unable to find BaseAppState");
+            return;
+        }
+        this.finalText = this.baseAppState.slideText;
+        if (initialText === this.finalText)
+            return;
+        this.dispatchStateChange = DispatchStateChangeUC_1.DispatchStateChangeUC.get(appObjects);
+        if (!this.dispatchStateChange) {
+            appObjects.submitWarning("UndoEditSlideText", "Unable to find DispatchStateChangeUC");
+            return;
+        }
+        const undoRedo = UndoRedoEntity_1.UndoRedoEntity.get(appObjects);
+        if (!undoRedo) {
+            appObjects.submitWarning("UndoEditSlideText", "Unable to find UndoRedoEntity");
+            return;
+        }
+        undoRedo.submitAction(this);
+    }
+}
+exports.UndoRedoEditSlideText = UndoRedoEditSlideText;

package/lib/Components/App/UC/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./AppRenderingUC";
+export * from "./EditSlideTextUC";
+export * from "./RenderCanvasUC";
+export * from "./UndoRedoEditSlideText";
+export * from "./UndoRedoEditSlideText";

package/lib/Components/App/UC/index.js

@@ -0,0 +1,17 @@
+"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("./AppRenderingUC"), exports);
+__exportStar(require("./EditSlideTextUC"), exports);
+__exportStar(require("./RenderCanvasUC"), exports);
+__exportStar(require("./UndoRedoEditSlideText"), exports);
+__exportStar(require("./UndoRedoEditSlideText"), exports);

package/lib/Components/App/UC/submitError.js

@@ -0,0 +1,28 @@
+"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: () => {
+            // done
+        },
+        message: `[${sender}]: ${message}`
+    });
+}
+exports.submitError = submitError;

package/lib/Components/App/UC/submitFatal.js

@@ -0,0 +1,28 @@
+"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: () => {
+            // done
+        },
+        message: `[${sender}]: ${message}`
+    });
+}
+exports.submitFatal = submitFatal;

package/lib/Components/App/UC/submitLog.js

@@ -0,0 +1,28 @@
+"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: () => {
+            // done
+        },
+        message: `[${sender}]: ${message}`
+    });
+}
+exports.submitLog = submitLog;

package/lib/Components/App/UC/submitWarning.js

@@ -0,0 +1,28 @@
+"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: () => {
+            // done
+        },
+        message: `[${sender}]: ${message}`
+    });
+}
+exports.submitWarning = submitWarning;

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

@@ -0,0 +1,4 @@
+export * from "./Entity";
+export * from "./UC";
+export * from "./PM";
+export * from "./Controller";

package/lib/Components/App/index.js

@@ -0,0 +1,16 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Entity"), exports);
+__exportStar(require("./UC"), exports);
+__exportStar(require("./PM"), exports);
+__exportStar(require("./Controller"), exports);

package/lib/Components/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";
+    static get: (appObjects: AppObjectRepo) => BabylonEntity | undefined;
+    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;
+}
+export declare function makeBabylonEntity(appObject: AppObject): BabylonEntity;

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

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeBabylonEntity = exports.BabylonEntity = void 0;
+const AppObject_1 = require("../../../AppObject");
+const AppObjectEntity_1 = require("../../../AppObject/AppObjectEntity");
+const Entities_1 = require("../../../Entities");
+const ValueObjects_1 = require("../../../ValueObjects");
+class BabylonEntity extends AppObjectEntity_1.AppObjectEntity {
+}
+exports.BabylonEntity = BabylonEntity;
+BabylonEntity.type = "BabylonEntity";
+BabylonEntity.get = (appObjects) => AppObject_1.getSingletonComponent(BabylonEntity.type, appObjects);
+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/Components/Babylon/Entities/index.d.ts

@@ -0,0 +1 @@
+export * from "./BabylonEntity";