@vived/host 3.0.0

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

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeOnStateCompleteHandler = exports.OnStateCompleteHandler = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+const Entities_1 = require("../Entities");
+class OnStateCompleteHandler extends HostAppObject_1.HostAppObjectUC {
+    constructor() {
+        super(...arguments);
+        this.requestType = "ON_STATE_COMPLETED";
+    }
+}
+exports.OnStateCompleteHandler = OnStateCompleteHandler;
+OnStateCompleteHandler.type = "OnStateCompleteHandler";
+function makeOnStateCompleteHandler(appObject) {
+    return new OnStateCompleteHandlerImp(appObject);
+}
+exports.makeOnStateCompleteHandler = makeOnStateCompleteHandler;
+class OnStateCompleteHandlerImp extends OnStateCompleteHandler {
+    constructor(appObject) {
+        super(appObject, OnStateCompleteHandler.type);
+        this.action = () => {
+            throw new Entities_1.ActionNotImplemented(this.requestType);
+        };
+        this.handleRequest = (version) => {
+            if (version === 1) {
+                this.action();
+            }
+            else {
+                throw new Entities_1.UnsupportedRequestVersion(this.requestType, version);
+            }
+        };
+        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);
+    }
+}

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

@@ -0,0 +1,10 @@
+import { HostAppObject, HostAppObjectUC } from "../../../HostAppObject";
+import { RequestHandler } from "../Entities";
+export declare type RegisterStylesheetsAction = (stylesheets: string[]) => void;
+export declare abstract class RegisterExternalStyleSheetsHandler extends HostAppObjectUC implements RequestHandler {
+    static readonly type = "RegisterExternalStyleSheetsHandler";
+    readonly requestType = "REGISTER_EXTERNAL_STYLESHEETS";
+    abstract action: RegisterStylesheetsAction;
+    abstract handleRequest: (version: number, payload?: unknown) => void;
+}
+export declare function makeRegisterExternalStyleSheetsHandler(appObject: HostAppObject): RegisterExternalStyleSheetsHandler;

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

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeRegisterExternalStyleSheetsHandler = exports.RegisterExternalStyleSheetsHandler = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+const Entities_1 = require("../Entities");
+class RegisterExternalStyleSheetsHandler extends HostAppObject_1.HostAppObjectUC {
+    constructor() {
+        super(...arguments);
+        this.requestType = "REGISTER_EXTERNAL_STYLESHEETS";
+    }
+}
+exports.RegisterExternalStyleSheetsHandler = RegisterExternalStyleSheetsHandler;
+RegisterExternalStyleSheetsHandler.type = "RegisterExternalStyleSheetsHandler";
+function makeRegisterExternalStyleSheetsHandler(appObject) {
+    return new RegisterExternalStyleSheetsHandlerImp(appObject);
+}
+exports.makeRegisterExternalStyleSheetsHandler = makeRegisterExternalStyleSheetsHandler;
+class RegisterExternalStyleSheetsHandlerImp extends RegisterExternalStyleSheetsHandler {
+    constructor(appObject) {
+        super(appObject, RegisterExternalStyleSheetsHandler.type);
+        this.requestType = "REGISTER_EXTERNAL_STYLESHEETS";
+        this.action = (stylesheets) => {
+            this.log(`Style sheets: ${stylesheets}`);
+        };
+        this.handleRequest = (version, payload) => {
+            if (version === 1) {
+                const { stylesheets } = this.castPayloadV1(payload);
+                this.action(stylesheets);
+            }
+            else {
+                throw new Entities_1.UnsupportedRequestVersion(this.requestType, version);
+            }
+        };
+        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);
+    }
+    castPayloadV1(payload) {
+        const castPayload = payload;
+        if (castPayload.stylesheets === undefined) {
+            throw new Entities_1.UnableToParsePayload(this.requestType, 1, JSON.stringify(payload));
+        }
+        return castPayload;
+    }
+}

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

@@ -0,0 +1,9 @@
+import { HostAppObject, HostAppObjectUC } from "../../../HostAppObject";
+import { RequestHandler } from "../Entities";
+export declare abstract class RestoreCurrentStateHandler extends HostAppObjectUC implements RequestHandler {
+    static readonly type = "RestoreCurrentStateHandler";
+    readonly requestType = "RESTORE_CURRENT_STATE";
+    abstract action: () => void;
+    abstract handleRequest: (version: number, payload?: unknown) => void;
+}
+export declare function makeRestoreCurrentStateHandler(appObject: HostAppObject): RestoreCurrentStateHandler;

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

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeRestoreCurrentStateHandler = exports.RestoreCurrentStateHandler = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+const Entities_1 = require("../Entities");
+const HasPreviousStateHandler_1 = require("./HasPreviousStateHandler");
+class RestoreCurrentStateHandler extends HostAppObject_1.HostAppObjectUC {
+    constructor() {
+        super(...arguments);
+        this.requestType = "RESTORE_CURRENT_STATE";
+    }
+}
+exports.RestoreCurrentStateHandler = RestoreCurrentStateHandler;
+RestoreCurrentStateHandler.type = "RestoreCurrentStateHandler";
+function makeRestoreCurrentStateHandler(appObject) {
+    return new RestoreCurrentStateHandlerImp(appObject);
+}
+exports.makeRestoreCurrentStateHandler = makeRestoreCurrentStateHandler;
+class RestoreCurrentStateHandlerImp extends RestoreCurrentStateHandler {
+    constructor(appObject) {
+        super(appObject, HasPreviousStateHandler_1.HasPreviousStateHandler.type);
+        this.payloadVersion = 1;
+        this.action = () => {
+            throw new Entities_1.ActionNotImplemented(this.requestType);
+        };
+        this.handleRequest = (version) => {
+            if (version === this.payloadVersion) {
+                this.action();
+            }
+            else {
+                throw new Entities_1.UnsupportedRequestVersion(this.requestType, version);
+            }
+        };
+        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);
+    }
+}

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

@@ -0,0 +1,16 @@
+import { HostAppObject, HostAppObjectUC } from "../../../HostAppObject";
+import { RequestHandler } from "../Entities";
+export interface ShowAlertActionDTO {
+    title: string;
+    message: string;
+    closeButtonLabel: string;
+    closeCallback: () => void;
+}
+export declare type ShowAlertAction = (actionDTO: ShowAlertActionDTO) => void;
+export declare abstract class ShowAlertHandler extends HostAppObjectUC implements RequestHandler {
+    static readonly type = "ShowAlertHandler";
+    readonly requestType = "SHOW_ALERT";
+    abstract action: ShowAlertAction;
+    abstract handleRequest: (version: number, payload?: unknown) => void;
+}
+export declare function makeShowAlertHandler(appObject: HostAppObject): ShowAlertHandler;

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

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeShowAlertHandler = exports.ShowAlertHandler = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+const Dialog_1 = require("../../Dialog");
+const Entities_1 = require("../Entities");
+class ShowAlertHandler extends HostAppObject_1.HostAppObjectUC {
+    constructor() {
+        super(...arguments);
+        this.requestType = "SHOW_ALERT";
+    }
+}
+exports.ShowAlertHandler = ShowAlertHandler;
+ShowAlertHandler.type = "ShowAlertHandler";
+function makeShowAlertHandler(appObject) {
+    return new ShowAlertHandlerImp(appObject);
+}
+exports.makeShowAlertHandler = makeShowAlertHandler;
+class ShowAlertHandlerImp extends ShowAlertHandler {
+    constructor(appObject) {
+        super(appObject, ShowAlertHandler.type);
+        this.action = (actionDTO) => {
+            var _a, _b;
+            const { closeButtonLabel, closeCallback, message, title } = actionDTO;
+            const dialogDTO = {
+                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.handleRequest = (version, payload) => {
+            if (version === 1) {
+                const castPayload = this.castPayloadV1(payload);
+                this.action(castPayload);
+            }
+            else {
+                throw new Entities_1.UnsupportedRequestVersion(this.requestType, version);
+            }
+        };
+        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);
+    }
+    castPayloadV1(payload) {
+        const castPayload = payload;
+        if (castPayload.title === undefined ||
+            castPayload.message === undefined ||
+            castPayload.closeButtonLabel === undefined ||
+            castPayload.closeCallback === undefined) {
+            throw new Entities_1.UnableToParsePayload(this.requestType, 1, JSON.stringify(payload));
+        }
+        return castPayload;
+    }
+}

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

@@ -0,0 +1,18 @@
+import { HostAppObject, HostAppObjectUC } from "../../../HostAppObject";
+import { RequestHandler } from "../Entities";
+export interface ShowConfirmActionDTO {
+    title: string;
+    message: string;
+    confirmButtonLabel: string;
+    cancelButtonLabel: string;
+    confirmCallback: () => void;
+    cancelCallback: () => void;
+}
+export declare type ShowConfirmAction = (confirmData: ShowConfirmActionDTO) => void;
+export declare abstract class ShowConfirmHandler extends HostAppObjectUC implements RequestHandler {
+    static readonly type = "ShowConfirmHandler";
+    readonly requestType = "SHOW_CONFIRM";
+    abstract action: ShowConfirmAction;
+    abstract handleRequest: (version: number, payload?: unknown) => void;
+}
+export declare function makeShowConfirmHandler(appObject: HostAppObject): ShowConfirmHandler;

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

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeShowConfirmHandler = exports.ShowConfirmHandler = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+const Dialog_1 = require("../../Dialog");
+const Entities_1 = require("../Entities");
+class ShowConfirmHandler extends HostAppObject_1.HostAppObjectUC {
+    constructor() {
+        super(...arguments);
+        this.requestType = "SHOW_CONFIRM";
+    }
+}
+exports.ShowConfirmHandler = ShowConfirmHandler;
+ShowConfirmHandler.type = "ShowConfirmHandler";
+function makeShowConfirmHandler(appObject) {
+    return new ShowConfirmHandlerImp(appObject);
+}
+exports.makeShowConfirmHandler = makeShowConfirmHandler;
+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 = {
+                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.handleRequest = (version, payload) => {
+            if (version === 1) {
+                const castPayload = this.castPayloadV1(payload);
+                this.action(castPayload);
+            }
+            else {
+                throw new Entities_1.UnsupportedRequestVersion(this.requestType, version);
+            }
+        };
+        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);
+    }
+    castPayloadV1(payload) {
+        const castPayload = payload;
+        if (castPayload.title === undefined ||
+            castPayload.message === undefined ||
+            castPayload.confirmButtonLabel === undefined ||
+            castPayload.cancelButtonLabel === undefined ||
+            castPayload.confirmCallback === undefined ||
+            castPayload.cancelCallback === undefined) {
+            throw new Entities_1.UnableToParsePayload(this.requestType, 1, JSON.stringify(payload));
+        }
+        return castPayload;
+    }
+}

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

@@ -0,0 +1,22 @@
+import { HostAppObject, HostAppObjectUC } from "../../../HostAppObject";
+import { RequestHandler } from "../Entities";
+export interface ShowMarkDownEditorActionDTO {
+    initialText: string;
+    submitCallback: (text: string) => void;
+    validateString?: (text: string) => string | null;
+}
+export declare type ShowMarkDownEditorAction = (confirmData: ShowMarkDownEditorActionDTO) => void;
+export declare abstract class ShowMarkDownEditorHandler extends HostAppObjectUC implements RequestHandler {
+    static readonly type = "ShowMarkDownEditorHandler";
+    readonly requestType = "SHOW_MARKDOWN_EDITOR";
+    abstract action: ShowMarkDownEditorAction;
+    abstract handleRequest: (version: number, payload?: unknown) => void;
+}
+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;
+    constructor(appObject: HostAppObject);
+}

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

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShowMarkDownEditorHandlerImp = exports.makeShowMarkDownEditorHandler = exports.ShowMarkDownEditorHandler = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+const Dialog_1 = require("../../Dialog");
+const Entities_1 = require("../Entities");
+class ShowMarkDownEditorHandler extends HostAppObject_1.HostAppObjectUC {
+    constructor() {
+        super(...arguments);
+        this.requestType = "SHOW_MARKDOWN_EDITOR";
+    }
+}
+exports.ShowMarkDownEditorHandler = ShowMarkDownEditorHandler;
+ShowMarkDownEditorHandler.type = "ShowMarkDownEditorHandler";
+function makeShowMarkDownEditorHandler(appObject) {
+    return new ShowMarkDownEditorHandlerImp(appObject);
+}
+exports.makeShowMarkDownEditorHandler = makeShowMarkDownEditorHandler;
+class ShowMarkDownEditorHandlerImp extends ShowMarkDownEditorHandler {
+    constructor(appObject) {
+        super(appObject, ShowMarkDownEditorHandler.type);
+        this.action = (actionDTO) => {
+            var _a, _b;
+            const { initialText, submitCallback } = actionDTO;
+            const dialogDTO = {
+                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.handleRequest = (version, payload) => {
+            if (version === 1) {
+                const castPayload = this.castPayloadV1(payload);
+                this.action(castPayload);
+            }
+            else {
+                throw new Entities_1.UnsupportedRequestVersion(this.requestType, version);
+            }
+        };
+        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);
+    }
+    castPayloadV1(payload) {
+        const castPayload = payload;
+        if (castPayload.initialText === undefined ||
+            castPayload.submitCallback === undefined) {
+            throw new Entities_1.UnableToParsePayload(this.requestType, 1, JSON.stringify(payload));
+        }
+        return castPayload;
+    }
+}
+exports.ShowMarkDownEditorHandlerImp = ShowMarkDownEditorHandlerImp;

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

@@ -0,0 +1,10 @@
+import { HostAppObject, HostAppObjectUC } from "../../../HostAppObject";
+import { RequestHandler } from "../Entities";
+export declare type ShowSelectModelAction = (callback: (modelId: string) => void) => void;
+export declare abstract class ShowSelectModelHandler extends HostAppObjectUC implements RequestHandler {
+    static readonly type = "ShowSelectModelHandler";
+    readonly requestType = "SHOW_SELECT_MODEL";
+    abstract action: ShowSelectModelAction;
+    abstract handleRequest: (version: number, payload?: unknown) => void;
+}
+export declare function makeShowSelectModelHandler(appObject: HostAppObject): ShowSelectModelHandler;

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

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeShowSelectModelHandler = exports.ShowSelectModelHandler = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+const Entities_1 = require("../Entities");
+class ShowSelectModelHandler extends HostAppObject_1.HostAppObjectUC {
+    constructor() {
+        super(...arguments);
+        this.requestType = "SHOW_SELECT_MODEL";
+    }
+}
+exports.ShowSelectModelHandler = ShowSelectModelHandler;
+ShowSelectModelHandler.type = "ShowSelectModelHandler";
+function makeShowSelectModelHandler(appObject) {
+    return new ShowSelectModelHandlerImp(appObject);
+}
+exports.makeShowSelectModelHandler = makeShowSelectModelHandler;
+class ShowSelectModelHandlerImp extends ShowSelectModelHandler {
+    constructor(appObject) {
+        super(appObject, ShowSelectModelHandler.type);
+        this.action = () => {
+            throw new Entities_1.ActionNotImplemented(this.requestType);
+        };
+        this.handleRequest = (version, payload) => {
+            if (version === 1) {
+                const castPayload = this.castPayloadV1(payload);
+                this.action(castPayload);
+            }
+            else {
+                throw new Entities_1.UnsupportedRequestVersion(this.requestType, version);
+            }
+        };
+        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);
+    }
+    castPayloadV1(payload) {
+        const castPayload = payload;
+        if (castPayload.callback === undefined) {
+            throw new Entities_1.UnableToParsePayload(this.requestType, 1, JSON.stringify(payload));
+        }
+        return castPayload.callback;
+    }
+}

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

@@ -0,0 +1,15 @@
+import { HostAppObject, HostAppObjectUC } from "../../../HostAppObject";
+import { RequestHandler } from "../Entities";
+export interface ShowSpinnerActionDTO {
+    message: string;
+    title: string;
+    closeCallback: (closeSpinner: () => void) => void;
+}
+export declare type ShowSpinnerAction = (confirmData: ShowSpinnerActionDTO) => void;
+export declare abstract class ShowSpinnerHandler extends HostAppObjectUC implements RequestHandler {
+    static readonly type = "ShowSpinnerHandler";
+    readonly requestType = "SHOW_SPINNER";
+    abstract action: ShowSpinnerAction;
+    abstract handleRequest: (version: number, payload?: unknown) => void;
+}
+export declare function makeShowSpinnerHandler(appObject: HostAppObject): ShowSpinnerHandler;

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

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeShowSpinnerHandler = exports.ShowSpinnerHandler = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+const Dialog_1 = require("../../Dialog");
+const Entities_1 = require("../Entities");
+class ShowSpinnerHandler extends HostAppObject_1.HostAppObjectUC {
+    constructor() {
+        super(...arguments);
+        this.requestType = "SHOW_SPINNER";
+    }
+}
+exports.ShowSpinnerHandler = ShowSpinnerHandler;
+ShowSpinnerHandler.type = "ShowSpinnerHandler";
+function makeShowSpinnerHandler(appObject) {
+    return new ShowSpinnerBase(appObject);
+}
+exports.makeShowSpinnerHandler = makeShowSpinnerHandler;
+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({
+                title,
+                message
+            });
+            if (!spinnerDialog) {
+                return;
+            }
+            this.dialogQueue.submitDialog(spinnerDialog);
+            closeCallback(spinnerDialog.close);
+        };
+        this.handleRequest = (version, payload) => {
+            if (version === 1) {
+                const castPayload = this.castPayloadV1(payload);
+                this.action(castPayload);
+            }
+            else {
+                throw new Entities_1.UnsupportedRequestVersion(this.requestType, version);
+            }
+        };
+        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);
+    }
+    castPayloadV1(payload) {
+        const castPayload = payload;
+        if (castPayload.message === undefined ||
+            castPayload.title === undefined ||
+            castPayload.closeCallback === undefined) {
+            throw new Entities_1.UnableToParsePayload(this.requestType, 1, JSON.stringify(payload));
+        }
+        return castPayload;
+    }
+}

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

@@ -0,0 +1,9 @@
+import { HostAppObject, HostAppObjectUC } from "../../../HostAppObject";
+import { RequestHandler } from "../Entities";
+export declare abstract class StartZSpaceHandler extends HostAppObjectUC implements RequestHandler {
+    static readonly type = "StartZSpaceHandler";
+    readonly requestType = "START_ZSPACE";
+    abstract action: () => void;
+    abstract handleRequest: (version: number, payload?: unknown) => void;
+}
+export declare function makeStartZSpaceHandler(appObject: HostAppObject): StartZSpaceHandler;

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

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeStartZSpaceHandler = exports.StartZSpaceHandler = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+const Entities_1 = require("../Entities");
+class StartZSpaceHandler extends HostAppObject_1.HostAppObjectUC {
+    constructor() {
+        super(...arguments);
+        this.requestType = "START_ZSPACE";
+    }
+}
+exports.StartZSpaceHandler = StartZSpaceHandler;
+StartZSpaceHandler.type = "StartZSpaceHandler";
+function makeStartZSpaceHandler(appObject) {
+    return new StartZSpaceHandlerImp(appObject);
+}
+exports.makeStartZSpaceHandler = makeStartZSpaceHandler;
+class StartZSpaceHandlerImp extends StartZSpaceHandler {
+    constructor(appObject) {
+        super(appObject, StartZSpaceHandler.type);
+        this.payloadVersion = 1;
+        this.action = () => {
+            throw new Entities_1.ActionNotImplemented(this.requestType);
+        };
+        this.handleRequest = (version) => {
+            if (version === this.payloadVersion) {
+                this.action();
+            }
+            else {
+                throw new Entities_1.UnsupportedRequestVersion(this.requestType, version);
+            }
+        };
+        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);
+    }
+}

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

@@ -0,0 +1,9 @@
+import { HostAppObject, HostAppObjectUC } from "../../../HostAppObject";
+import { RequestHandler } from "../Entities";
+export declare abstract class StopZSpaceHandler extends HostAppObjectUC implements RequestHandler {
+    static readonly type = "StopZSpaceHandler";
+    readonly requestType = "STOP_ZSPACE";
+    abstract action: () => void;
+    abstract handleRequest: (version: number, payload?: unknown) => void;
+}
+export declare function makeStopZSpaceHandler(appObject: HostAppObject): StopZSpaceHandler;

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

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeStopZSpaceHandler = exports.StopZSpaceHandler = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+const Entities_1 = require("../Entities");
+class StopZSpaceHandler extends HostAppObject_1.HostAppObjectUC {
+    constructor() {
+        super(...arguments);
+        this.requestType = "STOP_ZSPACE";
+    }
+}
+exports.StopZSpaceHandler = StopZSpaceHandler;
+StopZSpaceHandler.type = "StopZSpaceHandler";
+function makeStopZSpaceHandler(appObject) {
+    return new StopZSpaceHandlerImp(appObject);
+}
+exports.makeStopZSpaceHandler = makeStopZSpaceHandler;
+class StopZSpaceHandlerImp extends StopZSpaceHandler {
+    constructor(appObject) {
+        super(appObject, StopZSpaceHandler.type);
+        this.payloadVersion = 1;
+        this.action = () => {
+            throw new Entities_1.ActionNotImplemented(this.requestType);
+        };
+        this.handleRequest = (version) => {
+            if (version === this.payloadVersion) {
+                this.action();
+            }
+            else {
+                throw new Entities_1.UnsupportedRequestVersion(this.requestType, version);
+            }
+        };
+        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);
+    }
+}

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

@@ -0,0 +1,10 @@
+import { HostAppObject, HostAppObjectUC } from "../../../HostAppObject";
+import { RequestHandler } from "../Entities";
+export declare type SubmitActivityAssetAction = (assetFile: File, callback: (assetID: string | undefined) => void) => void;
+export declare abstract class SubmitActivityAssetHandler extends HostAppObjectUC implements RequestHandler {
+    static readonly type = "SubmitActivityAssetHandler";
+    readonly requestType = "SUBMIT_ACTIVITY_ASSET";
+    abstract action: SubmitActivityAssetAction;
+    abstract handleRequest: (version: number, payload?: unknown) => void;
+}
+export declare function makeSubmitActivityAssetHandler(appObject: HostAppObject): SubmitActivityAssetHandler;