@vived/host 3.0.0

package/lib/Components/Assets/UCs/GetAssetBlobURLUC.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeGetAssetBlobURLUC = exports.GetAssetBlobURLUC = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+const VivedAPI_1 = require("../../VivedAPI");
+const AssetRepo_1 = require("../Entities/AssetRepo");
+const GetAssetUC_1 = require("./GetAssetUC");
+class GetAssetBlobURLUC extends HostAppObject_1.HostAppObjectUC {
+    static get(appObjects) {
+        return HostAppObject_1.getSingletonComponent(GetAssetBlobURLUC.type, appObjects);
+    }
+}
+exports.GetAssetBlobURLUC = GetAssetBlobURLUC;
+GetAssetBlobURLUC.type = "GetAssetBlobURLUC";
+function makeGetAssetBlobURLUC(appObject) {
+    return new GetAssetBlobURLUCImp(appObject);
+}
+exports.makeGetAssetBlobURLUC = makeGetAssetBlobURLUC;
+class GetAssetBlobURLUCImp extends GetAssetBlobURLUC {
+    constructor(appObject) {
+        super(appObject, GetAssetBlobURLUC.type);
+        this.getAssetBlobURL = (assetID) => {
+            const assetRepo = this.assetRepo;
+            const getAsset = this.getAsset;
+            const fetchAssetFile = this.fetchAssetFile;
+            if (!assetRepo || !getAsset || !fetchAssetFile) {
+                return Promise.reject();
+            }
+            const existing = assetRepo.get(assetID);
+            if (existing && existing.blobURL) {
+                return Promise.resolve(existing.blobURL);
+            }
+            return new Promise((resolve, reject) => {
+                let fetchedAsset;
+                getAsset(assetID)
+                    .then((asset) => {
+                    asset.isFetchingFile = true;
+                    asset.fetchError = undefined;
+                    fetchedAsset = asset;
+                    return fetchAssetFile(asset);
+                })
+                    .then((file) => {
+                    if (fetchedAsset) {
+                        fetchedAsset.setFile(file);
+                        fetchedAsset.isFetchingFile = false;
+                        if (fetchedAsset.blobURL) {
+                            resolve(fetchedAsset.blobURL);
+                            return;
+                        }
+                    }
+                    reject(new Error("Blob URL is empty"));
+                })
+                    .catch((e) => {
+                    if (fetchedAsset) {
+                        fetchedAsset.fetchError = e;
+                        fetchedAsset.isFetchingFile = false;
+                    }
+                    reject(e);
+                });
+            });
+        };
+        this.appObjects.registerSingleton(this);
+        this.assetRepo = appObject.getComponent(AssetRepo_1.AssetRepo.type);
+        if (!this.assetRepo) {
+            this.error("UC added to an App Object that does not have AssetRepo");
+            return;
+        }
+    }
+    get fetchAssetFile() {
+        var _a;
+        return (_a = this.getCachedSingleton(VivedAPI_1.FetchAssetFileFromAPIUC.type)) === null || _a === void 0 ? void 0 : _a.doFetch;
+    }
+    get getAsset() {
+        var _a;
+        return (_a = this.getCachedSingleton(GetAssetUC_1.GetAssetUC.type)) === null || _a === void 0 ? void 0 : _a.getAsset;
+    }
+}

package/lib/Components/Assets/UCs/GetAssetFileUC.d.ts

@@ -0,0 +1,7 @@
+import { HostAppObject, HostAppObjectRepo, HostAppObjectUC } from "../../../HostAppObject";
+export declare abstract class GetAssetFileUC extends HostAppObjectUC {
+    static type: string;
+    abstract getAssetFile(assetID: string): Promise<File>;
+    static get(appObjects: HostAppObjectRepo): GetAssetFileUC | undefined;
+}
+export declare function makeGetAssetFileUC(appObject: HostAppObject): GetAssetFileUC;

package/lib/Components/Assets/UCs/GetAssetFileUC.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeGetAssetFileUC = exports.GetAssetFileUC = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+const VivedAPI_1 = require("../../VivedAPI");
+const AssetRepo_1 = require("../Entities/AssetRepo");
+const GetAssetUC_1 = require("./GetAssetUC");
+class GetAssetFileUC extends HostAppObject_1.HostAppObjectUC {
+    static get(appObjects) {
+        return HostAppObject_1.getSingletonComponent(GetAssetFileUC.type, appObjects);
+    }
+}
+exports.GetAssetFileUC = GetAssetFileUC;
+GetAssetFileUC.type = "GetAssetFileUC";
+function makeGetAssetFileUC(appObject) {
+    return new GetAssetFileUCImp(appObject);
+}
+exports.makeGetAssetFileUC = makeGetAssetFileUC;
+class GetAssetFileUCImp extends GetAssetFileUC {
+    constructor(appObject) {
+        super(appObject, GetAssetFileUC.type);
+        this.getAssetFile = (assetID) => {
+            const assetRepo = this.assetRepo;
+            const getAsset = this.getAsset;
+            const fetchAssetFile = this.fetchAssetFile;
+            if (!assetRepo || !getAsset || !fetchAssetFile) {
+                return Promise.reject();
+            }
+            const existing = assetRepo.get(assetID);
+            if (existing && existing.file) {
+                return Promise.resolve(existing.file);
+            }
+            return new Promise((resolve, reject) => {
+                let fetchedAsset;
+                getAsset(assetID)
+                    .then((asset) => {
+                    asset.isFetchingFile = true;
+                    asset.fetchError = undefined;
+                    fetchedAsset = asset;
+                    return fetchAssetFile(asset);
+                })
+                    .then((file) => {
+                    if (fetchedAsset) {
+                        fetchedAsset.setFile(file);
+                        fetchedAsset.isFetchingFile = false;
+                    }
+                    resolve(file);
+                })
+                    .catch((e) => {
+                    if (fetchedAsset) {
+                        fetchedAsset.fetchError = e;
+                        fetchedAsset.isFetchingFile = false;
+                    }
+                    reject(e);
+                });
+            });
+        };
+        this.appObjects.registerSingleton(this);
+        this.assetRepo = appObject.getComponent(AssetRepo_1.AssetRepo.type);
+        if (!this.assetRepo) {
+            this.error("UC added to an App Object that does not have AssetRepo");
+            return;
+        }
+    }
+    get fetchAssetFile() {
+        var _a;
+        return (_a = this.getCachedSingleton(VivedAPI_1.FetchAssetFileFromAPIUC.type)) === null || _a === void 0 ? void 0 : _a.doFetch;
+    }
+    get getAsset() {
+        var _a;
+        return (_a = this.getCachedSingleton(GetAssetUC_1.GetAssetUC.type)) === null || _a === void 0 ? void 0 : _a.getAsset;
+    }
+}

package/lib/Components/Assets/UCs/GetAssetUC.d.ts

@@ -0,0 +1,8 @@
+import { HostAppObject, HostAppObjectRepo, HostAppObjectUC } from "../../../HostAppObject";
+import { AssetEntity } from "../Entities/AssetEntity";
+export declare abstract class GetAssetUC extends HostAppObjectUC {
+    static type: string;
+    abstract getAsset(assetID: string): Promise<AssetEntity>;
+    static get(appObjects: HostAppObjectRepo): GetAssetUC | undefined;
+}
+export declare function makeGetAssetUC(appObject: HostAppObject): GetAssetUC;

package/lib/Components/Assets/UCs/GetAssetUC.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeGetAssetUC = exports.GetAssetUC = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+const VivedAPI_1 = require("../../VivedAPI");
+const AssetRepo_1 = require("../Entities/AssetRepo");
+class GetAssetUC extends HostAppObject_1.HostAppObjectUC {
+    static get(appObjects) {
+        return HostAppObject_1.getSingletonComponent(GetAssetUC.type, appObjects);
+    }
+}
+exports.GetAssetUC = GetAssetUC;
+GetAssetUC.type = "GetAssetUC";
+function makeGetAssetUC(appObject) {
+    return new GetAssetUCImp(appObject);
+}
+exports.makeGetAssetUC = makeGetAssetUC;
+class GetAssetUCImp extends GetAssetUC {
+    constructor(appObject) {
+        super(appObject, GetAssetUC.type);
+        this.getAsset = (assetID) => {
+            const assetRepo = this.assetRepo;
+            const fetchAssetMeta = this.fetchAssetMeta;
+            if (!assetRepo || !fetchAssetMeta) {
+                return Promise.reject();
+            }
+            if (assetRepo.has(assetID)) {
+                return Promise.resolve(assetRepo.get(assetID));
+            }
+            return new Promise((resolve, reject) => {
+                fetchAssetMeta(assetID)
+                    .then((baseDTO) => {
+                    const baseAsset = assetRepo.addFromDTO(baseDTO);
+                    resolve(baseAsset);
+                })
+                    .catch((e) => {
+                    this.warn(e.message);
+                    reject(e);
+                });
+            });
+        };
+        this.appObjects.registerSingleton(this);
+        this.assetRepo = appObject.getComponent(AssetRepo_1.AssetRepo.type);
+        if (!this.assetRepo) {
+            this.error("UC added to an App Object that does not have AssetRepo");
+            return;
+        }
+    }
+    get fetchAssetMeta() {
+        var _a;
+        return (_a = this.getCachedSingleton(VivedAPI_1.FetchAssetMetaFromAPIUC.type)) === null || _a === void 0 ? void 0 : _a.doFetch;
+    }
+}

package/lib/Components/Assets/UCs/UpdateArchiveAssetUC.d.ts

@@ -0,0 +1,7 @@
+import { HostAppObject, HostAppObjectRepo, HostAppObjectUC } from '../../../HostAppObject';
+export declare abstract class UpdateAssetIsArchivedUC extends HostAppObjectUC {
+    static type: string;
+    abstract setIsArchived(assetID: string, isArchived: boolean): Promise<void>;
+    static get(hostAppObjects: HostAppObjectRepo): UpdateAssetIsArchivedUC | undefined;
+}
+export declare function makeUpdateAssetIsArchivedUC(appObject: HostAppObject): UpdateAssetIsArchivedUC;

package/lib/Components/Assets/UCs/UpdateArchiveAssetUC.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeUpdateAssetIsArchivedUC = exports.UpdateAssetIsArchivedUC = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+const AppAssetsEntity_1 = require("../Entities/AppAssetsEntity");
+const AssetRepo_1 = require("../Entities/AssetRepo");
+class UpdateAssetIsArchivedUC extends HostAppObject_1.HostAppObjectUC {
+    static get(hostAppObjects) {
+        return HostAppObject_1.getSingletonComponent(UpdateAssetIsArchivedUC.type, hostAppObjects);
+    }
+}
+exports.UpdateAssetIsArchivedUC = UpdateAssetIsArchivedUC;
+UpdateAssetIsArchivedUC.type = 'UpdateAssetIsArchivedUC';
+function makeUpdateAssetIsArchivedUC(appObject) {
+    return new UpdateAssetIsArchivedUCImp(appObject);
+}
+exports.makeUpdateAssetIsArchivedUC = makeUpdateAssetIsArchivedUC;
+class UpdateAssetIsArchivedUCImp extends UpdateAssetIsArchivedUC {
+    constructor(appObject) {
+        super(appObject, UpdateAssetIsArchivedUC.type);
+        this.setIsArchived = (assetID, isArchived) => {
+            const assetRepo = this.assetRepo;
+            if (!assetRepo) {
+                return Promise.reject();
+            }
+            return new Promise((resolve, reject) => {
+                assetRepo
+                    .get(assetID)
+                    .then((asset) => {
+                    if (asset.archived === isArchived) {
+                        resolve();
+                    }
+                    else {
+                        assetRepo
+                            .setAssetArchived(assetID, isArchived)
+                            .then(() => {
+                            var _a;
+                            asset.archived = isArchived;
+                            (_a = this.appAssets) === null || _a === void 0 ? void 0 : _a.notifyOnChange();
+                            resolve();
+                        })
+                            .catch((e) => {
+                            reject(e);
+                        });
+                    }
+                })
+                    .catch((e) => {
+                    reject(new Error('Unable to find app asset by id ' + assetID));
+                });
+            });
+        };
+    }
+    get assetRepo() {
+        return this.getCachedSingleton(AssetRepo_1.AssetRepo.type);
+    }
+    get appAssets() {
+        return this.getCachedSingleton(AppAssetsEntity_1.AppAssetsEntity.type);
+    }
+}

package/lib/Components/Assets/UCs/UpdateAssetFileUC.d.ts

@@ -0,0 +1,12 @@
+import { HostAppObject, HostAppObjectRepo, HostAppObjectUC } from "../../../HostAppObject";
+export interface UpdateAssetMetaDTO {
+    name: string;
+    description: string;
+    archived: boolean;
+}
+export declare abstract class UpdateAssetFileUC extends HostAppObjectUC {
+    static type: string;
+    abstract updateFile(file: File): Promise<void>;
+    static get(assetID: string, appObjects: HostAppObjectRepo): UpdateAssetFileUC | undefined;
+}
+export declare function makeUpdateAssetFileUC(appObject: HostAppObject): UpdateAssetFileUC;

package/lib/Components/Assets/UCs/UpdateAssetFileUC.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeUpdateAssetFileUC = exports.UpdateAssetFileUC = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+const Dialog_1 = require("../../Dialog");
+const VivedAPI_1 = require("../../VivedAPI");
+const AssetEntity_1 = require("../Entities/AssetEntity");
+class UpdateAssetFileUC extends HostAppObject_1.HostAppObjectUC {
+    static get(assetID, appObjects) {
+        const appObject = appObjects.get(assetID);
+        if (!appObject) {
+            appObjects.submitWarning("UpdateAssetFileUC.get", "Unable to find app object");
+            return undefined;
+        }
+        const uc = appObject.getComponent(UpdateAssetFileUC.type);
+        if (!uc) {
+            appObjects.submitWarning("UpdateAssetFileUC.get", "App Object does not have UpdateAssetFileUC");
+            return undefined;
+        }
+        return uc;
+    }
+}
+exports.UpdateAssetFileUC = UpdateAssetFileUC;
+UpdateAssetFileUC.type = "UpdateAssetFileUC";
+function makeUpdateAssetFileUC(appObject) {
+    return new UpdateAssetFileUCImp(appObject);
+}
+exports.makeUpdateAssetFileUC = makeUpdateAssetFileUC;
+class UpdateAssetFileUCImp extends UpdateAssetFileUC {
+    constructor(appObject) {
+        super(appObject, UpdateAssetFileUC.type);
+        this.updateFile = (file) => {
+            const asset = this.asset;
+            if (!asset) {
+                return Promise.reject(new Error("No Asset Entity"));
+            }
+            const patchAssetFile = this.patchAssetFile;
+            const dialogQueue = this.dialogQueue;
+            if (!patchAssetFile || !dialogQueue) {
+                return Promise.reject();
+            }
+            const spinnerDialog = dialogQueue.spinnerDialogFactory({
+                title: "Asset File",
+                message: "Updating asset's file..."
+            });
+            if (spinnerDialog)
+                dialogQueue.submitDialog(spinnerDialog);
+            return new Promise((resolve, reject) => {
+                patchAssetFile(asset.id, file)
+                    .then((newFilename) => {
+                    asset.setFile(file);
+                    asset.filename = newFilename;
+                    spinnerDialog === null || spinnerDialog === void 0 ? void 0 : spinnerDialog.close();
+                    resolve();
+                })
+                    .catch((e) => {
+                    this.error("Patch asset file error: " + e.message);
+                    spinnerDialog === null || spinnerDialog === void 0 ? void 0 : spinnerDialog.close();
+                    const dialogDTO = {
+                        buttonLabel: "OK",
+                        message: `Something went wrong when updating the asset's file. Check the console. ${e.message}`,
+                        title: "Update Asset File Error",
+                    };
+                    const confirmDialog = dialogQueue.alertDialogFactory(dialogDTO);
+                    if (confirmDialog)
+                        dialogQueue.submitDialog(confirmDialog);
+                    resolve();
+                });
+            });
+        };
+        this.asset = appObject.getComponent(AssetEntity_1.AssetEntity.type);
+        if (!this.asset) {
+            this.error("UC has been added to an App Object that does not have ArchiveAssetUC");
+        }
+    }
+    get patchAssetFile() {
+        var _a;
+        return (_a = this.getCachedSingleton(VivedAPI_1.PatchAssetFileUC.type)) === null || _a === void 0 ? void 0 : _a.doPatch;
+    }
+    get dialogQueue() {
+        return this.getCachedSingleton(Dialog_1.DialogQueue.type);
+    }
+}

package/lib/Components/Assets/UCs/index.d.ts

@@ -0,0 +1,8 @@
+export * from './ArchiveAssetUC';
+export * from './DeleteAssetUC';
+export * from './DownloadAssetFileUC';
+export * from './GetAppAssetsUC';
+export * from './GetAssetBlobURLUC';
+export * from './GetAssetFileUC';
+export * from './GetAssetUC';
+export * from './UpdateAssetFileUC';

package/lib/Components/Assets/UCs/index.js

@@ -0,0 +1,20 @@
+"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("./ArchiveAssetUC"), exports);
+__exportStar(require("./DeleteAssetUC"), exports);
+__exportStar(require("./DownloadAssetFileUC"), exports);
+__exportStar(require("./GetAppAssetsUC"), exports);
+__exportStar(require("./GetAssetBlobURLUC"), exports);
+__exportStar(require("./GetAssetFileUC"), exports);
+__exportStar(require("./GetAssetUC"), exports);
+__exportStar(require("./UpdateAssetFileUC"), exports);

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

@@ -0,0 +1,5 @@
+export * from './Controllers';
+export * from './Entities';
+export * from './Mocks';
+export * from './PMs';
+export * from './UCs';

package/lib/Components/Assets/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("./Controllers"), exports);
+__exportStar(require("./Entities"), exports);
+__exportStar(require("./Mocks"), exports);
+__exportStar(require("./PMs"), exports);
+__exportStar(require("./UCs"), exports);

package/lib/Components/Dialog/Controllers/activeDialogHasClosed.d.ts

@@ -0,0 +1,2 @@
+import { HostAppObjectRepo } from '../../../HostAppObject';
+export declare function activeDialogHasClosed(appObjects: HostAppObjectRepo): void;

package/lib/Components/Dialog/Controllers/activeDialogHasClosed.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.activeDialogHasClosed = void 0;
+const Entities_1 = require("../Entities");
+function activeDialogHasClosed(appObjects) {
+    const dialogQueue = Entities_1.DialogQueue.get(appObjects);
+    if (dialogQueue) {
+        dialogQueue.activeDialogHasClosed();
+    }
+    else {
+        appObjects.submitWarning('activeDialogHasClosed', 'Unable to find DialogQueue');
+    }
+}
+exports.activeDialogHasClosed = activeDialogHasClosed;

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

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

package/lib/Components/Dialog/Controllers/index.js

@@ -0,0 +1,13 @@
+"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("./activeDialogHasClosed"), exports);

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

@@ -0,0 +1,25 @@
+import { HostAppObject, HostAppObjectRepo } from '../../../HostAppObject';
+import { Dialog } from './DialogQueue';
+export interface DialogAlertDTO {
+    message: string;
+    title: string;
+    buttonLabel: string;
+    onClose?: () => void;
+    preventOutsideDismiss?: boolean;
+}
+export declare const alertDialogType = "ALERT";
+export declare class AlertDialogEntity extends Dialog {
+    static type: string;
+    static get(assetID: string, appObjects: HostAppObjectRepo): AlertDialogEntity | undefined;
+    readonly dialogType = "ALERT";
+    readonly title: string;
+    readonly message: string;
+    readonly buttonLabel: string;
+    readonly preventOutsideDismiss: boolean;
+    private postClose?;
+    close: () => void;
+    private _isOpen;
+    get isOpen(): boolean;
+    set isOpen(val: boolean);
+    constructor(data: DialogAlertDTO, appObject: HostAppObject);
+}

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

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AlertDialogEntity = exports.alertDialogType = void 0;
+const Entities_1 = require("../../../Entities");
+const DialogQueue_1 = require("./DialogQueue");
+exports.alertDialogType = 'ALERT';
+class AlertDialogEntity extends DialogQueue_1.Dialog {
+    constructor(data, appObject) {
+        super(appObject, AlertDialogEntity.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('AlertDialogEntity.get', 'Unable to find app object');
+            return undefined;
+        }
+        const uc = appObject.getComponent(AlertDialogEntity.type);
+        if (!uc) {
+            appObjects.submitWarning('AlertDialogEntity.get', 'App Object does not have AlertDialogEntity');
+            return undefined;
+        }
+        return uc;
+    }
+    get isOpen() {
+        return this._isOpen.val;
+    }
+    set isOpen(val) {
+        this._isOpen.val = val;
+    }
+}
+exports.AlertDialogEntity = AlertDialogEntity;
+AlertDialogEntity.type = 'AlertDialogEntity';

package/lib/Components/Dialog/Entities/Confirm.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 ConfirmDialogEntity extends Dialog {
+    static type: string;
+    static get(assetID: string, appObjects: HostAppObjectRepo): ConfirmDialogEntity | 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/Confirm.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfirmDialogEntity = exports.confirmDialogType = void 0;
+const Entities_1 = require("../../../Entities");
+const DialogQueue_1 = require("./DialogQueue");
+exports.confirmDialogType = 'CONFIRM';
+class ConfirmDialogEntity extends DialogQueue_1.Dialog {
+    constructor(data, appObject) {
+        super(appObject, ConfirmDialogEntity.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('ConfirmDialogEntity.get', 'Unable to find app object');
+            return undefined;
+        }
+        const uc = appObject.getComponent(ConfirmDialogEntity.type);
+        if (!uc) {
+            appObjects.submitWarning('ConfirmDialogEntity.get', 'App Object does not have ConfirmDialogEntity');
+            return undefined;
+        }
+        return uc;
+    }
+    get isOpen() {
+        return this._isOpen.val;
+    }
+    set isOpen(val) {
+        this._isOpen.val = val;
+    }
+}
+exports.ConfirmDialogEntity = ConfirmDialogEntity;
+ConfirmDialogEntity.type = 'ConfirmDialogEntity';

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

@@ -0,0 +1,25 @@
+import { HostAppObject, HostAppObjectRepo } from '../../../HostAppObject';
+import { Dialog } from './DialogQueue';
+export interface DialogAlertDTO {
+    message: string;
+    title: string;
+    buttonLabel: string;
+    onClose?: () => void;
+    preventOutsideDismiss?: boolean;
+}
+export declare const alertDialogType = "ALERT";
+export declare class DialogAlertEntity extends Dialog {
+    static type: string;
+    static get(assetID: string, appObjects: HostAppObjectRepo): DialogAlertEntity | undefined;
+    readonly dialogType = "ALERT";
+    readonly title: string;
+    readonly message: string;
+    readonly buttonLabel: string;
+    readonly preventOutsideDismiss: boolean;
+    private postClose?;
+    close: () => void;
+    private _isOpen;
+    get isOpen(): boolean;
+    set isOpen(val: boolean);
+    constructor(data: DialogAlertDTO, appObject: HostAppObject);
+}