@vived/host 3.1.0 → 3.3.0

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;

package/lib/Components/Dialog/UCs/MakeAlertDialogUC.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMakeAlertDialogUC = exports.MakeAlertDialogUC = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+const Utilities_1 = require("../../../Utilities");
+const Entities_1 = require("../Entities");
+class MakeAlertDialogUC extends HostAppObject_1.HostAppObjectUC {
+    static get(appObjects) {
+        return HostAppObject_1.getSingletonComponent(MakeAlertDialogUC.type, appObjects);
+    }
+    static make(dto, appObjects) {
+        const uc = MakeAlertDialogUC.get(appObjects);
+        uc === null || uc === void 0 ? void 0 : uc.make(dto);
+    }
+}
+exports.MakeAlertDialogUC = MakeAlertDialogUC;
+MakeAlertDialogUC.type = "MakeAlertDialogUC";
+function makeMakeAlertDialogUC(appObject) {
+    return new MakeActivityDetailsDialogUCImp(appObject);
+}
+exports.makeMakeAlertDialogUC = makeMakeAlertDialogUC;
+class MakeActivityDetailsDialogUCImp extends MakeAlertDialogUC {
+    get dialogRepo() {
+        return this.getCachedSingleton(Entities_1.DialogQueue.type);
+    }
+    factory(data) {
+        const ao = this.appObjects.getOrCreate(Utilities_1.generateUniqueID());
+        const entity = new Entities_1.AlertDialogEntity(data, ao);
+        return entity;
+    }
+    make(dto) {
+        if (!this.dialogRepo)
+            return;
+        const dialog = this.factory(dto);
+        this.dialogRepo.submitDialog(dialog);
+    }
+    constructor(appObject) {
+        super(appObject, MakeAlertDialogUC.type);
+        this.appObjects.registerSingleton(this);
+    }
+}

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

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

package/lib/Components/Dialog/UCs/MakeConfirmDialogUC.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMakeConfirmDialogUC = exports.MakeConfirmDialogUC = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+const Utilities_1 = require("../../../Utilities");
+const Entities_1 = require("../Entities");
+class MakeConfirmDialogUC extends HostAppObject_1.HostAppObjectUC {
+    static get(appObjects) {
+        return HostAppObject_1.getSingletonComponent(MakeConfirmDialogUC.type, appObjects);
+    }
+    static make(dto, appObjects) {
+        const uc = MakeConfirmDialogUC.get(appObjects);
+        uc === null || uc === void 0 ? void 0 : uc.make(dto);
+    }
+}
+exports.MakeConfirmDialogUC = MakeConfirmDialogUC;
+MakeConfirmDialogUC.type = "MakeConfirmDialogUC";
+function makeMakeConfirmDialogUC(appObject) {
+    return new MakeConfirmDialogUCImp(appObject);
+}
+exports.makeMakeConfirmDialogUC = makeMakeConfirmDialogUC;
+class MakeConfirmDialogUCImp extends MakeConfirmDialogUC {
+    get dialogRepo() {
+        return this.getCachedSingleton(Entities_1.DialogQueue.type);
+    }
+    factory(data) {
+        const ao = this.appObjects.getOrCreate(Utilities_1.generateUniqueID());
+        const entity = new Entities_1.ConfirmDialogEntity(data, ao);
+        return entity;
+    }
+    make(dto) {
+        if (!this.dialogRepo)
+            return;
+        const dialog = this.factory(dto);
+        this.dialogRepo.submitDialog(dialog);
+    }
+    constructor(appObject) {
+        super(appObject, MakeConfirmDialogUC.type);
+        this.appObjects.registerSingleton(this);
+    }
+}

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

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

package/lib/Components/Dialog/UCs/MakeMarkdownDialogUC.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMakeMarkdownDialogUC = exports.MakeMarkdownDialogUC = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+const Utilities_1 = require("../../../Utilities");
+const Entities_1 = require("../Entities");
+class MakeMarkdownDialogUC extends HostAppObject_1.HostAppObjectUC {
+    static get(appObjects) {
+        return HostAppObject_1.getSingletonComponent(MakeMarkdownDialogUC.type, appObjects);
+    }
+    static make(dto, appObjects) {
+        const uc = MakeMarkdownDialogUC.get(appObjects);
+        uc === null || uc === void 0 ? void 0 : uc.make(dto);
+    }
+}
+exports.MakeMarkdownDialogUC = MakeMarkdownDialogUC;
+MakeMarkdownDialogUC.type = "MakeMarkdownDialogUC";
+function makeMakeMarkdownDialogUC(appObject) {
+    return new MakeMarkdownDialogUCImp(appObject);
+}
+exports.makeMakeMarkdownDialogUC = makeMakeMarkdownDialogUC;
+class MakeMarkdownDialogUCImp extends MakeMarkdownDialogUC {
+    get dialogRepo() {
+        return this.getCachedSingleton(Entities_1.DialogQueue.type);
+    }
+    factory(data) {
+        const ao = this.appObjects.getOrCreate(Utilities_1.generateUniqueID());
+        const entity = new Entities_1.MarkDownEditorDialogEntity(data, ao);
+        return entity;
+    }
+    make(dto) {
+        if (!this.dialogRepo)
+            return;
+        const dialog = this.factory(dto);
+        this.dialogRepo.submitDialog(dialog);
+    }
+    constructor(appObject) {
+        super(appObject, MakeMarkdownDialogUC.type);
+        this.appObjects.registerSingleton(this);
+    }
+}

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

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

package/lib/Components/Dialog/UCs/MakeSelectModelDialogUC.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMakeSelectModelDialogUC = exports.MakeSelectModelDialogUC = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+const Utilities_1 = require("../../../Utilities");
+const Entities_1 = require("../Entities");
+class MakeSelectModelDialogUC extends HostAppObject_1.HostAppObjectUC {
+    static get(appObjects) {
+        return HostAppObject_1.getSingletonComponent(MakeSelectModelDialogUC.type, appObjects);
+    }
+    static make(appObjects) {
+        const uc = MakeSelectModelDialogUC.get(appObjects);
+        uc === null || uc === void 0 ? void 0 : uc.make();
+    }
+}
+exports.MakeSelectModelDialogUC = MakeSelectModelDialogUC;
+MakeSelectModelDialogUC.type = "MakeSelectModelDialogUC";
+function makeMakeSelectModelDialogUC(appObject) {
+    return new MakeSelectModelDialogUCImp(appObject);
+}
+exports.makeMakeSelectModelDialogUC = makeMakeSelectModelDialogUC;
+class MakeSelectModelDialogUCImp extends MakeSelectModelDialogUC {
+    get dialogRepo() {
+        return this.getCachedSingleton(Entities_1.DialogQueue.type);
+    }
+    factory() {
+        const ao = this.appObjects.getOrCreate(Utilities_1.generateUniqueID());
+        const entity = new Entities_1.SelectModelDialogEntity(ao);
+        return entity;
+    }
+    make() {
+        if (!this.dialogRepo)
+            return;
+        const dialog = this.factory();
+        this.dialogRepo.submitDialog(dialog);
+    }
+    constructor(appObject) {
+        super(appObject, MakeSelectModelDialogUC.type);
+        this.appObjects.registerSingleton(this);
+    }
+}

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

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

package/lib/Components/Dialog/UCs/MakeSpinnerDialogUC.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMakeSpinnerDialogUC = exports.MakeSpinnerDialogUC = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+const Utilities_1 = require("../../../Utilities");
+const Entities_1 = require("../Entities");
+class MakeSpinnerDialogUC extends HostAppObject_1.HostAppObjectUC {
+    static get(appObjects) {
+        return HostAppObject_1.getSingletonComponent(MakeSpinnerDialogUC.type, appObjects);
+    }
+    static make(dto, appObjects) {
+        const uc = MakeSpinnerDialogUC.get(appObjects);
+        return uc === null || uc === void 0 ? void 0 : uc.make(dto);
+    }
+}
+exports.MakeSpinnerDialogUC = MakeSpinnerDialogUC;
+MakeSpinnerDialogUC.type = "MakeSpinnerDialogUC";
+function makeMakeSpinnerDialogUC(appObject) {
+    return new MakeSpinnerDialogUCImp(appObject);
+}
+exports.makeMakeSpinnerDialogUC = makeMakeSpinnerDialogUC;
+class MakeSpinnerDialogUCImp extends MakeSpinnerDialogUC {
+    get dialogRepo() {
+        return this.getCachedSingleton(Entities_1.DialogQueue.type);
+    }
+    factory(data) {
+        const ao = this.appObjects.getOrCreate(Utilities_1.generateUniqueID());
+        const entity = new Entities_1.SpinnerDialogEntity(data, ao);
+        return entity;
+    }
+    make(dto) {
+        if (!this.dialogRepo)
+            return;
+        const dialog = this.factory(dto);
+        this.dialogRepo.submitDialog(dialog);
+        return dialog;
+    }
+    constructor(appObject) {
+        super(appObject, MakeSpinnerDialogUC.type);
+        this.appObjects.registerSingleton(this);
+    }
+}

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

@@ -0,0 +1,5 @@
+export * from "./MakeAlertDialogUC";
+export * from "./MakeConfirmDialogUC";
+export * from "./MakeMarkdownDialogUC";
+export * from "./MakeSelectModelDialogUC";
+export * from "./MakeSpinnerDialogUC";

package/lib/Components/Dialog/UCs/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("./MakeAlertDialogUC"), exports);
+__exportStar(require("./MakeConfirmDialogUC"), exports);
+__exportStar(require("./MakeMarkdownDialogUC"), exports);
+__exportStar(require("./MakeSelectModelDialogUC"), exports);
+__exportStar(require("./MakeSpinnerDialogUC"), exports);

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

@@ -1,4 +1,7 @@
+export * from "./Adapters";
 export * from "./Controllers";
-export * from './Entities';
-export * from './Factories';
-export * from './PMs';
+export * from "./Entities";
+export * from "./Factories";
+export * from "./Mocks";
+export * from "./PMs";
+export * from "./UCs";

package/lib/Components/Dialog/index.js

@@ -10,7 +10,10 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Adapters"), exports);
 __exportStar(require("./Controllers"), exports);
 __exportStar(require("./Entities"), exports);
 __exportStar(require("./Factories"), exports);
+__exportStar(require("./Mocks"), exports);
 __exportStar(require("./PMs"), exports);
+__exportStar(require("./UCs"), exports);

package/lib/Components/Dispatcher/Entities/HostDispatchEntity.js

@@ -55,7 +55,12 @@ class HostDispatchEntityImp extends HostDispatchEntity {
                 this.error("No app handler has been registered");
                 return;
             }
-            this.appHandler(request);
+            try {
+                this.appHandler(request);
+            }
+            catch (e) {
+                this.warn(e.message);
+            }
         };
         this.formRequestAndDispatch = (type, version, payload) => {
             if (!this.appHandler) {
@@ -67,7 +72,7 @@ class HostDispatchEntityImp extends HostDispatchEntity {
                 version,
                 payload
             };
-            this.appHandler(request);
+            this.dispatch(request);
         };
     }
     get appHandlerVersion() {

package/lib/Components/Dispatcher/UCs/DispatchStartBrowseChannelsUC.d.ts

@@ -7,7 +7,7 @@ export interface BrowseChannelDTO {
 }
 export declare abstract class DispatchStartBrowseChannelsUC extends HostAppObjectUC {
     static readonly type = "DispatchStartBrowseChannelsUC";
-    readonly requestType = "START_BROWSE_CHANNEL_MODELS";
+    readonly requestType = "START_SELECT_CHANNEL_MODEL";
     abstract doDispatch(dto: BrowseChannelDTO): void;
     static get(appObject: HostAppObject): DispatchStartBrowseChannelsUC | undefined;
     static getByID(id: string, appObjects: HostAppObjectRepo): DispatchStartBrowseChannelsUC | undefined;

package/lib/Components/Dispatcher/UCs/DispatchStartBrowseChannelsUC.js

@@ -6,7 +6,7 @@ const Entities_1 = require("../Entities");
 class DispatchStartBrowseChannelsUC extends HostAppObject_1.HostAppObjectUC {
     constructor() {
         super(...arguments);
-        this.requestType = "START_BROWSE_CHANNEL_MODELS";
+        this.requestType = "START_SELECT_CHANNEL_MODEL";
     }
     static get(appObject) {
         const asset = appObject.getComponent(DispatchStartBrowseChannelsUC.type);

package/lib/Components/Handler/UCs/CloseAssetSystemPlugin.d.ts

@@ -0,0 +1,17 @@
+import { HostAppObject, HostAppObjectUC } from "../../../HostAppObject";
+import { RequestHandler } from "../Entities";
+export declare abstract class CloseAssetSystemPluginUC extends HostAppObjectUC implements RequestHandler {
+    static readonly type = "CloseAssetSystemPluginUC";
+    readonly requestType = "CLOSE_PLUGIN";
+    readonly payloadVersion = 1;
+    abstract action: () => void;
+    abstract handleRequest: (version: number, payload?: unknown) => void;
+}
+export declare function makeCloseAssetSystemPluginUC(appObject: HostAppObject): CloseAssetSystemPluginUC;
+export declare class CloseAssetSystemPluginUCImp extends CloseAssetSystemPluginUC {
+    private get dialogQueue();
+    private get assetSystemPlugin();
+    handleRequest: (version: number) => void;
+    action: () => void;
+    constructor(appObject: HostAppObject);
+}

package/lib/Components/Handler/UCs/CloseAssetSystemPlugin.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CloseAssetSystemPluginUCImp = exports.makeCloseAssetSystemPluginUC = exports.CloseAssetSystemPluginUC = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+const AssetPlugin_1 = require("../../AssetPlugin");
+const Dialog_1 = require("../../Dialog");
+const Dispatcher_1 = require("../../Dispatcher");
+const Entities_1 = require("../Entities");
+class CloseAssetSystemPluginUC extends HostAppObject_1.HostAppObjectUC {
+    constructor() {
+        super(...arguments);
+        this.requestType = "CLOSE_PLUGIN";
+        this.payloadVersion = 1;
+    }
+}
+exports.CloseAssetSystemPluginUC = CloseAssetSystemPluginUC;
+CloseAssetSystemPluginUC.type = "CloseAssetSystemPluginUC";
+function makeCloseAssetSystemPluginUC(appObject) {
+    return new CloseAssetSystemPluginUCImp(appObject);
+}
+exports.makeCloseAssetSystemPluginUC = makeCloseAssetSystemPluginUC;
+class CloseAssetSystemPluginUCImp extends CloseAssetSystemPluginUC {
+    constructor(appObject) {
+        super(appObject, CloseAssetSystemPluginUC.type);
+        this.handleRequest = (version) => {
+            if (version === this.payloadVersion) {
+                this.action();
+            }
+            else {
+                throw new Entities_1.UnsupportedRequestVersion(this.requestType, version);
+            }
+        };
+        this.action = () => {
+            if (!this.assetSystemPlugin)
+                return;
+            if (!this.dialogQueue)
+                return;
+            this.dialogQueue.activeDialogHasClosed();
+            const dispatchDisposeApp = Dispatcher_1.DispatchDisposeAppUC.get(this.appObject);
+            if (!dispatchDisposeApp) {
+                this.error("Cannot find DispatchDisposeAppUC");
+                return;
+            }
+            const dispatchStopApp = Dispatcher_1.DispatchStopAppUC.get(this.appObject);
+            if (!dispatchStopApp) {
+                this.error("Cannot find DispatchDisposeAppUC");
+                return;
+            }
+            dispatchStopApp.doDispatch();
+            dispatchDisposeApp.doDispatch();
+            this.assetSystemPlugin.show = false;
+        };
+        const hostHandler = Entities_1.HostHandlerEntity.get(appObject);
+        if (!hostHandler) {
+            this.error("UC added to an entity that does not have HostHandlerEntity");
+            return;
+        }
+        hostHandler.registerRequestHandler(this);
+    }
+    get dialogQueue() {
+        return this.getCachedSingleton(Dialog_1.DialogQueue.type);
+    }
+    get assetSystemPlugin() {
+        return this.getCachedLocalComponent(AssetPlugin_1.AssetPluginEntity.type);
+    }
+}
+exports.CloseAssetSystemPluginUCImp = CloseAssetSystemPluginUCImp;

package/lib/Components/Handler/UCs/GetAssetFolderURLHandler.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeGetAssetFolderURLHandler = exports.GetAssetFolderURLHandler = void 0;
 const HostAppObject_1 = require("../../../HostAppObject");
+const Apps_1 = require("../../Apps");
 const Entities_1 = require("../Entities");
 class GetAssetFolderURLHandler extends HostAppObject_1.HostAppObjectUC {
     constructor() {
@@ -18,8 +19,14 @@ exports.makeGetAssetFolderURLHandler = makeGetAssetFolderURLHandler;
 class GetAssetFolderURLHandlerImp extends GetAssetFolderURLHandler {
     constructor(appObject) {
         super(appObject, GetAssetFolderURLHandler.type);
-        this.action = () => {
-            this.warn("Action has not been setup");
+        this.action = (callback) => {
+            var _a;
+            if (!this.app) {
+                this.error("No AppEntity");
+                callback("");
+                return;
+            }
+            callback((_a = this.app.appAssetFolderURL) !== null && _a !== void 0 ? _a : "");
         };
         this.handleRequest = (version, payload) => {
             if (version === 1) {
@@ -37,6 +44,9 @@ class GetAssetFolderURLHandlerImp extends GetAssetFolderURLHandler {
         }
         hostHandler.registerRequestHandler(this);
     }
+    get app() {
+        return this.getCachedLocalComponent(Apps_1.AppEntity.type);
+    }
     castPayloadV1(payload) {
         const castPayload = payload;
         if (!castPayload.callback) {