@vived/host 3.2.0 → 3.4.0

package/lib/Components/Dialog/Mocks/MockMakeSelectModelDialogUC.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMockMakeSelectModelDialogUC = exports.MockMakeSelectModelDialogUC = void 0;
+const MakeSelectModelDialogUC_1 = require("../UCs/MakeSelectModelDialogUC");
+class MockMakeSelectModelDialogUC extends MakeSelectModelDialogUC_1.MakeSelectModelDialogUC {
+    constructor(appObject) {
+        super(appObject, MakeSelectModelDialogUC_1.MakeSelectModelDialogUC.type);
+        this.make = jest.fn();
+        this.factory = jest.fn();
+    }
+}
+exports.MockMakeSelectModelDialogUC = MockMakeSelectModelDialogUC;
+function makeMockMakeSelectModelDialogUC(appObjects) {
+    return new MockMakeSelectModelDialogUC(appObjects.getOrCreate("MockMakeSelectModelDialogUC"));
+}
+exports.makeMockMakeSelectModelDialogUC = makeMockMakeSelectModelDialogUC;

package/lib/Components/Dialog/Mocks/MockMakeSpinnerDialogUC.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="jest" />
+import { HostAppObject, HostAppObjectRepo } from "../../../HostAppObject";
+import { MakeSpinnerDialogUC } from "../UCs/MakeSpinnerDialogUC";
+export declare class MockMakeSpinnerDialogUC extends MakeSpinnerDialogUC {
+    make: jest.Mock<any, any>;
+    factory: jest.Mock<any, any>;
+    constructor(appObject: HostAppObject);
+}
+export declare function makeMockMakeSpinnerDialogUC(appObjects: HostAppObjectRepo): MockMakeSpinnerDialogUC;

package/lib/Components/Dialog/Mocks/MockMakeSpinnerDialogUC.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMockMakeSpinnerDialogUC = exports.MockMakeSpinnerDialogUC = void 0;
+const MakeSpinnerDialogUC_1 = require("../UCs/MakeSpinnerDialogUC");
+class MockMakeSpinnerDialogUC extends MakeSpinnerDialogUC_1.MakeSpinnerDialogUC {
+    constructor(appObject) {
+        super(appObject, MakeSpinnerDialogUC_1.MakeSpinnerDialogUC.type);
+        this.make = jest.fn();
+        this.factory = jest.fn();
+    }
+}
+exports.MockMakeSpinnerDialogUC = MockMakeSpinnerDialogUC;
+function makeMockMakeSpinnerDialogUC(appObjects) {
+    return new MockMakeSpinnerDialogUC(appObjects.getOrCreate("MockMakeSpinnerDialogUC"));
+}
+exports.makeMockMakeSpinnerDialogUC = makeMockMakeSpinnerDialogUC;

package/lib/Components/Dialog/Mocks/MockMarkDownEditorDialogPM.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="jest" />
+import { HostAppObject } from "../../../HostAppObject";
+import { MarkDownEditorDialogPM } from "../PMs";
+export declare class MockMarkDownEditorDialogPM extends MarkDownEditorDialogPM {
+    vmsAreEqual: jest.Mock<any, any>;
+    constructor(appObject: HostAppObject);
+}

package/lib/Components/Dialog/Mocks/MockMarkDownEditorDialogPM.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockMarkDownEditorDialogPM = void 0;
+const PMs_1 = require("../PMs");
+class MockMarkDownEditorDialogPM extends PMs_1.MarkDownEditorDialogPM {
+    constructor(appObject) {
+        super(appObject, PMs_1.MarkDownEditorDialogPM.type);
+        this.vmsAreEqual = jest.fn();
+    }
+}
+exports.MockMarkDownEditorDialogPM = MockMarkDownEditorDialogPM;

package/lib/Components/Dialog/Mocks/MockSpinnerDialogPM.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="jest" />
+import { HostAppObject } from "../../../HostAppObject";
+import { SpinnerDialogPM } from "../PMs";
+export declare class MockSpinnerDialogPM extends SpinnerDialogPM {
+    vmsAreEqual: jest.Mock<any, any>;
+    constructor(appObject: HostAppObject);
+}

package/lib/Components/Dialog/Mocks/MockSpinnerDialogPM.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockSpinnerDialogPM = void 0;
+const PMs_1 = require("../PMs");
+class MockSpinnerDialogPM extends PMs_1.SpinnerDialogPM {
+    constructor(appObject) {
+        super(appObject, PMs_1.SpinnerDialogPM.type);
+        this.vmsAreEqual = jest.fn();
+    }
+}
+exports.MockSpinnerDialogPM = MockSpinnerDialogPM;

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

@@ -0,0 +1,10 @@
+export * from "./MockAlertDialogPM";
+export * from "./MockConfirmDialogPM";
+export * from "./MockDialogQueuePM";
+export * from "./MockMakeAlertDialogUC";
+export * from "./MockMakeConfirmDialogUC";
+export * from "./MockMakeMarkdownDialogUC";
+export * from "./MockMakeSelectModelDialogUC";
+export * from "./MockMakeSpinnerDialogUC";
+export * from "./MockMarkDownEditorDialogPM";
+export * from "./MockSpinnerDialogPM";

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

@@ -0,0 +1,22 @@
+"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("./MockAlertDialogPM"), exports);
+__exportStar(require("./MockConfirmDialogPM"), exports);
+__exportStar(require("./MockDialogQueuePM"), exports);
+__exportStar(require("./MockMakeAlertDialogUC"), exports);
+__exportStar(require("./MockMakeConfirmDialogUC"), exports);
+__exportStar(require("./MockMakeMarkdownDialogUC"), exports);
+__exportStar(require("./MockMakeSelectModelDialogUC"), exports);
+__exportStar(require("./MockMakeSpinnerDialogUC"), exports);
+__exportStar(require("./MockMarkDownEditorDialogPM"), exports);
+__exportStar(require("./MockSpinnerDialogPM"), exports);

package/lib/Components/Dialog/PMs/AlertDialogPM.d.ts

@@ -1,16 +1,13 @@
-import { HostAppObject, HostAppObjectPM, HostAppObjectRepo } from '../../../HostAppObject';
+import { HostAppObject, HostAppObjectPM, HostAppObjectRepo } from "../../../HostAppObject";
 export interface AlertDialogVM {
     message: string;
     title: string;
     buttonLabel: string;
     close: () => void;
 }
-export declare class AlertDialogPM extends HostAppObjectPM<AlertDialogVM> {
+export declare const defaultAlertDialogVM: AlertDialogVM;
+export declare abstract class AlertDialogPM extends HostAppObjectPM<AlertDialogVM> {
     static type: string;
-    static get(assetID: string, appObjects: HostAppObjectRepo): AlertDialogPM | undefined;
-    private alert?;
-    vmsAreEqual(a: AlertDialogVM, b: AlertDialogVM): boolean;
-    onAlertChange: () => void;
-    constructor(appObject: HostAppObject);
+    static get(id: string, appObjects: HostAppObjectRepo): AlertDialogPM | undefined;
 }
-export declare const defaultAlertDialogVM: AlertDialogVM;
+export declare function makeAlertDialogPM(appObject: HostAppObject): AlertDialogPM;

package/lib/Components/Dialog/PMs/AlertDialogPM.js

@@ -1,9 +1,38 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.defaultAlertDialogVM = exports.AlertDialogPM = void 0;
+exports.makeAlertDialogPM = exports.AlertDialogPM = exports.defaultAlertDialogVM = void 0;
 const HostAppObject_1 = require("../../../HostAppObject");
 const Entities_1 = require("../Entities");
+exports.defaultAlertDialogVM = {
+    message: "",
+    buttonLabel: "",
+    close: () => {
+        // empty
+    },
+    title: ""
+};
 class AlertDialogPM extends HostAppObject_1.HostAppObjectPM {
+    static get(id, appObjects) {
+        const appObject = appObjects.get(id);
+        if (!appObject) {
+            appObjects.submitWarning("AlertDialogPM.get", "Unable to find app object");
+            return undefined;
+        }
+        const pm = appObject.getComponent(AlertDialogPM.type);
+        if (!pm) {
+            appObjects.submitWarning("AlertDialogPM.get", "App Object does not have AlertDialogPM");
+            return undefined;
+        }
+        return pm;
+    }
+}
+exports.AlertDialogPM = AlertDialogPM;
+AlertDialogPM.type = "AlertDialogPM";
+function makeAlertDialogPM(appObject) {
+    return new AlertDialogPMImp(appObject);
+}
+exports.makeAlertDialogPM = makeAlertDialogPM;
+class AlertDialogPMImp extends AlertDialogPM {
     constructor(appObject) {
         super(appObject, AlertDialogPM.type);
         this.onAlertChange = () => {
@@ -13,30 +42,17 @@ class AlertDialogPM extends HostAppObject_1.HostAppObjectPM {
                 buttonLabel: this.alert.buttonLabel,
                 close: this.alert.close,
                 message: this.alert.message,
-                title: this.alert.title,
+                title: this.alert.title
             });
         };
         this.alert = appObject.getComponent(Entities_1.AlertDialogEntity.type);
         if (!this.alert) {
-            this.error('PM added to an app object that does not have a DialogAlertEntity');
+            this.error("PM added to an app object that does not have a DialogAlertEntity");
             return;
         }
         this.alert.addChangeObserver(this.onAlertChange);
         this.onAlertChange();
     }
-    static get(assetID, appObjects) {
-        const appObject = appObjects.get(assetID);
-        if (!appObject) {
-            appObjects.submitWarning('AlertDialogPM.get', 'Unable to find app object');
-            return undefined;
-        }
-        const pm = appObject.getComponent(AlertDialogPM.type);
-        if (!pm) {
-            appObjects.submitWarning('AlertDialogPM.get', 'App Object does not have AlertDialogPM');
-            return undefined;
-        }
-        return pm;
-    }
     vmsAreEqual(a, b) {
         if (a.message !== b.message)
             return false;
@@ -47,13 +63,3 @@ class AlertDialogPM extends HostAppObject_1.HostAppObjectPM {
         return true;
     }
 }
-exports.AlertDialogPM = AlertDialogPM;
-AlertDialogPM.type = 'AlertDialogPM';
-exports.defaultAlertDialogVM = {
-    message: "Generic alert message",
-    title: "Alert",
-    buttonLabel: "Close",
-    close: () => {
-        console.warn('[AlertDialogVM.close] default VM');
-    }
-};

package/lib/Components/Dialog/PMs/ConfirmDialogPM.d.ts

@@ -1,4 +1,4 @@
-import { HostAppObject, HostAppObjectPM, HostAppObjectRepo } from '../../../HostAppObject';
+import { HostAppObject, HostAppObjectPM, HostAppObjectRepo } from "../../../HostAppObject";
 export interface ConfirmDialogVM {
     message: string;
     title: string;
@@ -7,12 +7,9 @@ export interface ConfirmDialogVM {
     cancel: () => void;
     confirm: () => void;
 }
-export declare class ConfirmDialogPM extends HostAppObjectPM<ConfirmDialogVM> {
+export declare abstract class ConfirmDialogPM extends HostAppObjectPM<ConfirmDialogVM> {
     static type: string;
-    static get(assetID: string, appObjects: HostAppObjectRepo): ConfirmDialogPM | undefined;
-    private dialog?;
-    vmsAreEqual(a: ConfirmDialogVM, b: ConfirmDialogVM): boolean;
-    onAlertChange: () => void;
-    constructor(appObject: HostAppObject);
+    static get(id: string, appObjects: HostAppObjectRepo): ConfirmDialogPM | undefined;
 }
+export declare function makeConfirmDialogPM(appObject: HostAppObject): ConfirmDialogPM;
 export declare const defaultConfirmDialogVM: ConfirmDialogVM;

package/lib/Components/Dialog/PMs/ConfirmDialogPM.js

@@ -1,9 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.defaultConfirmDialogVM = exports.ConfirmDialogPM = void 0;
+exports.defaultConfirmDialogVM = exports.makeConfirmDialogPM = exports.ConfirmDialogPM = void 0;
 const HostAppObject_1 = require("../../../HostAppObject");
 const Entities_1 = require("../Entities");
 class ConfirmDialogPM extends HostAppObject_1.HostAppObjectPM {
+    static get(id, appObjects) {
+        const appObject = appObjects.get(id);
+        if (!appObject) {
+            appObjects.submitWarning("ConfirmDialogPM.get", "Unable to find app object");
+            return undefined;
+        }
+        const pm = appObject.getComponent(ConfirmDialogPM.type);
+        if (!pm) {
+            appObjects.submitWarning("ConfirmDialogPM.get", "App Object does not have ConfirmDialogPM");
+            return undefined;
+        }
+        return pm;
+    }
+}
+exports.ConfirmDialogPM = ConfirmDialogPM;
+ConfirmDialogPM.type = "ConfirmDialogPM";
+function makeConfirmDialogPM(appObject) {
+    return new ConfirmDialogPMImp(appObject);
+}
+exports.makeConfirmDialogPM = makeConfirmDialogPM;
+class ConfirmDialogPMImp extends ConfirmDialogPM {
     constructor(appObject) {
         super(appObject, ConfirmDialogPM.type);
         this.onAlertChange = () => {
@@ -15,30 +36,17 @@ class ConfirmDialogPM extends HostAppObject_1.HostAppObjectPM {
                 cancel: this.dialog.cancel,
                 message: this.dialog.message,
                 title: this.dialog.title,
-                confirm: this.dialog.confirm,
+                confirm: this.dialog.confirm
             });
         };
         this.dialog = appObject.getComponent(Entities_1.ConfirmDialogEntity.type);
         if (!this.dialog) {
-            this.error('PM added to an app object that does not have a DialogConfirmEntity');
+            this.error("PM added to an app object that does not have a DialogConfirmEntity");
             return;
         }
         this.dialog.addChangeObserver(this.onAlertChange);
         this.onAlertChange();
     }
-    static get(assetID, appObjects) {
-        const appObject = appObjects.get(assetID);
-        if (!appObject) {
-            appObjects.submitWarning('ConfirmDialogPM.get', 'Unable to find app object');
-            return undefined;
-        }
-        const pm = appObject.getComponent(ConfirmDialogPM.type);
-        if (!pm) {
-            appObjects.submitWarning('ConfirmDialogPM.get', 'App Object does not have ConfirmDialogPM');
-            return undefined;
-        }
-        return pm;
-    }
     vmsAreEqual(a, b) {
         if (a.message !== b.message)
             return false;
@@ -51,17 +59,15 @@ class ConfirmDialogPM extends HostAppObject_1.HostAppObjectPM {
         return true;
     }
 }
-exports.ConfirmDialogPM = ConfirmDialogPM;
-ConfirmDialogPM.type = 'ConfirmDialogPM';
 exports.defaultConfirmDialogVM = {
-    message: 'Generic confirm message',
-    title: 'Confirm',
+    message: "Generic confirm message",
+    title: "Confirm",
     cancel: () => {
-        console.warn('[ConfirmDialogVM.cancel] default VM');
+        console.warn("[ConfirmDialogVM.cancel] default VM");
     },
-    cancelButtonLabel: '',
+    cancelButtonLabel: "",
     confirm: () => {
-        console.warn('[ConfirmDialogVM.confirm] default VM');
+        console.warn("[ConfirmDialogVM.confirm] default VM");
     },
-    confirmButtonLabel: '',
+    confirmButtonLabel: ""
 };

package/lib/Components/Dialog/PMs/DialogQueuePM.d.ts

@@ -1,16 +1,13 @@
-import { HostAppObject, HostAppObjectPM, HostAppObjectRepo } from '../../../HostAppObject';
-export interface DialogVM {
+import { HostAppObject, HostAppObjectPM, HostAppObjectRepo } from "../../../HostAppObject";
+export interface DialogQueueVM {
     open: boolean;
     id?: string;
     dialogType?: string;
     preventOutsideDismiss?: boolean;
 }
-export declare class DialogQueuePM extends HostAppObjectPM<DialogVM> {
+export declare abstract class DialogQueuePM extends HostAppObjectPM<DialogQueueVM> {
     static type: string;
     static get(appObjects: HostAppObjectRepo): DialogQueuePM | undefined;
-    private queue?;
-    vmsAreEqual(a: DialogVM, b: DialogVM): boolean;
-    onQueueChange: () => void;
-    constructor(appObject: HostAppObject);
 }
-export declare const defualtDialogVM: DialogVM;
+export declare function makeDialogQueuePM(appObject: HostAppObject): DialogQueuePM;
+export declare const defaultDialogVM: DialogQueueVM;

package/lib/Components/Dialog/PMs/DialogQueuePM.js

@@ -1,9 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.defualtDialogVM = exports.DialogQueuePM = void 0;
+exports.defaultDialogVM = exports.makeDialogQueuePM = exports.DialogQueuePM = void 0;
 const HostAppObject_1 = require("../../../HostAppObject");
 const Entities_1 = require("../Entities");
 class DialogQueuePM extends HostAppObject_1.HostAppObjectPM {
+    static get(appObjects) {
+        return HostAppObject_1.getSingletonComponent(DialogQueuePM.type, appObjects);
+    }
+}
+exports.DialogQueuePM = DialogQueuePM;
+DialogQueuePM.type = "DialogQueuePM";
+function makeDialogQueuePM(appObject) {
+    return new DialogQueuePMImp(appObject);
+}
+exports.makeDialogQueuePM = makeDialogQueuePM;
+class DialogQueuePMImp extends DialogQueuePM {
     constructor(appObject) {
         super(appObject, DialogQueuePM.type);
         this.onQueueChange = () => {
@@ -16,23 +27,20 @@ class DialogQueuePM extends HostAppObject_1.HostAppObjectPM {
                     open: currentDialog.isOpen,
                     dialogType: currentDialog.dialogType,
                     preventOutsideDismiss: currentDialog.preventOutsideDismiss,
-                    id: currentDialog.appObject.id,
+                    id: currentDialog.appObject.id
                 };
             }
             this.doUpdateView(vm);
         };
         this.queue = appObject.getComponent(Entities_1.DialogQueue.type);
         if (!this.queue) {
-            this.error('PM added to an app object that does not have a DialogQueue');
+            this.error("PM added to an app object that does not have a DialogQueue");
             return;
         }
         this.queue.addChangeObserver(this.onQueueChange);
         this.onQueueChange();
         this.appObjects.registerSingleton(this);
     }
-    static get(appObjects) {
-        return HostAppObject_1.getSingletonComponent(DialogQueuePM.type, appObjects);
-    }
     vmsAreEqual(a, b) {
         if (a.open !== b.open)
             return false;
@@ -45,8 +53,6 @@ class DialogQueuePM extends HostAppObject_1.HostAppObjectPM {
         return true;
     }
 }
-exports.DialogQueuePM = DialogQueuePM;
-DialogQueuePM.type = 'DialogQueuePM';
-exports.defualtDialogVM = {
-    open: false,
+exports.defaultDialogVM = {
+    open: false
 };

package/lib/Components/Dialog/PMs/MarkDownEditorDialogPM.d.ts

@@ -1,14 +1,11 @@
-import { HostAppObject, HostAppObjectPM, HostAppObjectRepo } from '../../../HostAppObject';
+import { HostAppObject, HostAppObjectPM, HostAppObjectRepo } from "../../../HostAppObject";
 export interface MarkDownEditorDialogVM {
     initialText: string;
     confirm: (text: string) => void;
 }
-export declare class MarkDownEditorDialogPM extends HostAppObjectPM<MarkDownEditorDialogVM> {
+export declare abstract class MarkDownEditorDialogPM extends HostAppObjectPM<MarkDownEditorDialogVM> {
     static type: string;
     static get(assetID: string, appObjects: HostAppObjectRepo): MarkDownEditorDialogPM | undefined;
-    private dialog?;
-    vmsAreEqual(a: MarkDownEditorDialogVM, b: MarkDownEditorDialogVM): boolean;
-    onAlertChange: () => void;
-    constructor(appObject: HostAppObject);
 }
+export declare function makeMarkDownEditorDialogPM(appObject: HostAppObject): MarkDownEditorDialogPM;
 export declare const defaultMarkDownEditorDialogVM: MarkDownEditorDialogVM;

package/lib/Components/Dialog/PMs/MarkDownEditorDialogPM.js

@@ -1,9 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.defaultMarkDownEditorDialogVM = exports.MarkDownEditorDialogPM = void 0;
+exports.defaultMarkDownEditorDialogVM = exports.makeMarkDownEditorDialogPM = exports.MarkDownEditorDialogPM = void 0;
 const HostAppObject_1 = require("../../../HostAppObject");
 const MarkDownEditor_1 = require("../Entities/MarkDownEditor");
 class MarkDownEditorDialogPM extends HostAppObject_1.HostAppObjectPM {
+    static get(assetID, appObjects) {
+        const appObject = appObjects.get(assetID);
+        if (!appObject) {
+            appObjects.submitWarning("MarkDownEditorDialogPM.get", "Unable to find app object");
+            return undefined;
+        }
+        const pm = appObject.getComponent(MarkDownEditorDialogPM.type);
+        if (!pm) {
+            appObjects.submitWarning("MarkDownEditorDialogPM.get", "App Object does not have MarkDownEditorDialogPM");
+            return undefined;
+        }
+        return pm;
+    }
+}
+exports.MarkDownEditorDialogPM = MarkDownEditorDialogPM;
+MarkDownEditorDialogPM.type = "MarkDownEditorDialogPM";
+function makeMarkDownEditorDialogPM(appObject) {
+    return new MarkDownEditorDialogPMImp(appObject);
+}
+exports.makeMarkDownEditorDialogPM = makeMarkDownEditorDialogPM;
+class MarkDownEditorDialogPMImp extends MarkDownEditorDialogPM {
     constructor(appObject) {
         super(appObject, MarkDownEditorDialogPM.type);
         this.onAlertChange = () => {
@@ -11,41 +32,26 @@ class MarkDownEditorDialogPM extends HostAppObject_1.HostAppObjectPM {
                 return;
             this.doUpdateView({
                 initialText: this.dialog.initialText,
-                confirm: this.dialog.confirm,
+                confirm: this.dialog.confirm
             });
         };
         this.dialog = appObject.getComponent(MarkDownEditor_1.MarkDownEditorDialogEntity.type);
         if (!this.dialog) {
-            this.error('PM added to an app object that does not have a DialogMarkDownEntity');
+            this.error("PM added to an app object that does not have a DialogMarkDownEntity");
             return;
         }
         this.dialog.addChangeObserver(this.onAlertChange);
         this.onAlertChange();
     }
-    static get(assetID, appObjects) {
-        const appObject = appObjects.get(assetID);
-        if (!appObject) {
-            appObjects.submitWarning('MarkDownEditorDialogPM.get', 'Unable to find app object');
-            return undefined;
-        }
-        const pm = appObject.getComponent(MarkDownEditorDialogPM.type);
-        if (!pm) {
-            appObjects.submitWarning('MarkDownEditorDialogPM.get', 'App Object does not have MarkDownEditorDialogPM');
-            return undefined;
-        }
-        return pm;
-    }
     vmsAreEqual(a, b) {
         if (a.initialText !== b.initialText)
             return false;
         return true;
     }
 }
-exports.MarkDownEditorDialogPM = MarkDownEditorDialogPM;
-MarkDownEditorDialogPM.type = 'MarkDownEditorDialogPM';
 exports.defaultMarkDownEditorDialogVM = {
-    initialText: '',
+    initialText: "",
     confirm: (text) => {
-        console.warn('[MarkDownEditorDialogVM.confirm] default VM!');
-    },
+        console.warn("[MarkDownEditorDialogVM.confirm] default VM!");
+    }
 };

package/lib/Components/Dialog/PMs/SpinnerDialogPM.d.ts

@@ -1,14 +1,11 @@
-import { HostAppObject, HostAppObjectPM, HostAppObjectRepo } from '../../../HostAppObject';
+import { HostAppObject, HostAppObjectPM, HostAppObjectRepo } from "../../../HostAppObject";
 export interface SpinnerDialogVM {
     message: string;
     title: string;
 }
-export declare class SpinnerDialogPM extends HostAppObjectPM<SpinnerDialogVM> {
+export declare abstract class SpinnerDialogPM extends HostAppObjectPM<SpinnerDialogVM> {
     static type: string;
     static get(assetID: string, appObjects: HostAppObjectRepo): SpinnerDialogPM | undefined;
-    private dialog?;
-    vmsAreEqual(a: SpinnerDialogVM, b: SpinnerDialogVM): boolean;
-    onAlertChange: () => void;
-    constructor(appObject: HostAppObject);
 }
+export declare function makeSpinnerDialogPM(appObject: HostAppObject): SpinnerDialogPM;
 export declare const defaultSpinnerDialogVM: SpinnerDialogVM;

package/lib/Components/Dialog/PMs/SpinnerDialogPM.js

@@ -1,9 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.defaultSpinnerDialogVM = exports.SpinnerDialogPM = void 0;
+exports.defaultSpinnerDialogVM = exports.makeSpinnerDialogPM = exports.SpinnerDialogPM = void 0;
 const HostAppObject_1 = require("../../../HostAppObject");
 const Entities_1 = require("../Entities");
 class SpinnerDialogPM extends HostAppObject_1.HostAppObjectPM {
+    static get(assetID, appObjects) {
+        const appObject = appObjects.get(assetID);
+        if (!appObject) {
+            appObjects.submitWarning("SpinnerDialogPM.get", "Unable to find app object");
+            return undefined;
+        }
+        const pm = appObject.getComponent(SpinnerDialogPM.type);
+        if (!pm) {
+            appObjects.submitWarning("SpinnerDialogPM.get", "App Object does not have SpinnerDialogPM");
+            return undefined;
+        }
+        return pm;
+    }
+}
+exports.SpinnerDialogPM = SpinnerDialogPM;
+SpinnerDialogPM.type = "SpinnerDialogPM";
+function makeSpinnerDialogPM(appObject) {
+    return new SpinnerDialogPMImp(appObject);
+}
+exports.makeSpinnerDialogPM = makeSpinnerDialogPM;
+class SpinnerDialogPMImp extends SpinnerDialogPM {
     constructor(appObject) {
         super(appObject, SpinnerDialogPM.type);
         this.onAlertChange = () => {
@@ -11,30 +32,17 @@ class SpinnerDialogPM extends HostAppObject_1.HostAppObjectPM {
                 return;
             this.doUpdateView({
                 message: this.dialog.message,
-                title: this.dialog.title,
+                title: this.dialog.title
             });
         };
         this.dialog = appObject.getComponent(Entities_1.SpinnerDialogEntity.type);
         if (!this.dialog) {
-            this.error('PM added to an app object that does not have a DialogSpinnerEntity');
+            this.error("PM added to an app object that does not have a DialogSpinnerEntity");
             return;
         }
         this.dialog.addChangeObserver(this.onAlertChange);
         this.onAlertChange();
     }
-    static get(assetID, appObjects) {
-        const appObject = appObjects.get(assetID);
-        if (!appObject) {
-            appObjects.submitWarning('SpinnerDialogPM.get', 'Unable to find app object');
-            return undefined;
-        }
-        const pm = appObject.getComponent(SpinnerDialogPM.type);
-        if (!pm) {
-            appObjects.submitWarning('SpinnerDialogPM.get', 'App Object does not have SpinnerDialogPM');
-            return undefined;
-        }
-        return pm;
-    }
     vmsAreEqual(a, b) {
         if (a.message !== b.message)
             return false;
@@ -43,9 +51,7 @@ class SpinnerDialogPM extends HostAppObject_1.HostAppObjectPM {
         return true;
     }
 }
-exports.SpinnerDialogPM = SpinnerDialogPM;
-SpinnerDialogPM.type = 'SpinnerDialogPM';
 exports.defaultSpinnerDialogVM = {
-    message: 'Default spinner message',
-    title: 'Spinner',
+    message: "Default spinner message",
+    title: "Spinner"
 };

package/lib/Components/Dialog/UCs/MakeAlertDialogUC.d.ts

@@ -0,0 +1,10 @@
+import { HostAppObject, HostAppObjectRepo, HostAppObjectUC } from "../../../HostAppObject";
+import { DialogAlertDTO, AlertDialogEntity } from "../Entities";
+export declare abstract class MakeAlertDialogUC extends HostAppObjectUC {
+    static type: string;
+    abstract make(dto: DialogAlertDTO): void;
+    abstract factory(data: DialogAlertDTO): AlertDialogEntity;
+    static get(appObjects: HostAppObjectRepo): MakeAlertDialogUC | undefined;
+    static make(dto: DialogAlertDTO, appObjects: HostAppObjectRepo): void;
+}
+export declare function makeMakeAlertDialogUC(appObject: HostAppObject): MakeAlertDialogUC;