@vived/host 3.0.0

package/lib/HostAppObject/HostAppObjectRepo.d.ts

@@ -0,0 +1,25 @@
+import { ObservableEntity } from '../Entities';
+import { HostAppObject } from './HostAppObject';
+import { HostAppObjectComponent } from './HostAppObjectComponent';
+export declare abstract class HostAppObjectRepo extends ObservableEntity {
+    abstract has(appObjectID: string): boolean;
+    abstract add(appObject: HostAppObject): void;
+    abstract remove(appObjectID: string): void;
+    abstract get(appObjectID: string): HostAppObject | undefined;
+    abstract getOrCreate(appObjectID: string): HostAppObject;
+    abstract getAll(): HostAppObject[];
+    abstract submitLog(sender: string, message: string): void;
+    abstract submitWarning(sender: string, message: string): void;
+    abstract submitError(sender: string, message: string): void;
+    abstract submitFatal(sender: string, message: string): void;
+    abstract registerSingleton(component: HostAppObjectComponent): void;
+    abstract getSingleton<T extends HostAppObjectComponent>(type: string): T | undefined;
+    abstract getAppObjectComponent<T extends HostAppObjectComponent>(appObjectID: string, type: string): T | undefined;
+    abstract getAllAppObjectsWithComponent(componentType: string): HostAppObject[];
+    abstract getAllComponents<T extends HostAppObjectComponent>(type: string): T[];
+    abstract addAppObjectAddedObserver: (observer: (addedEntity: HostAppObject) => void) => void;
+    abstract removeAppObjectAddedObserver: (observer: (addedEntity: HostAppObject) => void) => void;
+    abstract addAppObjectRemovedObserver: (observer: (addedEntity: HostAppObject) => void) => void;
+    abstract removedAppObjectRemovedObserver: (observer: (addedEntity: HostAppObject) => void) => void;
+}
+export declare function makeHostAppObjectRepo(): HostAppObjectRepo;

package/lib/HostAppObject/HostAppObjectRepo.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeHostAppObjectRepo = exports.HostAppObjectRepo = void 0;
+const Entities_1 = require("../Entities");
+const HostAppObject_1 = require("./HostAppObject");
+class HostAppObjectRepo extends Entities_1.ObservableEntity {
+}
+exports.HostAppObjectRepo = HostAppObjectRepo;
+function makeHostAppObjectRepo() {
+    return new AppObjectRepoImp();
+}
+exports.makeHostAppObjectRepo = makeHostAppObjectRepo;
+class AppObjectRepoImp extends HostAppObjectRepo {
+    constructor() {
+        super(...arguments);
+        this.appObjectLookup = new Map();
+        this.singletons = new Map();
+        this.onAppObjectAddedObserver = new Entities_1.ObserverList();
+        this.addAppObjectAddedObserver = (observer) => {
+            this.onAppObjectAddedObserver.add(observer);
+        };
+        this.removeAppObjectAddedObserver = (observer) => {
+            this.onAppObjectAddedObserver.remove(observer);
+        };
+        this.onAppObjectRemovedObservers = new Entities_1.ObserverList();
+        this.addAppObjectRemovedObserver = (observer) => {
+            this.onAppObjectRemovedObservers.add(observer);
+        };
+        this.removedAppObjectRemovedObserver = (observer) => {
+            this.onAppObjectRemovedObservers.remove(observer);
+        };
+        this.has = (id) => {
+            return this.appObjectLookup.has(id);
+        };
+        this.add = (appObject) => {
+            const existing = this.appObjectLookup.get(appObject.id);
+            if (existing) {
+                existing.removeObserver(this.notify);
+            }
+            this.appObjectLookup.set(appObject.id, appObject);
+            appObject.addObserver(this.notify);
+            this.notify();
+            this.onAppObjectAddedObserver.notify(appObject);
+        };
+        this.remove = (id) => {
+            const existing = this.appObjectLookup.get(id);
+            if (!existing)
+                return;
+            this.appObjectLookup.delete(id);
+            existing.removeObserver(this.notify);
+            this.notify();
+            this.onAppObjectRemovedObservers.notify(existing);
+        };
+        this.get = (id) => {
+            return this.appObjectLookup.get(id);
+        };
+        this.getOrCreate = (id) => {
+            const existing = this.appObjectLookup.get(id);
+            if (!existing) {
+                return HostAppObject_1.makeAppObject(id, this);
+            }
+            else {
+                return existing;
+            }
+        };
+        this.getAll = () => {
+            return Array.from(this.appObjectLookup.values());
+        };
+    }
+    getAllAppObjectsWithComponent(componentType) {
+        const rArray = [];
+        this.appObjectLookup.forEach((appObj) => {
+            if (appObj.hasComponent(componentType)) {
+                rArray.push(appObj);
+            }
+        });
+        return rArray;
+    }
+    getAllComponents(type) {
+        const rArray = [];
+        this.appObjectLookup.forEach((appObj) => {
+            const aoEntity = appObj.getComponent(type);
+            if (aoEntity) {
+                rArray.push(aoEntity);
+            }
+        });
+        return rArray;
+    }
+    getAppObjectComponent(id, entityType) {
+        const ao = this.appObjectLookup.get(id);
+        if (!ao) {
+            return undefined;
+        }
+        return ao.getComponent(entityType);
+    }
+    submitLog(sender, message) {
+        console.log(`[${sender}]: ${message}`);
+    }
+    submitWarning(sender, message) {
+        console.warn(`[${sender}]: ${message}`);
+    }
+    submitError(sender, message) {
+        console.error(`[${sender}]: ${message}`);
+    }
+    submitFatal(sender, message) {
+        console.error(`FATAL ERROR - [${sender}]: ${message}`);
+    }
+    registerSingleton(component) {
+        if (this.singletons.has(component.type)) {
+            this.submitWarning('AppObjectRepo', `Singleton for type ${component.type} already exists. Replacing`);
+        }
+        this.singletons.set(component.type, component);
+    }
+    getSingleton(type) {
+        if (this.singletons.has(type)) {
+            return this.singletons.get(type);
+        }
+        const components = this.getAllComponents(type);
+        if (components.length === 1) {
+            this.singletons.set(components[0].type, components[0]);
+            return components[0];
+        }
+        else if (components.length === 0) {
+            this.submitWarning('AppObjectRepo', `Unable to find a singleton for ${type}`);
+            return undefined;
+        }
+        else if (components.length > 1) {
+            this.submitWarning('AppObjectRepo', `Multiple ${type} found. There should only be one if it truly a singleton. Using the first one`);
+            return components[0];
+        }
+    }
+}

package/lib/HostAppObject/HostAppObjectUC.d.ts

@@ -0,0 +1,3 @@
+import { HostAppObjectComponent } from './HostAppObjectComponent';
+export declare class HostAppObjectUC extends HostAppObjectComponent {
+}

package/lib/HostAppObject/HostAppObjectUC.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HostAppObjectUC = void 0;
+const HostAppObjectComponent_1 = require("./HostAppObjectComponent");
+class HostAppObjectUC extends HostAppObjectComponent_1.HostAppObjectComponent {
+}
+exports.HostAppObjectUC = HostAppObjectUC;

package/lib/HostAppObject/HostAppObjectView.d.ts

@@ -0,0 +1,3 @@
+import { HostAppObjectComponent } from './HostAppObjectComponent';
+export declare class HostAppObjectView extends HostAppObjectComponent {
+}

package/lib/HostAppObject/HostAppObjectView.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HostAppObjectView = void 0;
+const HostAppObjectComponent_1 = require("./HostAppObjectComponent");
+class HostAppObjectView extends HostAppObjectComponent_1.HostAppObjectComponent {
+}
+exports.HostAppObjectView = HostAppObjectView;

package/lib/HostAppObject/getSingletonComponent.d.ts

@@ -0,0 +1,3 @@
+import { HostAppObjectComponent } from './HostAppObjectComponent';
+import { HostAppObjectRepo } from './HostAppObjectRepo';
+export declare function getSingletonComponent<T extends HostAppObjectComponent>(type: string, appObjects: HostAppObjectRepo): T | undefined;

package/lib/HostAppObject/getSingletonComponent.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSingletonComponent = void 0;
+function getSingletonComponent(type, appObjects) {
+    return appObjects.getSingleton(type);
+}
+exports.getSingletonComponent = getSingletonComponent;

package/lib/HostAppObject/index.d.ts

@@ -0,0 +1,9 @@
+export * from './HostAppObject';
+export * from './HostAppObjectEntity';
+export * from './HostAppObjectEntityRepo';
+export * from './HostAppObjectPM';
+export * from './HostAppObjectRepo';
+export * from './HostAppObjectUC';
+export * from './HostAppObjectController';
+export * from './HostAppObjectView';
+export * from './getSingletonComponent';

package/lib/HostAppObject/index.js

@@ -0,0 +1,21 @@
+"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("./HostAppObject"), exports);
+__exportStar(require("./HostAppObjectEntity"), exports);
+__exportStar(require("./HostAppObjectEntityRepo"), exports);
+__exportStar(require("./HostAppObjectPM"), exports);
+__exportStar(require("./HostAppObjectRepo"), exports);
+__exportStar(require("./HostAppObjectUC"), exports);
+__exportStar(require("./HostAppObjectController"), exports);
+__exportStar(require("./HostAppObjectView"), exports);
+__exportStar(require("./getSingletonComponent"), exports);

package/lib/PresentationManagers/DevicePreview/DevicePreviewListPM.d.ts

@@ -0,0 +1,23 @@
+import { DevicePreview } from "../..";
+export interface DevicePreviewListVM {
+    useDevicePreview: boolean;
+    selectedDeviceName: string;
+    selectedDeviceX: number;
+    selectedDeviceY: number;
+    selectedDeviceID: string;
+    catagorizedDevices: Map<string, DeviceInfoVM[]>;
+}
+export interface DeviceInfoVM {
+    id: string;
+    name: string;
+    x: number;
+    y: number;
+}
+export declare class DevicePreviewListPM {
+    devicePreview: DevicePreview;
+    updateView: (viewModel: DevicePreviewListVM) => void;
+    devices: Map<string, DeviceInfoVM[]>;
+    doUpdateView: () => void;
+    dispose(): void;
+    constructor(devicePreview: DevicePreview, updateView: (viewModel: DevicePreviewListVM) => void);
+}

package/lib/PresentationManagers/DevicePreview/DevicePreviewListPM.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DevicePreviewListPM = void 0;
+class DevicePreviewListPM {
+    constructor(devicePreview, updateView) {
+        this.devices = new Map();
+        this.doUpdateView = () => {
+            const selectedDevice = this.devicePreview.selectedDevice;
+            if (selectedDevice) {
+                this.updateView({
+                    catagorizedDevices: this.devices,
+                    selectedDeviceID: selectedDevice.id,
+                    selectedDeviceName: selectedDevice.name,
+                    selectedDeviceX: selectedDevice.x,
+                    selectedDeviceY: selectedDevice.y,
+                    useDevicePreview: true,
+                });
+            }
+            else {
+                this.updateView({
+                    catagorizedDevices: this.devices,
+                    selectedDeviceID: '',
+                    selectedDeviceName: '',
+                    selectedDeviceX: 0,
+                    selectedDeviceY: 0,
+                    useDevicePreview: false,
+                });
+            }
+        };
+        const categories = devicePreview.getCategoryList();
+        categories.forEach((category) => {
+            const devicesInCategory = devicePreview.getDevicesInCategory(category);
+            const deviceList = devicesInCategory.map((device) => {
+                const { id, name, x, y } = device;
+                return { id, name, x, y };
+            });
+            if (deviceList.length > 0) {
+                this.devices.set(category, deviceList);
+            }
+        });
+        this.devicePreview = devicePreview;
+        this.updateView = updateView;
+        this.doUpdateView();
+        devicePreview.addObserver(this.doUpdateView);
+    }
+    dispose() {
+        this.devicePreview.removeObserver(this.doUpdateView);
+    }
+}
+exports.DevicePreviewListPM = DevicePreviewListPM;

package/lib/PresentationManagers/Dialog/AlertDialogPM.d.ts

@@ -0,0 +1,18 @@
+import { DialogAlert, DialogRepo } from "../../Entities";
+export interface AlertDialogVM {
+    message: string;
+    title: string;
+    buttonLabel: string;
+    close: () => void;
+}
+export declare class AlertDialogPM {
+    private repo;
+    private updateView;
+    private observingAlert;
+    private lastVM?;
+    doUpdateView: () => void;
+    updateAlertObserver(alert: DialogAlert | null): void;
+    private vmHasChanged;
+    dispose: () => void;
+    constructor(repo: DialogRepo, updateView: (vm: AlertDialogVM | null) => void);
+}

package/lib/PresentationManagers/Dialog/AlertDialogPM.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AlertDialogPM = void 0;
+const Entities_1 = require("../../Entities");
+class AlertDialogPM {
+    constructor(repo, updateView) {
+        this.repo = repo;
+        this.updateView = updateView;
+        this.observingAlert = null;
+        this.doUpdateView = () => {
+            let vm = null;
+            if (this.repo.activeDialog &&
+                this.repo.activeDialog.type === Entities_1.alertDialogType) {
+                const alertDialog = this.repo.activeDialog;
+                this.updateAlertObserver(alertDialog);
+                vm = {
+                    buttonLabel: alertDialog.buttonLabel,
+                    close: alertDialog.close,
+                    message: alertDialog.message,
+                    title: alertDialog.title,
+                };
+            }
+            else {
+                this.updateAlertObserver(null);
+            }
+            if (!this.vmHasChanged(vm))
+                return;
+            this.updateView(vm);
+            this.lastVM = vm;
+        };
+        this.dispose = () => {
+            this.repo.removeObserver(this.doUpdateView);
+            if (this.observingAlert) {
+                this.observingAlert.removeObserver(this.doUpdateView);
+            }
+        };
+        repo.addObserver(this.doUpdateView);
+        this.doUpdateView();
+    }
+    updateAlertObserver(alert) {
+        if (alert === this.observingAlert)
+            return;
+        if (this.observingAlert !== null) {
+            this.observingAlert.removeObserver(this.doUpdateView);
+        }
+        if (alert !== null) {
+            alert.addObserver(this.doUpdateView);
+        }
+        this.observingAlert = alert;
+    }
+    vmHasChanged(vm) {
+        var _a, _b, _c;
+        if (this.lastVM === undefined)
+            return true;
+        if (vm === null && this.lastVM === null)
+            return false;
+        if ((vm === null || vm === void 0 ? void 0 : vm.buttonLabel) === ((_a = this.lastVM) === null || _a === void 0 ? void 0 : _a.buttonLabel) &&
+            (vm === null || vm === void 0 ? void 0 : vm.message) === ((_b = this.lastVM) === null || _b === void 0 ? void 0 : _b.message) &&
+            (vm === null || vm === void 0 ? void 0 : vm.title) === ((_c = this.lastVM) === null || _c === void 0 ? void 0 : _c.title)) {
+            return false;
+        }
+        return true;
+    }
+}
+exports.AlertDialogPM = AlertDialogPM;

package/lib/PresentationManagers/Dialog/ConfirmDialogPM.d.ts

@@ -0,0 +1,21 @@
+import { DialogConfirm, DialogRepo } from "../../Entities";
+export interface ConfirmDialogVM {
+    message: string;
+    title: string;
+    cancelButtonLabel: string;
+    confirmButtonLabel: string;
+    cancel: () => void;
+    confirm: () => void;
+}
+export declare class ConfirmDialogPM {
+    private repo;
+    private updateView;
+    private observingAlert;
+    private lastVM?;
+    doUpdateView: () => void;
+    updateAlertObserver(alert: DialogConfirm | null): void;
+    private vmHasChanged;
+    dispose: () => void;
+    constructor(repo: DialogRepo, updateView: (vm: ConfirmDialogVM) => void);
+}
+export declare const defaultConfirmDialogVM: ConfirmDialogVM;

package/lib/PresentationManagers/Dialog/ConfirmDialogPM.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultConfirmDialogVM = exports.ConfirmDialogPM = void 0;
+const Entities_1 = require("../../Entities");
+class ConfirmDialogPM {
+    constructor(repo, updateView) {
+        this.repo = repo;
+        this.updateView = updateView;
+        this.observingAlert = null;
+        this.doUpdateView = () => {
+            let vm = {
+                message: "",
+                title: "",
+                cancel: () => {
+                    console.warn("[ConfirmDialogVM.cancel] empty VM!");
+                },
+                cancelButtonLabel: "",
+                confirm: () => {
+                    console.warn("[ConfirmDialogVM.confirm] empty VM!");
+                },
+                confirmButtonLabel: ""
+            };
+            if (this.repo.activeDialog &&
+                this.repo.activeDialog.type === Entities_1.confirmDialogType) {
+                const alertDialog = this.repo.activeDialog;
+                this.updateAlertObserver(alertDialog);
+                vm = {
+                    cancelButtonLabel: alertDialog.cancelButtonLabel,
+                    confirmButtonLabel: alertDialog.confirmButtonLabel,
+                    cancel: alertDialog.cancel,
+                    confirm: alertDialog.confirm,
+                    message: alertDialog.message,
+                    title: alertDialog.title,
+                };
+            }
+            else {
+                this.updateAlertObserver(null);
+            }
+            if (!this.vmHasChanged(vm))
+                return;
+            this.updateView(vm);
+            this.lastVM = vm;
+        };
+        this.dispose = () => {
+            this.repo.removeObserver(this.doUpdateView);
+            if (this.observingAlert) {
+                this.observingAlert.removeObserver(this.doUpdateView);
+            }
+        };
+        repo.addObserver(this.doUpdateView);
+        this.doUpdateView();
+    }
+    updateAlertObserver(alert) {
+        if (alert === this.observingAlert)
+            return;
+        if (this.observingAlert !== null) {
+            this.observingAlert.removeObserver(this.doUpdateView);
+        }
+        if (alert !== null) {
+            alert.addObserver(this.doUpdateView);
+        }
+        this.observingAlert = alert;
+    }
+    vmHasChanged(vm) {
+        if (this.lastVM === undefined)
+            return true;
+        if (vm.cancelButtonLabel === this.lastVM.cancelButtonLabel &&
+            vm.message === this.lastVM.message &&
+            vm.title === this.lastVM.title) {
+            return false;
+        }
+        return true;
+    }
+}
+exports.ConfirmDialogPM = ConfirmDialogPM;
+exports.defaultConfirmDialogVM = {
+    message: "",
+    title: "",
+    cancel: () => {
+        console.warn("[ConfirmDialogVM.cancel] default VM!");
+    },
+    cancelButtonLabel: "",
+    confirm: () => {
+        console.warn("[ConfirmDialogVM.confirm] default VM!");
+    },
+    confirmButtonLabel: ""
+};

package/lib/PresentationManagers/Dialog/DialogPM.d.ts

@@ -0,0 +1,19 @@
+import { DialogBase, DialogRepo } from "../../Entities";
+export interface DialogVM {
+    open: boolean;
+    type?: string;
+    dialog?: DialogBase;
+    preventOutsideDismiss?: boolean;
+}
+export declare class DialogPM {
+    private repo;
+    private updateView;
+    private observingDialog;
+    private lastVM?;
+    doUpdateView: () => void;
+    updateAlertObserver(alert: DialogBase | null): void;
+    private vmHasChanged;
+    dispose: () => void;
+    constructor(repo: DialogRepo, updateView: (vm: DialogVM) => void);
+}
+export declare const defualtDialogVM: DialogVM;

package/lib/PresentationManagers/Dialog/DialogPM.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defualtDialogVM = exports.DialogPM = void 0;
+class DialogPM {
+    constructor(repo, updateView) {
+        this.repo = repo;
+        this.updateView = updateView;
+        this.observingDialog = null;
+        this.doUpdateView = () => {
+            let vm = { open: false };
+            const currentDialog = this.repo.activeDialog;
+            if (currentDialog) {
+                this.updateAlertObserver(currentDialog);
+                vm = {
+                    open: currentDialog.isOpen,
+                    type: currentDialog.type,
+                    dialog: currentDialog,
+                    preventOutsideDismiss: currentDialog.preventOutsideDismiss
+                };
+            }
+            else {
+                this.updateAlertObserver(null);
+            }
+            if (!this.vmHasChanged(vm))
+                return;
+            this.updateView(vm);
+            this.lastVM = vm;
+        };
+        this.dispose = () => {
+            this.repo.removeObserver(this.doUpdateView);
+            if (this.observingDialog) {
+                this.observingDialog.removeObserver(this.doUpdateView);
+            }
+        };
+        repo.addObserver(this.doUpdateView);
+        this.doUpdateView();
+    }
+    updateAlertObserver(alert) {
+        if (alert === this.observingDialog)
+            return;
+        if (this.observingDialog !== null) {
+            this.observingDialog.removeObserver(this.doUpdateView);
+        }
+        if (alert !== null) {
+            alert.addObserver(this.doUpdateView);
+        }
+        this.observingDialog = alert;
+    }
+    vmHasChanged(vm) {
+        var _a, _b, _c;
+        if (this.lastVM === undefined)
+            return true;
+        if (vm === null && this.lastVM === null)
+            return false;
+        if ((vm === null || vm === void 0 ? void 0 : vm.open) === ((_a = this.lastVM) === null || _a === void 0 ? void 0 : _a.open) &&
+            (vm === null || vm === void 0 ? void 0 : vm.type) === ((_b = this.lastVM) === null || _b === void 0 ? void 0 : _b.type) &&
+            (vm === null || vm === void 0 ? void 0 : vm.dialog) === ((_c = this.lastVM) === null || _c === void 0 ? void 0 : _c.dialog)) {
+            return false;
+        }
+        return true;
+    }
+}
+exports.DialogPM = DialogPM;
+exports.defualtDialogVM = {
+    open: false
+};

package/lib/PresentationManagers/Dialog/MarkDownEditorDialogPM.d.ts

@@ -0,0 +1,17 @@
+import { DialogMarkDownEditor, DialogRepo } from '../../Entities';
+export interface MarkDownEditorDialogVM {
+    initialText: string;
+    confirm: (text: string) => void;
+}
+export declare class MarkDownEditorDialogPM {
+    private repo;
+    private updateView;
+    private observingMarkDownEditor;
+    private lastVM?;
+    doUpdateView: () => void;
+    updateAlertObserver(markDownEditor: DialogMarkDownEditor | null): void;
+    private vmHasChanged;
+    dispose: () => void;
+    constructor(repo: DialogRepo, updateView: (vm: MarkDownEditorDialogVM) => void);
+}
+export declare const defaultMarkDownEditorDialogVM: MarkDownEditorDialogVM;

package/lib/PresentationManagers/Dialog/MarkDownEditorDialogPM.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultMarkDownEditorDialogVM = exports.MarkDownEditorDialogPM = void 0;
+const Entities_1 = require("../../Entities");
+class MarkDownEditorDialogPM {
+    constructor(repo, updateView) {
+        this.repo = repo;
+        this.updateView = updateView;
+        this.observingMarkDownEditor = null;
+        this.doUpdateView = () => {
+            let vm = {
+                initialText: '',
+                confirm: (text) => {
+                    console.warn('[MarkDownEditorDialogVM.confirm] empty VM!');
+                },
+            };
+            if (this.repo.activeDialog && this.repo.activeDialog.type === Entities_1.markDownEditorDialogType) {
+                const markDownEditorDialog = this.repo.activeDialog;
+                this.updateAlertObserver(markDownEditorDialog);
+                vm = {
+                    confirm: markDownEditorDialog.confirm,
+                    initialText: markDownEditorDialog.initialText,
+                };
+            }
+            else {
+                this.updateAlertObserver(null);
+            }
+            if (!this.vmHasChanged(vm))
+                return;
+            this.updateView(vm);
+            this.lastVM = vm;
+        };
+        this.dispose = () => {
+            this.repo.removeObserver(this.doUpdateView);
+            if (this.observingMarkDownEditor) {
+                this.observingMarkDownEditor.removeObserver(this.doUpdateView);
+            }
+        };
+        repo.addObserver(this.doUpdateView);
+        this.doUpdateView();
+    }
+    updateAlertObserver(markDownEditor) {
+        if (markDownEditor === this.observingMarkDownEditor)
+            return;
+        if (this.observingMarkDownEditor !== null) {
+            this.observingMarkDownEditor.removeObserver(this.doUpdateView);
+        }
+        if (markDownEditor !== null) {
+            markDownEditor.addObserver(this.doUpdateView);
+        }
+        this.observingMarkDownEditor = markDownEditor;
+    }
+    vmHasChanged(vm) {
+        if (this.lastVM === undefined)
+            return true;
+        if (vm.initialText === this.lastVM.initialText) {
+            return false;
+        }
+        return true;
+    }
+}
+exports.MarkDownEditorDialogPM = MarkDownEditorDialogPM;
+exports.defaultMarkDownEditorDialogVM = {
+    initialText: '',
+    confirm: (text) => {
+        console.warn('[MarkDownEditorDialogVM.confirm] default VM!');
+    },
+};