@vived/host 3.0.0

package/lib/Components/Dialog/Entities/DialogAlert.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DialogAlertEntity = exports.alertDialogType = void 0;
+const Entities_1 = require("../../../Entities");
+const DialogQueue_1 = require("./DialogQueue");
+exports.alertDialogType = 'ALERT';
+class DialogAlertEntity extends DialogQueue_1.Dialog {
+    constructor(data, appObject) {
+        super(appObject, DialogAlertEntity.type);
+        this.dialogType = exports.alertDialogType;
+        this.preventOutsideDismiss = false;
+        this.close = () => {
+            this.isOpen = false;
+            if (this.postClose) {
+                this.postClose();
+            }
+        };
+        this._isOpen = new Entities_1.MemoizedBoolean(false, this.notifyOnChange);
+        this.buttonLabel = data.buttonLabel;
+        this.message = data.message;
+        this.title = data.title;
+        this.postClose = data.onClose;
+        if (data.preventOutsideDismiss !== undefined) {
+            this.preventOutsideDismiss = data.preventOutsideDismiss;
+        }
+    }
+    static get(assetID, appObjects) {
+        const appObject = appObjects.get(assetID);
+        if (!appObject) {
+            appObjects.submitWarning('DialogAlertEntity.get', 'Unable to find app object');
+            return undefined;
+        }
+        const uc = appObject.getComponent(DialogAlertEntity.type);
+        if (!uc) {
+            appObjects.submitWarning('DialogAlertEntity.get', 'App Object does not have DialogAlertEntity');
+            return undefined;
+        }
+        return uc;
+    }
+    get isOpen() {
+        return this._isOpen.val;
+    }
+    set isOpen(val) {
+        this._isOpen.val = val;
+    }
+}
+exports.DialogAlertEntity = DialogAlertEntity;
+DialogAlertEntity.type = 'DialogAlertEntity';

package/lib/Components/Dialog/Entities/DialogConfirm.d.ts

@@ -0,0 +1,29 @@
+import { HostAppObject, HostAppObjectRepo } from '../../../HostAppObject';
+import { Dialog } from './DialogQueue';
+export interface DialogConfirmDTO {
+    message: string;
+    title: string;
+    confirmButtonLabel: string;
+    cancelButtonLabel: string;
+    onCancel?: () => void;
+    onConfirm?: () => void;
+}
+export declare const confirmDialogType = "CONFIRM";
+export declare class DialogConfirmEntity extends Dialog {
+    static type: string;
+    static get(assetID: string, appObjects: HostAppObjectRepo): DialogConfirmEntity | undefined;
+    readonly dialogType = "CONFIRM";
+    readonly title: string;
+    readonly message: string;
+    readonly confirmButtonLabel: string;
+    readonly cancelButtonLabel: string;
+    readonly preventOutsideDismiss = true;
+    private postCancel?;
+    cancel: () => void;
+    private postConfirm?;
+    confirm: () => void;
+    private _isOpen;
+    get isOpen(): boolean;
+    set isOpen(val: boolean);
+    constructor(data: DialogConfirmDTO, appObject: HostAppObject);
+}

package/lib/Components/Dialog/Entities/DialogConfirm.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DialogConfirmEntity = exports.confirmDialogType = void 0;
+const Entities_1 = require("../../../Entities");
+const DialogQueue_1 = require("./DialogQueue");
+exports.confirmDialogType = 'CONFIRM';
+class DialogConfirmEntity extends DialogQueue_1.Dialog {
+    constructor(data, appObject) {
+        super(appObject, DialogConfirmEntity.type);
+        this.dialogType = exports.confirmDialogType;
+        this.preventOutsideDismiss = true;
+        this.cancel = () => {
+            this.isOpen = false;
+            if (this.postCancel) {
+                this.postCancel();
+            }
+        };
+        this.confirm = () => {
+            this.isOpen = false;
+            if (this.postConfirm) {
+                this.postConfirm();
+            }
+        };
+        this._isOpen = new Entities_1.MemoizedBoolean(false, this.notifyOnChange);
+        this.confirmButtonLabel = data.confirmButtonLabel;
+        this.cancelButtonLabel = data.cancelButtonLabel;
+        this.message = data.message;
+        this.title = data.title;
+        this.postCancel = data.onCancel;
+        this.postConfirm = data.onConfirm;
+    }
+    static get(assetID, appObjects) {
+        const appObject = appObjects.get(assetID);
+        if (!appObject) {
+            appObjects.submitWarning('DialogConfirmEntity.get', 'Unable to find app object');
+            return undefined;
+        }
+        const uc = appObject.getComponent(DialogConfirmEntity.type);
+        if (!uc) {
+            appObjects.submitWarning('DialogConfirmEntity.get', 'App Object does not have DialogConfirmEntity');
+            return undefined;
+        }
+        return uc;
+    }
+    get isOpen() {
+        return this._isOpen.val;
+    }
+    set isOpen(val) {
+        this._isOpen.val = val;
+    }
+}
+exports.DialogConfirmEntity = DialogConfirmEntity;
+DialogConfirmEntity.type = 'DialogConfirmEntity';

package/lib/Components/Dialog/Entities/DialogMarkDownEditor.d.ts

@@ -0,0 +1,21 @@
+import { HostAppObject, HostAppObjectRepo } from '../../../HostAppObject';
+import { Dialog } from './DialogQueue';
+export interface DialogMarkDownEditorDTO {
+    initialText: string;
+    onConfirm: (text: string) => void;
+}
+export declare const markDownEditorDialogType = "MARKDOWN_EDITOR";
+export declare class DialogMarkDownEntity extends Dialog {
+    static type: string;
+    static get(assetID: string, appObjects: HostAppObjectRepo): DialogMarkDownEntity | undefined;
+    readonly dialogType = "MARKDOWN_EDITOR";
+    readonly initialText: string;
+    readonly preventOutsideDismiss = true;
+    cancel: () => void;
+    private postConfirm;
+    confirm: (text: string) => void;
+    private _isOpen;
+    get isOpen(): boolean;
+    set isOpen(val: boolean);
+    constructor(data: DialogMarkDownEditorDTO, appObject: HostAppObject);
+}

package/lib/Components/Dialog/Entities/DialogMarkDownEditor.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DialogMarkDownEntity = exports.markDownEditorDialogType = void 0;
+const Entities_1 = require("../../../Entities");
+const DialogQueue_1 = require("./DialogQueue");
+exports.markDownEditorDialogType = 'MARKDOWN_EDITOR';
+class DialogMarkDownEntity extends DialogQueue_1.Dialog {
+    constructor(data, appObject) {
+        super(appObject, DialogMarkDownEntity.type);
+        this.dialogType = exports.markDownEditorDialogType;
+        this.preventOutsideDismiss = true;
+        this.cancel = () => {
+            this.isOpen = false;
+        };
+        this.confirm = (text) => {
+            this.isOpen = false;
+            this.postConfirm(text);
+        };
+        this._isOpen = new Entities_1.MemoizedBoolean(false, this.notifyOnChange);
+        this.initialText = data.initialText;
+        this.postConfirm = data.onConfirm;
+    }
+    static get(assetID, appObjects) {
+        const appObject = appObjects.get(assetID);
+        if (!appObject) {
+            appObjects.submitWarning('DialogMarkDownEntity.get', 'Unable to find app object');
+            return undefined;
+        }
+        const uc = appObject.getComponent(DialogMarkDownEntity.type);
+        if (!uc) {
+            appObjects.submitWarning('DialogMarkDownEntity.get', 'App Object does not have DialogAlertEntity');
+            return undefined;
+        }
+        return uc;
+    }
+    get isOpen() {
+        return this._isOpen.val;
+    }
+    set isOpen(val) {
+        this._isOpen.val = val;
+    }
+}
+exports.DialogMarkDownEntity = DialogMarkDownEntity;
+DialogMarkDownEntity.type = 'DialogMarkDownEntity';

package/lib/Components/Dialog/Entities/DialogQueue.d.ts

@@ -0,0 +1,24 @@
+import { HostAppObject, HostAppObjectEntity, HostAppObjectRepo } from '../../../HostAppObject';
+import { DialogAlertDTO, AlertDialogEntity } from './Alert';
+import { DialogConfirmDTO, ConfirmDialogEntity } from './Confirm';
+import { DialogMarkDownEditorDTO, MarkDownEditorDialogEntity } from './MarkDownEditor';
+import { SelectModelDialogEntity } from './SelectModel';
+import { DialogSpinnerDTO, SpinnerDialogEntity } from './Spinner';
+export declare abstract class Dialog extends HostAppObjectEntity {
+    abstract dialogType: string;
+    abstract preventOutsideDismiss: boolean;
+    abstract isOpen: boolean;
+}
+export declare abstract class DialogQueue extends HostAppObjectEntity {
+    static type: string;
+    abstract get activeDialog(): Dialog | null;
+    abstract submitDialog(dialog: Dialog): void;
+    abstract activeDialogHasClosed(): void;
+    abstract alertDialogFactory(dto: DialogAlertDTO): AlertDialogEntity | undefined;
+    abstract confirmDialogFactory(dto: DialogConfirmDTO): ConfirmDialogEntity | undefined;
+    abstract markDownDialogFactory(dto: DialogMarkDownEditorDTO): MarkDownEditorDialogEntity | undefined;
+    abstract selectModelDialogFactory(): SelectModelDialogEntity | undefined;
+    abstract spinnerDialogFactory(dto: DialogSpinnerDTO): SpinnerDialogEntity | undefined;
+    static get(appObjects: HostAppObjectRepo): DialogQueue | undefined;
+}
+export declare function makeDialogQueue(appObject: HostAppObject): DialogQueue;

package/lib/Components/Dialog/Entities/DialogQueue.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeDialogQueue = exports.DialogQueue = exports.Dialog = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+class Dialog extends HostAppObject_1.HostAppObjectEntity {
+}
+exports.Dialog = Dialog;
+class DialogQueue extends HostAppObject_1.HostAppObjectEntity {
+    static get(appObjects) {
+        return HostAppObject_1.getSingletonComponent(DialogQueue.type, appObjects);
+    }
+}
+exports.DialogQueue = DialogQueue;
+DialogQueue.type = 'DialogQueue';
+function makeDialogQueue(appObject) {
+    return new DialogRepoImp(appObject);
+}
+exports.makeDialogQueue = makeDialogQueue;
+class DialogRepoImp extends DialogQueue {
+    constructor(appObject) {
+        super(appObject, DialogQueue.type);
+        this.dialogQueue = [];
+        this.submitDialog = (dialog) => {
+            this.dialogQueue.push(dialog);
+            if (this.activeDialog === dialog) {
+                dialog.isOpen = true;
+            }
+            dialog.addChangeObserver(this.notifyOnChange);
+            this.notifyOnChange();
+        };
+        this.activeDialogHasClosed = () => {
+            const activeDialog = this.activeDialog;
+            if (activeDialog !== null) {
+                this.dialogQueue.splice(0, 1);
+                const newActiveDialog = this.activeDialog;
+                if (newActiveDialog !== null) {
+                    newActiveDialog.isOpen = true;
+                }
+                activeDialog.removeChangeObserver(this.notifyOnChange);
+                this.notifyOnChange();
+            }
+        };
+        this.alertDialogFactory = (dto) => {
+            this.error('Alert factory has not been injected');
+            return;
+        };
+        this.confirmDialogFactory = (dto) => {
+            this.error('Confirm factory has not been injected');
+            return;
+        };
+        this.markDownDialogFactory = (dto) => {
+            this.error('Mark Down factory has not been injected');
+            return;
+        };
+        this.spinnerDialogFactory = (dto) => {
+            this.error('Spinner factory has not been injected');
+            return;
+        };
+        this.appObjects.registerSingleton(this);
+    }
+    get activeDialog() {
+        return this.dialogQueue.length > 0 ? this.dialogQueue[0] : null;
+    }
+    selectModelDialogFactory() {
+        this.error('Select Model factory has not been injected');
+        return;
+    }
+}

package/lib/Components/Dialog/Entities/DialogSpinner.d.ts

@@ -0,0 +1,24 @@
+import { HostAppObject, HostAppObjectRepo } from '../../../HostAppObject';
+import { Dialog } from './DialogQueue';
+export declare const spinnerDialogType = "SPINNER";
+export interface DialogSpinnerDTO {
+    message: string;
+    title: string;
+}
+export declare class DialogSpinnerEntity extends Dialog {
+    static type: string;
+    static get(assetID: string, appObjects: HostAppObjectRepo): DialogSpinnerEntity | undefined;
+    readonly dialogType = "SPINNER";
+    readonly mininumuLifespan = 2000;
+    readonly title: string;
+    private createdAt?;
+    readonly preventOutsideDismiss = true;
+    private memoizedMessage;
+    get message(): string;
+    set message(val: string);
+    private _isOpen;
+    set isOpen(open: boolean);
+    get isOpen(): boolean;
+    close: () => void;
+    constructor(data: DialogSpinnerDTO, appObject: HostAppObject);
+}

package/lib/Components/Dialog/Entities/DialogSpinner.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DialogSpinnerEntity = exports.spinnerDialogType = void 0;
+const Entities_1 = require("../../../Entities");
+const DialogQueue_1 = require("./DialogQueue");
+exports.spinnerDialogType = 'SPINNER';
+class DialogSpinnerEntity extends DialogQueue_1.Dialog {
+    constructor(data, appObject) {
+        super(appObject, DialogSpinnerEntity.type);
+        this.dialogType = exports.spinnerDialogType;
+        this.mininumuLifespan = 2000;
+        this.preventOutsideDismiss = true;
+        this._isOpen = new Entities_1.MemoizedBoolean(false, this.notifyOnChange);
+        this.close = () => {
+            if (this.createdAt === undefined) {
+                this.isOpen = false;
+                return;
+            }
+            const timeAlive = Date.now() - this.createdAt;
+            const timeleft = this.mininumuLifespan - timeAlive;
+            if (timeleft <= 0) {
+                this.isOpen = false;
+            }
+            else {
+                setTimeout(() => {
+                    this.isOpen = false;
+                }, timeleft);
+            }
+        };
+        this.memoizedMessage = new Entities_1.MemoizedString(data.message, this.notifyOnChange);
+        this.title = data.title;
+    }
+    static get(assetID, appObjects) {
+        const appObject = appObjects.get(assetID);
+        if (!appObject) {
+            appObjects.submitWarning('DialogSpinnerEntity.get', 'Unable to find app object');
+            return undefined;
+        }
+        const uc = appObject.getComponent(DialogSpinnerEntity.type);
+        if (!uc) {
+            appObjects.submitWarning('DialogSpinnerEntity.get', 'App Object does not have DialogSpinnerEntity');
+            return undefined;
+        }
+        return uc;
+    }
+    get message() {
+        return this.memoizedMessage.val;
+    }
+    set message(val) {
+        this.memoizedMessage.val = val;
+    }
+    set isOpen(open) {
+        if (open && this.createdAt === undefined) {
+            this.createdAt = Date.now();
+        }
+        this._isOpen.val = open;
+    }
+    get isOpen() {
+        return this._isOpen.val;
+    }
+}
+exports.DialogSpinnerEntity = DialogSpinnerEntity;
+DialogSpinnerEntity.type = 'DialogSpinnerEntity';

package/lib/Components/Dialog/Entities/MarkDownEditor.d.ts

@@ -0,0 +1,21 @@
+import { HostAppObject, HostAppObjectRepo } from '../../../HostAppObject';
+import { Dialog } from './DialogQueue';
+export interface DialogMarkDownEditorDTO {
+    initialText: string;
+    onConfirm: (text: string) => void;
+}
+export declare const markDownEditorDialogType = "MARKDOWN_EDITOR";
+export declare class MarkDownEditorDialogEntity extends Dialog {
+    static type: string;
+    static get(assetID: string, appObjects: HostAppObjectRepo): MarkDownEditorDialogEntity | undefined;
+    readonly dialogType = "MARKDOWN_EDITOR";
+    readonly initialText: string;
+    readonly preventOutsideDismiss = true;
+    cancel: () => void;
+    private postConfirm;
+    confirm: (text: string) => void;
+    private _isOpen;
+    get isOpen(): boolean;
+    set isOpen(val: boolean);
+    constructor(data: DialogMarkDownEditorDTO, appObject: HostAppObject);
+}

package/lib/Components/Dialog/Entities/MarkDownEditor.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MarkDownEditorDialogEntity = exports.markDownEditorDialogType = void 0;
+const Entities_1 = require("../../../Entities");
+const DialogQueue_1 = require("./DialogQueue");
+exports.markDownEditorDialogType = 'MARKDOWN_EDITOR';
+class MarkDownEditorDialogEntity extends DialogQueue_1.Dialog {
+    constructor(data, appObject) {
+        super(appObject, MarkDownEditorDialogEntity.type);
+        this.dialogType = exports.markDownEditorDialogType;
+        this.preventOutsideDismiss = true;
+        this.cancel = () => {
+            this.isOpen = false;
+        };
+        this.confirm = (text) => {
+            this.isOpen = false;
+            this.postConfirm(text);
+        };
+        this._isOpen = new Entities_1.MemoizedBoolean(false, this.notifyOnChange);
+        this.initialText = data.initialText;
+        this.postConfirm = data.onConfirm;
+    }
+    static get(assetID, appObjects) {
+        const appObject = appObjects.get(assetID);
+        if (!appObject) {
+            appObjects.submitWarning('MarkDownEditorDialogEntity.get', 'Unable to find app object');
+            return undefined;
+        }
+        const uc = appObject.getComponent(MarkDownEditorDialogEntity.type);
+        if (!uc) {
+            appObjects.submitWarning('MarkDownEditorDialogEntity.get', 'App Object does not have DialogAlertEntity');
+            return undefined;
+        }
+        return uc;
+    }
+    get isOpen() {
+        return this._isOpen.val;
+    }
+    set isOpen(val) {
+        this._isOpen.val = val;
+    }
+}
+exports.MarkDownEditorDialogEntity = MarkDownEditorDialogEntity;
+MarkDownEditorDialogEntity.type = 'MarkDownEditorDialogEntity';

package/lib/Components/Dialog/Entities/SelectModel.d.ts

@@ -0,0 +1,20 @@
+import { MemoizedBoolean } from '../../../Entities';
+import { HostAppObject, HostAppObjectRepo } from '../../../HostAppObject';
+import { Dialog } from './DialogQueue';
+export declare const selectModelDialogType = "SELECT_CHANNEL_MODEL";
+export declare class SelectModelDialogEntity extends Dialog {
+    static type: string;
+    static get(assetID: string, appObjects: HostAppObjectRepo): SelectModelDialogEntity | undefined;
+    readonly dialogType = "SELECT_CHANNEL_MODEL";
+    private _isOpen;
+    get isOpen(): boolean;
+    set isOpen(val: boolean);
+    preventOutsideDismiss: boolean;
+    protected _container?: HTMLElement;
+    get container(): HTMLElement | undefined;
+    set container(element: HTMLElement | undefined);
+    protected memoizedIsReady: MemoizedBoolean;
+    get isReady(): boolean;
+    set isReady(isReady: boolean);
+    constructor(appObject: HostAppObject);
+}

package/lib/Components/Dialog/Entities/SelectModel.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SelectModelDialogEntity = exports.selectModelDialogType = void 0;
+const Entities_1 = require("../../../Entities");
+const DialogQueue_1 = require("./DialogQueue");
+exports.selectModelDialogType = 'SELECT_CHANNEL_MODEL';
+class SelectModelDialogEntity extends DialogQueue_1.Dialog {
+    constructor(appObject) {
+        super(appObject, SelectModelDialogEntity.type);
+        this.dialogType = exports.selectModelDialogType;
+        this._isOpen = new Entities_1.MemoizedBoolean(false, this.notifyOnChange);
+        this.preventOutsideDismiss = true;
+        this.memoizedIsReady = new Entities_1.MemoizedBoolean(false, this.notifyOnChange);
+    }
+    static get(assetID, appObjects) {
+        const appObject = appObjects.get(assetID);
+        if (!appObject) {
+            appObjects.submitWarning('SelectModelDialogEntity.get', 'Unable to find app object');
+            return undefined;
+        }
+        const uc = appObject.getComponent(SelectModelDialogEntity.type);
+        if (!uc) {
+            appObjects.submitWarning('SelectModelDialogEntity.get', 'App Object does not have SelectModelDialogEntity');
+            return undefined;
+        }
+        return uc;
+    }
+    get isOpen() {
+        return this._isOpen.val;
+    }
+    set isOpen(val) {
+        this._isOpen.val = val;
+    }
+    get container() {
+        return this._container;
+    }
+    set container(element) {
+        this._container = element;
+        this.notifyOnChange();
+    }
+    get isReady() {
+        return this.memoizedIsReady.val;
+    }
+    set isReady(isReady) {
+        this.memoizedIsReady.val = isReady;
+    }
+}
+exports.SelectModelDialogEntity = SelectModelDialogEntity;
+SelectModelDialogEntity.type = 'SelectModelDialogEntity';

package/lib/Components/Dialog/Entities/Spinner.d.ts

@@ -0,0 +1,24 @@
+import { HostAppObject, HostAppObjectRepo } from '../../../HostAppObject';
+import { Dialog } from './DialogQueue';
+export declare const spinnerDialogType = "SPINNER";
+export interface DialogSpinnerDTO {
+    message: string;
+    title: string;
+}
+export declare class SpinnerDialogEntity extends Dialog {
+    static type: string;
+    static get(assetID: string, appObjects: HostAppObjectRepo): SpinnerDialogEntity | undefined;
+    readonly dialogType = "SPINNER";
+    readonly mininumuLifespan = 2000;
+    readonly title: string;
+    private createdAt?;
+    readonly preventOutsideDismiss = true;
+    private memoizedMessage;
+    get message(): string;
+    set message(val: string);
+    private _isOpen;
+    set isOpen(open: boolean);
+    get isOpen(): boolean;
+    close: () => void;
+    constructor(data: DialogSpinnerDTO, appObject: HostAppObject);
+}

package/lib/Components/Dialog/Entities/Spinner.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpinnerDialogEntity = exports.spinnerDialogType = void 0;
+const Entities_1 = require("../../../Entities");
+const DialogQueue_1 = require("./DialogQueue");
+exports.spinnerDialogType = 'SPINNER';
+class SpinnerDialogEntity extends DialogQueue_1.Dialog {
+    constructor(data, appObject) {
+        super(appObject, SpinnerDialogEntity.type);
+        this.dialogType = exports.spinnerDialogType;
+        this.mininumuLifespan = 2000;
+        this.preventOutsideDismiss = true;
+        this._isOpen = new Entities_1.MemoizedBoolean(false, this.notifyOnChange);
+        this.close = () => {
+            if (this.createdAt === undefined) {
+                this.isOpen = false;
+                return;
+            }
+            const timeAlive = Date.now() - this.createdAt;
+            const timeleft = this.mininumuLifespan - timeAlive;
+            if (timeleft <= 0) {
+                this.isOpen = false;
+            }
+            else {
+                setTimeout(() => {
+                    this.isOpen = false;
+                }, timeleft);
+            }
+        };
+        this.memoizedMessage = new Entities_1.MemoizedString(data.message, this.notifyOnChange);
+        this.title = data.title;
+    }
+    static get(assetID, appObjects) {
+        const appObject = appObjects.get(assetID);
+        if (!appObject) {
+            appObjects.submitWarning('SpinnerDialogEntity.get', 'Unable to find app object');
+            return undefined;
+        }
+        const uc = appObject.getComponent(SpinnerDialogEntity.type);
+        if (!uc) {
+            appObjects.submitWarning('SpinnerDialogEntity.get', 'App Object does not have SpinnerDialogEntity');
+            return undefined;
+        }
+        return uc;
+    }
+    get message() {
+        return this.memoizedMessage.val;
+    }
+    set message(val) {
+        this.memoizedMessage.val = val;
+    }
+    set isOpen(open) {
+        if (open && this.createdAt === undefined) {
+            this.createdAt = Date.now();
+        }
+        this._isOpen.val = open;
+    }
+    get isOpen() {
+        return this._isOpen.val;
+    }
+}
+exports.SpinnerDialogEntity = SpinnerDialogEntity;
+SpinnerDialogEntity.type = 'SpinnerDialogEntity';

package/lib/Components/Dialog/Entities/index.d.ts

@@ -0,0 +1,6 @@
+export * from './Alert';
+export * from './Confirm';
+export * from './MarkDownEditor';
+export * from './DialogQueue';
+export * from './SelectModel';
+export * from './Spinner';

package/lib/Components/Dialog/Entities/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("./Alert"), exports);
+__exportStar(require("./Confirm"), exports);
+__exportStar(require("./MarkDownEditor"), exports);
+__exportStar(require("./DialogQueue"), exports);
+__exportStar(require("./SelectModel"), exports);
+__exportStar(require("./Spinner"), exports);

package/lib/Components/Dialog/Factories/alertDialogFactory.d.ts

@@ -0,0 +1,3 @@
+import { HostAppObjectRepo } from "../../../HostAppObject";
+import { AlertDialogEntity, DialogAlertDTO } from "../Entities";
+export declare function makeAlertFactory(appObjects: HostAppObjectRepo): (data: DialogAlertDTO) => AlertDialogEntity;

package/lib/Components/Dialog/Factories/alertDialogFactory.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeAlertFactory = void 0;
+const Utilities_1 = require("../../../Utilities");
+const Entities_1 = require("../Entities");
+const PMs_1 = require("../PMs");
+function makeAlertFactory(appObjects) {
+    return function alertFactory(data) {
+        const ao = appObjects.getOrCreate(Utilities_1.generateUniqueID());
+        const entity = new Entities_1.AlertDialogEntity(data, ao);
+        new PMs_1.AlertDialogPM(ao);
+        return entity;
+    };
+}
+exports.makeAlertFactory = makeAlertFactory;

package/lib/Components/Dialog/Factories/confirmDialogFactory.d.ts

@@ -0,0 +1,3 @@
+import { HostAppObjectRepo } from "../../../HostAppObject";
+import { ConfirmDialogEntity, DialogConfirmDTO } from "../Entities";
+export declare function makeConfirmFactory(appObjects: HostAppObjectRepo): (data: DialogConfirmDTO) => ConfirmDialogEntity;