@vived/host 3.2.0 → 3.4.0

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/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/ShowAlertHandler.js

@@ -20,17 +20,13 @@ class ShowAlertHandlerImp extends ShowAlertHandler {
     constructor(appObject) {
         super(appObject, ShowAlertHandler.type);
         this.action = (actionDTO) => {
-            var _a, _b;
             const { closeButtonLabel, closeCallback, message, title } = actionDTO;
-            const dialogDTO = {
+            Dialog_1.MakeAlertDialogUC.make({
                 buttonLabel: closeButtonLabel,
                 message,
                 title,
                 onClose: closeCallback
-            };
-            const alertDialog = (_a = this.dialogQueue) === null || _a === void 0 ? void 0 : _a.alertDialogFactory(dialogDTO);
-            if (alertDialog)
-                (_b = this.dialogQueue) === null || _b === void 0 ? void 0 : _b.submitDialog(alertDialog);
+            }, this.appObjects);
         };
         this.handleRequest = (version, payload) => {
             if (version === 1) {
@@ -48,9 +44,6 @@ class ShowAlertHandlerImp extends ShowAlertHandler {
         }
         hostHandler.registerRequestHandler(this);
     }
-    get dialogQueue() {
-        return this.getCachedSingleton(Dialog_1.DialogQueue.type);
-    }
     castPayloadV1(payload) {
         const castPayload = payload;
         if (castPayload.title === undefined ||

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

@@ -20,19 +20,15 @@ class ShowConfirmHandlerImp extends ShowConfirmHandler {
     constructor(appObject) {
         super(appObject, ShowConfirmHandler.type);
         this.action = (actionDTO) => {
-            var _a, _b;
             const { cancelButtonLabel, cancelCallback, confirmButtonLabel, confirmCallback, message, title } = actionDTO;
-            const dialogDTO = {
+            Dialog_1.MakeConfirmDialogUC.make({
                 cancelButtonLabel,
                 confirmButtonLabel,
                 message,
                 title,
                 onCancel: cancelCallback,
                 onConfirm: confirmCallback
-            };
-            const confirmDialog = (_a = this.dialogQueue) === null || _a === void 0 ? void 0 : _a.confirmDialogFactory(dialogDTO);
-            if (confirmDialog)
-                (_b = this.dialogQueue) === null || _b === void 0 ? void 0 : _b.submitDialog(confirmDialog);
+            }, this.appObjects);
         };
         this.handleRequest = (version, payload) => {
             if (version === 1) {
@@ -50,9 +46,6 @@ class ShowConfirmHandlerImp extends ShowConfirmHandler {
         }
         hostHandler.registerRequestHandler(this);
     }
-    get dialogQueue() {
-        return this.getCachedSingleton(Dialog_1.DialogQueue.type);
-    }
     castPayloadV1(payload) {
         const castPayload = payload;
         if (castPayload.title === undefined ||

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

@@ -14,7 +14,6 @@ export declare abstract class ShowMarkDownEditorHandler extends HostAppObjectUC
 }
 export declare function makeShowMarkDownEditorHandler(appObject: HostAppObject): ShowMarkDownEditorHandler;
 export declare class ShowMarkDownEditorHandlerImp extends ShowMarkDownEditorHandler {
-    private get dialogQueue();
     action: ShowMarkDownEditorAction;
     handleRequest: (version: number, payload: unknown) => void;
     private castPayloadV1;

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

@@ -20,15 +20,11 @@ class ShowMarkDownEditorHandlerImp extends ShowMarkDownEditorHandler {
     constructor(appObject) {
         super(appObject, ShowMarkDownEditorHandler.type);
         this.action = (actionDTO) => {
-            var _a, _b;
             const { initialText, submitCallback } = actionDTO;
-            const dialogDTO = {
+            Dialog_1.MakeMarkdownDialogUC.make({
                 initialText,
                 onConfirm: submitCallback
-            };
-            const dialog = (_a = this.dialogQueue) === null || _a === void 0 ? void 0 : _a.markDownDialogFactory(dialogDTO);
-            if (dialog)
-                (_b = this.dialogQueue) === null || _b === void 0 ? void 0 : _b.submitDialog(dialog);
+            }, this.appObjects);
         };
         this.handleRequest = (version, payload) => {
             if (version === 1) {
@@ -46,9 +42,6 @@ class ShowMarkDownEditorHandlerImp extends ShowMarkDownEditorHandler {
         }
         hostHandler.registerRequestHandler(this);
     }
-    get dialogQueue() {
-        return this.getCachedSingleton(Dialog_1.DialogQueue.type);
-    }
     castPayloadV1(payload) {
         const castPayload = payload;
         if (castPayload.initialText === undefined ||

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

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeShowSelectModelHandler = exports.ShowSelectModelHandler = void 0;
 const HostAppObject_1 = require("../../../HostAppObject");
+const AssetPlugin_1 = require("../../AssetPlugin");
+const Dialog_1 = require("../../Dialog");
 const Entities_1 = require("../Entities");
 class ShowSelectModelHandler extends HostAppObject_1.HostAppObjectUC {
     constructor() {
@@ -18,8 +20,12 @@ exports.makeShowSelectModelHandler = makeShowSelectModelHandler;
 class ShowSelectModelHandlerImp extends ShowSelectModelHandler {
     constructor(appObject) {
         super(appObject, ShowSelectModelHandler.type);
-        this.action = () => {
-            throw new Entities_1.ActionNotImplemented(this.requestType);
+        this.action = (callback) => {
+            if (!this.assetPlugin)
+                return;
+            this.assetPlugin.callback = callback;
+            this.assetPlugin.show = true;
+            Dialog_1.MakeSelectModelDialogUC.make(this.appObjects);
         };
         this.handleRequest = (version, payload) => {
             if (version === 1) {
@@ -37,6 +43,9 @@ class ShowSelectModelHandlerImp extends ShowSelectModelHandler {
         }
         hostHandler.registerRequestHandler(this);
     }
+    get assetPlugin() {
+        return this.getCachedSingleton(AssetPlugin_1.AssetPluginEntity.type);
+    }
     castPayloadV1(payload) {
         const castPayload = payload;
         if (castPayload.callback === undefined) {

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

@@ -20,19 +20,12 @@ class ShowSpinnerBase extends ShowSpinnerHandler {
     constructor(appObject) {
         super(appObject, ShowSpinnerHandler.type);
         this.action = (actionDTO) => {
-            if (!this.dialogQueue) {
-                return;
-            }
             const { title, message, closeCallback } = actionDTO;
-            const spinnerDialog = this.dialogQueue.spinnerDialogFactory({
+            const spinnerDialog = Dialog_1.MakeSpinnerDialogUC.make({
                 title,
                 message
-            });
-            if (!spinnerDialog) {
-                return;
-            }
-            this.dialogQueue.submitDialog(spinnerDialog);
-            closeCallback(spinnerDialog.close);
+            }, this.appObjects);
+            closeCallback(() => spinnerDialog === null || spinnerDialog === void 0 ? void 0 : spinnerDialog.close());
         };
         this.handleRequest = (version, payload) => {
             if (version === 1) {
@@ -50,9 +43,6 @@ class ShowSpinnerBase extends ShowSpinnerHandler {
         }
         hostHandler.registerRequestHandler(this);
     }
-    get dialogQueue() {
-        return this.getCachedSingleton(Dialog_1.DialogQueue.type);
-    }
     castPayloadV1(payload) {
         const castPayload = payload;
         if (castPayload.message === undefined ||

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeSubmitLogHandler = exports.SubmitLogHandler = void 0;
 const HostAppObject_1 = require("../../../HostAppObject");
+const Apps_1 = require("../../Apps");
 const Entities_1 = require("../Entities");
 class SubmitLogHandler extends HostAppObject_1.HostAppObjectUC {
     constructor() {
@@ -18,8 +19,27 @@ exports.makeSubmitLogHandler = makeSubmitLogHandler;
 class SubmitLogHandlerImp extends SubmitLogHandler {
     constructor(appObject) {
         super(appObject, SubmitLogHandler.type);
-        this.action = () => {
-            throw new Entities_1.ActionNotImplemented(this.requestType);
+        this.action = (sender, severity, message) => {
+            if (!this.app) {
+                return;
+            }
+            const prependedSender = `[${this.app.name}] ${sender}`;
+            if (severity === "LOG") {
+                this.appObjects.submitLog(prependedSender, message);
+            }
+            else if (severity === "WARNING") {
+                this.appObjects.submitWarning(prependedSender, message);
+            }
+            else if (severity === "ERROR") {
+                this.appObjects.submitError(prependedSender, message);
+            }
+            else if (severity === "FATAL") {
+                this.appObjects.submitFatal(prependedSender, message);
+            }
+            else {
+                this.appObjects.submitLog(prependedSender, message);
+                this.appObjects.submitWarning("Host Handler - Submit Log", `Received an unsupported log severity type of ${severity}`);
+            }
         };
         this.handleRequest = (version, payload) => {
             if (version === 1) {
@@ -37,6 +57,9 @@ class SubmitLogHandlerImp extends SubmitLogHandler {
         }
         hostHandler.registerRequestHandler(this);
     }
+    get app() {
+        return this.getCachedLocalComponent(Apps_1.AppEntity.type);
+    }
     castPayloadV1(payload) {
         const castPayload = payload;
         if (castPayload.sender === undefined ||

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

@@ -1,4 +1,5 @@
 export * from "./CallbackAssetDTO";
+export * from "./CloseAssetSystemPlugin";
 export * from "./GetAssetBlobURLHandler";
 export * from "./GetAssetFolderURLHandler";
 export * from "./GetAssetMetaHandler";

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

@@ -11,6 +11,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./CallbackAssetDTO"), exports);
+__exportStar(require("./CloseAssetSystemPlugin"), exports);
 __exportStar(require("./GetAssetBlobURLHandler"), exports);
 __exportStar(require("./GetAssetFolderURLHandler"), exports);
 __exportStar(require("./GetAssetMetaHandler"), exports);

package/lib/Components/Logger/Adapters/fatalErrorAdapter.d.ts

@@ -0,0 +1,3 @@
+import { SingletonPmAdapter } from "../../../Types";
+import { FatalErrorVM } from "../PMs";
+export declare const fatalErrorAdapter: SingletonPmAdapter<FatalErrorVM>;

package/lib/Components/Logger/Adapters/fatalErrorAdapter.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fatalErrorAdapter = void 0;
+const PMs_1 = require("../PMs");
+exports.fatalErrorAdapter = {
+    defaultVM: PMs_1.defaultFatalErrorVM,
+    subscribe: (appObjects, setVM) => {
+        const pm = PMs_1.FatalErrorPM.get(appObjects);
+        if (!pm) {
+            appObjects.submitError("appListPMAdapter", "Unable to find AppsListPM");
+            return;
+        }
+        pm.addView(setVM);
+    },
+    unsubscribe: (appObjects, setVM) => {
+        const pm = PMs_1.FatalErrorPM.get(appObjects);
+        if (!pm) {
+            appObjects.submitError("appListPMAdapter", "Unable to find AppsListPM");
+            return;
+        }
+        pm.removeView(setVM);
+    }
+};