@vived/app 4.27.1 → 4.28.0

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

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeIsReviewingPM = exports.IsReviewingPM = void 0;
+const AppObject_1 = require("../../../AppObject");
+const Entity_1 = require("../Entity");
+class IsReviewingPM extends AppObject_1.AppObjectPM {
+}
+exports.IsReviewingPM = IsReviewingPM;
+IsReviewingPM.type = "IsReviewingPM";
+IsReviewingPM.get = (appObjects) => AppObject_1.getSingletonComponent(IsReviewingPM.type, appObjects);
+function makeIsReviewingPM(appObject) {
+    return new IsReviewingPMImp(appObject);
+}
+exports.makeIsReviewingPM = makeIsReviewingPM;
+class IsReviewingPMImp extends IsReviewingPM {
+    constructor(appObject) {
+        var _a;
+        super(appObject, IsReviewingPM.type);
+        this.onAppStateChange = () => {
+            if (!this.baseAppState)
+                return;
+            this.doUpdateView(this.baseAppState.isReviewing);
+        };
+        (_a = this.baseAppState) === null || _a === void 0 ? void 0 : _a.addChangeObserver(this.onAppStateChange);
+        this.onAppStateChange();
+        this.appObjects.registerSingleton(this);
+    }
+    get baseAppState() {
+        return this.getCachedSingleton(Entity_1.BaseAppState.type);
+    }
+    vmsAreEqual(a, b) {
+        return a === b;
+    }
+    dispose() {
+        var _a;
+        super.dispose();
+        (_a = this.baseAppState) === null || _a === void 0 ? void 0 : _a.removeChangeObserver(this.onAppStateChange);
+    }
+}

package/lib/Components/BaseApp/PM/SlideNavigationPM.d.ts

@@ -0,0 +1,12 @@
+import { AppObject, AppObjectPM, AppObjectRepo } from "../../../AppObject";
+export interface SlideNavigationVM {
+    hasNextState: boolean;
+    hasPreviousState: boolean;
+    hideNavigation: boolean;
+}
+export declare abstract class SlideNavigationPM extends AppObjectPM<SlideNavigationVM> {
+    static readonly type = "SlideNavigationPM";
+    static get: (appObjects: AppObjectRepo) => SlideNavigationPM | undefined;
+}
+export declare const defaultSlideNavigationVM: SlideNavigationVM;
+export declare function makeSlideNavigationPM(appObject: AppObject): SlideNavigationPM;

package/lib/Components/BaseApp/PM/SlideNavigationPM.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSlideNavigationPM = exports.defaultSlideNavigationVM = exports.SlideNavigationPM = void 0;
+const AppObject_1 = require("../../../AppObject");
+const Entity_1 = require("../Entity");
+class SlideNavigationPM extends AppObject_1.AppObjectPM {
+}
+exports.SlideNavigationPM = SlideNavigationPM;
+SlideNavigationPM.type = "SlideNavigationPM";
+SlideNavigationPM.get = (appObjects) => AppObject_1.getSingletonComponent(SlideNavigationPM.type, appObjects);
+exports.defaultSlideNavigationVM = {
+    hasNextState: true,
+    hasPreviousState: false,
+    hideNavigation: false,
+};
+function makeSlideNavigationPM(appObject) {
+    return new SlideNavigationPMImp(appObject);
+}
+exports.makeSlideNavigationPM = makeSlideNavigationPM;
+class SlideNavigationPMImp extends SlideNavigationPM {
+    constructor(appObject) {
+        var _a;
+        super(appObject, SlideNavigationPM.type);
+        this.onAppStateChange = () => {
+            if (!this.baseAppState)
+                return;
+            const hasNextState = this.baseAppState.hasNextState;
+            const hasPreviousState = this.baseAppState.hasPreviousState;
+            const hideNavigation = this.baseAppState.hideSlideNavigation;
+            const vm = { hasNextState, hasPreviousState, hideNavigation };
+            this.doUpdateView(vm);
+        };
+        (_a = this.baseAppState) === null || _a === void 0 ? void 0 : _a.addChangeObserver(this.onAppStateChange);
+        this.onAppStateChange();
+        this.appObjects.registerSingleton(this);
+    }
+    get baseAppState() {
+        return this.getCachedSingleton(Entity_1.BaseAppState.type);
+    }
+    vmsAreEqual(a, b) {
+        if (a.hasNextState !== b.hasNextState)
+            return false;
+        if (a.hasPreviousState !== b.hasPreviousState)
+            return false;
+        if (a.hideNavigation !== b.hideNavigation)
+            return false;
+        return true;
+    }
+}

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

@@ -0,0 +1,6 @@
+import { AppObject, AppObjectPM, AppObjectRepo } from "../../../AppObject";
+export declare abstract class SlideTextPM extends AppObjectPM<string> {
+    static readonly type = "SlideTextPM";
+    static get: (appObjects: AppObjectRepo) => SlideTextPM | undefined;
+}
+export declare function makeSlideTextPM(appObject: AppObject): SlideTextPM;

package/lib/Components/BaseApp/PM/SlideTextPM.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSlideTextPM = exports.SlideTextPM = void 0;
+const AppObject_1 = require("../../../AppObject");
+const Entity_1 = require("../Entity");
+class SlideTextPM extends AppObject_1.AppObjectPM {
+}
+exports.SlideTextPM = SlideTextPM;
+SlideTextPM.type = "SlideTextPM";
+SlideTextPM.get = (appObjects) => AppObject_1.getSingletonComponent(SlideTextPM.type, appObjects);
+function makeSlideTextPM(appObject) {
+    return new SlideTextPMImp(appObject);
+}
+exports.makeSlideTextPM = makeSlideTextPM;
+class SlideTextPMImp extends SlideTextPM {
+    constructor(appObject) {
+        var _a;
+        super(appObject, SlideTextPM.type);
+        this.onAppStateChange = () => {
+            if (!this.baseAppState)
+                return;
+            this.doUpdateView(this.baseAppState.slideText);
+        };
+        (_a = this.baseAppState) === null || _a === void 0 ? void 0 : _a.addChangeObserver(this.onAppStateChange);
+        this.onAppStateChange();
+        this.appObjects.registerSingleton(this);
+    }
+    get baseAppState() {
+        return this.getCachedSingleton(Entity_1.BaseAppState.type);
+    }
+    vmsAreEqual(a, b) {
+        return a === b;
+    }
+}

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

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

package/lib/{AppObjectComponents/Hideable → Components/BaseApp/PM}/index.js

@@ -10,5 +10,7 @@ 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/Hideable"), exports);
-__exportStar(require("./PresentationManagers/IsHiddenPM"), exports);
+__exportStar(require("./IsAuthoringPM"), exports);
+__exportStar(require("./IsReviewingPM"), exports);
+__exportStar(require("./SlideNavigationPM"), exports);
+__exportStar(require("./SlideTextPM"), exports);

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

package/lib/Components/BaseApp/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/BaseApp/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/BaseApp/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/BaseApp/UC/SerializeBaseAppState.d.ts

@@ -0,0 +1,17 @@
+import { AppObject, AppObjectUC } from "../../../AppObject";
+import { SerializedSystem } from "../../StateMachine";
+export declare class SerializeBaseAppState extends AppObjectUC implements SerializedSystem {
+    static readonly type = "SerializeBaseAppState";
+    name: string;
+    seriliziationVersion: number;
+    private get baseAppState();
+    getSystemState(): object;
+    applySystemState(state: object, version: number): void;
+    private applyStateV1;
+    applyDefaultState(): void;
+    constructor(appObject: AppObject);
+}
+export interface SerializedAppStateV1 {
+    slideText: string;
+    slideInfoContentHeight: number;
+}

package/lib/Components/BaseApp/UC/SerializeBaseAppState.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SerializeBaseAppState = void 0;
+const AppObject_1 = require("../../../AppObject");
+const StateMachine_1 = require("../../StateMachine");
+const Entity_1 = require("../Entity");
+class SerializeBaseAppState extends AppObject_1.AppObjectUC {
+    constructor(appObject) {
+        super(appObject, SerializeBaseAppState.type);
+        this.name = "base-app-state";
+        this.seriliziationVersion = 1;
+        const stateMachine = StateMachine_1.StateMachineEntity.get(appObject.appObjectRepo);
+        if (stateMachine) {
+            stateMachine.registerSerializedSystem(this);
+        }
+        else {
+            this.warn("Unable to find StateMachineEntity");
+        }
+    }
+    get baseAppState() {
+        return this.getCachedSingleton(Entity_1.BaseAppState.type);
+    }
+    getSystemState() {
+        if (!this.baseAppState)
+            return {};
+        const state = {
+            slideText: this.baseAppState.slideText,
+            slideInfoContentHeight: this.baseAppState.slideInfoContentHeight
+        };
+        return state;
+    }
+    applySystemState(state, version) {
+        if (version === 1) {
+            this.applyStateV1(state);
+        }
+        else {
+            this.applyDefaultState();
+        }
+    }
+    applyStateV1(state) {
+        if (!this.baseAppState)
+            return;
+        if (state.slideText === undefined ||
+            state.slideInfoContentHeight === undefined) {
+            this.applyDefaultState();
+            return;
+        }
+        this.baseAppState.slideText = state.slideText;
+        this.baseAppState.slideInfoContentHeight = state.slideInfoContentHeight;
+    }
+    applyDefaultState() {
+        if (!this.baseAppState)
+            return;
+        this.baseAppState.slideText = "";
+        this.baseAppState.slideInfoContentHeight = 0;
+    }
+}
+exports.SerializeBaseAppState = SerializeBaseAppState;
+SerializeBaseAppState.type = "SerializeBaseAppState";

package/lib/Components/BaseApp/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/BaseApp/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/BaseApp/UC/UpdateContentSizeUC.d.ts

@@ -0,0 +1,7 @@
+import { AppObject, AppObjectRepo, AppObjectUC } from "../../../AppObject";
+export declare abstract class UpdateContentSizeUC extends AppObjectUC {
+    static readonly type = "UpdateContentSizeUC";
+    abstract updateContentSize(size: number): void;
+    static get: (appObjects: AppObjectRepo) => UpdateContentSizeUC | undefined;
+}
+export declare function makeUpdateContentSizeUC(appObject: AppObject): UpdateContentSizeUC;

package/lib/Components/BaseApp/UC/UpdateContentSizeUC.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeUpdateContentSizeUC = exports.UpdateContentSizeUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const Dispatcher_1 = require("../../Dispatcher");
+const Entity_1 = require("../Entity");
+class UpdateContentSizeUC extends AppObject_1.AppObjectUC {
+}
+exports.UpdateContentSizeUC = UpdateContentSizeUC;
+UpdateContentSizeUC.type = "UpdateContentSizeUC";
+UpdateContentSizeUC.get = (appObjects) => AppObject_1.getSingletonComponent(UpdateContentSizeUC.type, appObjects);
+function makeUpdateContentSizeUC(appObject) {
+    return new UpdateContentSizeUCImp(appObject);
+}
+exports.makeUpdateContentSizeUC = makeUpdateContentSizeUC;
+class UpdateContentSizeUCImp extends UpdateContentSizeUC {
+    constructor(appObject) {
+        super(appObject, UpdateContentSizeUC.type);
+        this.updateContentSize = (size) => {
+            if (!this.baseApp) {
+                return;
+            }
+            const newHeight = Math.ceil(size);
+            if (newHeight === this.baseApp.slideInfoContentHeight)
+                return;
+            this.baseApp.slideInfoContentHeight = newHeight;
+            Dispatcher_1.dispatchStateChange(this.appObjects);
+        };
+    }
+    get baseApp() {
+        return this.getCachedSingleton(Entity_1.BaseAppState.type);
+    }
+}

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

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

package/lib/Components/BaseApp/UC/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("./AppRenderingUC"), exports);
+__exportStar(require("./EditSlideTextUC"), exports);
+__exportStar(require("./RenderCanvasUC"), exports);
+__exportStar(require("./SerializeBaseAppState"), exports);
+__exportStar(require("./UndoRedoEditSlideText"), exports);
+__exportStar(require("./UndoRedoEditSlideText"), exports);
+__exportStar(require("./UpdateContentSizeUC"), exports);

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

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

package/lib/Components/BaseApp/index.js

@@ -0,0 +1,18 @@
+"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("./Adapters"), exports);
+__exportStar(require("./Controller"), exports);
+__exportStar(require("./Entity"), exports);
+__exportStar(require("./Mocks"), exports);
+__exportStar(require("./PM"), exports);
+__exportStar(require("./UC"), exports);

package/lib/Components/Callouts/Adapters/calloutLinePointsAdapter.d.ts

@@ -0,0 +1,3 @@
+import { PmAdapter } from "../../../Types";
+import { Vector3 } from "../../../ValueObjects";
+export declare const calloutLinePointsAdapter: PmAdapter<Vector3[]>;

package/lib/Components/Callouts/Adapters/calloutLinePointsAdapter.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calloutLinePointsAdapter = void 0;
+const CalloutLinePointsPM_1 = require("../PM/CalloutLinePointsPM");
+exports.calloutLinePointsAdapter = {
+    defaultVM: [],
+    subscribe: (id, appObjects, setVM) => {
+        if (!id)
+            return;
+        const pm = CalloutLinePointsPM_1.CalloutLinePointsPM.getById(id, appObjects);
+        if (!pm) {
+            appObjects.submitError("calloutLinePointsAdapter", "Unable to find CalloutLinePointsPM");
+            return;
+        }
+        pm.addView(setVM);
+    },
+    unsubscribe: (id, appObjects, setVM) => {
+        const pm = CalloutLinePointsPM_1.CalloutLinePointsPM.getById(id, appObjects);
+        if (pm) {
+            pm.removeView(setVM);
+        }
+    }
+};

package/lib/Components/Callouts/Adapters/calloutListAdapter.d.ts

@@ -0,0 +1,2 @@
+import { PmAdapter } from "../../../Types";
+export declare const calloutListAdapter: PmAdapter<string[]>;

package/lib/Components/Callouts/Adapters/calloutListAdapter.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calloutListAdapter = void 0;
+const CalloutListPM_1 = require("../PM/CalloutListPM");
+exports.calloutListAdapter = {
+    defaultVM: [],
+    subscribe: (id, appObjects, setVM) => {
+        if (!id)
+            return;
+        const pm = CalloutListPM_1.CalloutListPM.getById(id, appObjects);
+        if (!pm) {
+            appObjects.submitError("calloutSizeAdapter", "Unable to find CalloutListPM");
+            return;
+        }
+        pm.addView(setVM);
+    },
+    unsubscribe: (id, appObjects, setVM) => {
+        const pm = CalloutListPM_1.CalloutListPM.getById(id, appObjects);
+        if (pm) {
+            pm.removeView(setVM);
+        }
+    },
+};

package/lib/Components/Callouts/Adapters/calloutOffsetAdapter.d.ts

@@ -0,0 +1,3 @@
+import { PmAdapter } from "../../../Types";
+import { CalloutOffsetDirection } from "../Entities/CalloutEntity";
+export declare const calloutOffsetAdapter: PmAdapter<CalloutOffsetDirection>;