@vived/host 3.0.0

package/lib/UseCases/Handlers/IsZSpaceAvailableBase.d.ts

@@ -0,0 +1,10 @@
+import { RequestHandler } from "../../Components";
+import { HostHandlerX } from "../../Entities";
+export declare type IsZSpaceAvailableAction = (callback: (isZSpaceAvailable: boolean) => void) => void;
+export declare class IsZSpaceAvailableBase implements RequestHandler {
+    readonly requestType = "IS_ZSPACE_AVAILABLE";
+    action: IsZSpaceAvailableAction;
+    handleRequest: (version: number, payload: unknown) => void;
+    private castPayloadV1;
+    constructor(hostHandler: HostHandlerX);
+}

package/lib/UseCases/Handlers/IsZSpaceAvailableBase.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsZSpaceAvailableBase = void 0;
+const Components_1 = require("../../Components");
+class IsZSpaceAvailableBase {
+    constructor(hostHandler) {
+        this.requestType = "IS_ZSPACE_AVAILABLE";
+        this.action = () => {
+            throw new Components_1.ActionNotImplemented(this.requestType);
+        };
+        this.handleRequest = (version, payload) => {
+            if (version === 1) {
+                const { callback } = this.castPayloadV1(payload);
+                this.action(callback);
+            }
+            else {
+                throw new Components_1.UnsupportedRequestVersion(this.requestType, version);
+            }
+        };
+        hostHandler.registerRequestHandler(this);
+    }
+    castPayloadV1(payload) {
+        const castPayload = payload;
+        if (!castPayload.callback) {
+            throw new Components_1.UnableToParsePayload(this.requestType, 1, JSON.stringify(payload));
+        }
+        return castPayload;
+    }
+}
+exports.IsZSpaceAvailableBase = IsZSpaceAvailableBase;

package/lib/UseCases/Handlers/NewActivityAssetBase.d.ts

@@ -0,0 +1,10 @@
+import { RequestHandler } from "../../Components";
+import { HostHandlerX } from "../../Entities";
+export declare type NewActivityAssetAction = (file: File, callback: (blobURL: string | undefined) => void) => void;
+export declare class NewActivityAssetBase implements RequestHandler {
+    readonly requestType = "NEW_ACTIVITY_ASSET";
+    action: NewActivityAssetAction;
+    handleRequest: (version: number, payload: unknown) => void;
+    private castPayloadV1;
+    constructor(hostHandler: HostHandlerX);
+}

package/lib/UseCases/Handlers/NewActivityAssetBase.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NewActivityAssetBase = void 0;
+const Components_1 = require("../../Components");
+class NewActivityAssetBase {
+    constructor(hostHandler) {
+        this.requestType = "NEW_ACTIVITY_ASSET";
+        this.action = () => {
+            throw new Components_1.ActionNotImplemented(this.requestType);
+        };
+        this.handleRequest = (version, payload) => {
+            if (version === 1) {
+                const { file, callback } = this.castPayloadV1(payload);
+                this.action(file, callback);
+            }
+            else {
+                throw new Components_1.UnsupportedRequestVersion(this.requestType, version);
+            }
+        };
+        hostHandler.registerRequestHandler(this);
+    }
+    castPayloadV1(payload) {
+        const castPayload = payload;
+        if (!castPayload.file || !castPayload.callback) {
+            throw new Components_1.UnableToParsePayload(this.requestType, 1, JSON.stringify(payload));
+        }
+        return castPayload;
+    }
+}
+exports.NewActivityAssetBase = NewActivityAssetBase;

package/lib/UseCases/Handlers/OnAppIsReadyBase.d.ts

@@ -0,0 +1,8 @@
+import { RequestHandler } from "../../Components";
+import { HostHandlerX } from "../../Entities";
+export declare class OnAppIsReadyBase implements RequestHandler {
+    readonly requestType = "APP_IS_READY";
+    action: () => void;
+    handleRequest: (version: number) => void;
+    constructor(hostHandler: HostHandlerX);
+}

package/lib/UseCases/Handlers/OnAppIsReadyBase.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OnAppIsReadyBase = void 0;
+const Components_1 = require("../../Components");
+class OnAppIsReadyBase {
+    constructor(hostHandler) {
+        this.requestType = "APP_IS_READY";
+        this.action = () => {
+            throw new Components_1.ActionNotImplemented(this.requestType);
+        };
+        this.handleRequest = (version) => {
+            if (version === 1) {
+                this.action();
+            }
+            else {
+                throw new Components_1.UnsupportedRequestVersion(this.requestType, version);
+            }
+        };
+        hostHandler.registerRequestHandler(this);
+    }
+}
+exports.OnAppIsReadyBase = OnAppIsReadyBase;

package/lib/UseCases/Handlers/OnStateChangeBase.d.ts

@@ -0,0 +1,12 @@
+import { RequestHandler } from "../../Components";
+import { HostHandlerX } from "../../Entities";
+export declare type OnStateChangeAction = (state: object, assets: string[], validationErrorMessage?: string) => void;
+export declare class OnStateChangeBase implements RequestHandler {
+    readonly requestType = "ON_STATE_CHANGE";
+    action: OnStateChangeAction;
+    handleRequest: (version: number, payload: unknown) => void;
+    private castPayloadV1;
+    private castPayloadV2;
+    private castPayloadV3;
+    constructor(hostHandler: HostHandlerX);
+}

package/lib/UseCases/Handlers/OnStateChangeBase.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OnStateChangeBase = void 0;
+const Components_1 = require("../../Components");
+class OnStateChangeBase {
+    constructor(hostHandler) {
+        this.requestType = "ON_STATE_CHANGE";
+        this.action = () => {
+            throw new Components_1.ActionNotImplemented(this.requestType);
+        };
+        this.handleRequest = (version, payload) => {
+            if (version === 1) {
+                const { stateObject } = this.castPayloadV1(payload);
+                this.action(stateObject, []);
+            }
+            else if (version === 2) {
+                const { stateObject, validationErrorMessage } = this.castPayloadV2(payload);
+                this.action(stateObject, [], validationErrorMessage);
+            }
+            else if (version === 3) {
+                const { stateObject, assets, validationErrorMessage } = this.castPayloadV3(payload);
+                this.action(stateObject, assets, validationErrorMessage);
+            }
+            else {
+                throw new Components_1.UnsupportedRequestVersion(this.requestType, version);
+            }
+        };
+        hostHandler.registerRequestHandler(this);
+    }
+    castPayloadV1(payload) {
+        const castPayload = payload;
+        if (castPayload.stateObject === undefined) {
+            throw new Components_1.UnableToParsePayload(this.requestType, 1, JSON.stringify(payload));
+        }
+        return castPayload;
+    }
+    castPayloadV2(payload) {
+        const castPayload = payload;
+        if (castPayload.stateObject === undefined) {
+            throw new Components_1.UnableToParsePayload(this.requestType, 2, JSON.stringify(payload));
+        }
+        return castPayload;
+    }
+    castPayloadV3(payload) {
+        const castPayload = payload;
+        if (castPayload.stateObject === undefined) {
+            throw new Components_1.UnableToParsePayload(this.requestType, 3, JSON.stringify(payload));
+        }
+        return castPayload;
+    }
+}
+exports.OnStateChangeBase = OnStateChangeBase;

package/lib/UseCases/Handlers/OnStateCompleteBase.d.ts

@@ -0,0 +1,8 @@
+import { RequestHandler } from "../../Components";
+import { HostHandlerX } from "../../Entities";
+export declare class OnStateCompleteBase implements RequestHandler {
+    readonly requestType = "ON_STATE_COMPLETED";
+    action: () => void;
+    handleRequest: (version: number) => void;
+    constructor(hostHandler: HostHandlerX);
+}

package/lib/UseCases/Handlers/OnStateCompleteBase.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OnStateCompleteBase = void 0;
+const Components_1 = require("../../Components");
+class OnStateCompleteBase {
+    constructor(hostHandler) {
+        this.requestType = "ON_STATE_COMPLETED";
+        this.action = () => {
+            throw new Components_1.ActionNotImplemented(this.requestType);
+        };
+        this.handleRequest = (version) => {
+            if (version === 1) {
+                this.action();
+            }
+            else {
+                throw new Components_1.UnsupportedRequestVersion(this.requestType, version);
+            }
+        };
+        hostHandler.registerRequestHandler(this);
+    }
+}
+exports.OnStateCompleteBase = OnStateCompleteBase;

package/lib/UseCases/Handlers/RegisterExternalStyleSheetsBase.d.ts

@@ -0,0 +1,10 @@
+import { RequestHandler } from "../../Components";
+import { HostHandlerX } from "../../Entities";
+export declare type RegisterStylesheetsAction = (stylesheets: string[]) => void;
+export declare class RegisterExternalStyleSheetsBase implements RequestHandler {
+    readonly requestType = "REGISTER_EXTERNAL_STYLESHEETS";
+    action: RegisterStylesheetsAction;
+    handleRequest: (version: number, payload: unknown) => void;
+    private castPayloadV1;
+    constructor(hostHandler: HostHandlerX);
+}

package/lib/UseCases/Handlers/RegisterExternalStyleSheetsBase.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RegisterExternalStyleSheetsBase = void 0;
+const Components_1 = require("../../Components");
+class RegisterExternalStyleSheetsBase {
+    constructor(hostHandler) {
+        this.requestType = "REGISTER_EXTERNAL_STYLESHEETS";
+        this.action = () => {
+            throw new Components_1.ActionNotImplemented(this.requestType);
+        };
+        this.handleRequest = (version, payload) => {
+            if (version === 1) {
+                const { stylesheets } = this.castPayloadV1(payload);
+                this.action(stylesheets);
+            }
+            else {
+                throw new Components_1.UnsupportedRequestVersion(this.requestType, version);
+            }
+        };
+        hostHandler.registerRequestHandler(this);
+    }
+    castPayloadV1(payload) {
+        const castPayload = payload;
+        if (castPayload.stylesheets === undefined) {
+            throw new Components_1.UnableToParsePayload(this.requestType, 1, JSON.stringify(payload));
+        }
+        return castPayload;
+    }
+}
+exports.RegisterExternalStyleSheetsBase = RegisterExternalStyleSheetsBase;

package/lib/UseCases/Handlers/RestoreCurrentStateBase.d.ts

@@ -0,0 +1,9 @@
+import { RequestHandler } from "../../Components";
+import { HostHandlerX } from "../../Entities";
+export declare class RestoreCurrentStateBase implements RequestHandler {
+    readonly requestType = "RESTORE_CURRENT_STATE";
+    readonly payloadVersion = 1;
+    action: () => void;
+    handleRequest: (version: number) => void;
+    constructor(handler: HostHandlerX);
+}

package/lib/UseCases/Handlers/RestoreCurrentStateBase.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RestoreCurrentStateBase = void 0;
+const Components_1 = require("../../Components");
+class RestoreCurrentStateBase {
+    constructor(handler) {
+        this.requestType = "RESTORE_CURRENT_STATE";
+        this.payloadVersion = 1;
+        this.action = () => {
+            throw new Components_1.ActionNotImplemented(this.requestType);
+        };
+        this.handleRequest = (version) => {
+            if (version === this.payloadVersion) {
+                this.action();
+            }
+            else {
+                throw new Components_1.UnsupportedRequestVersion(this.requestType, version);
+            }
+        };
+        handler.registerRequestHandler(this);
+    }
+}
+exports.RestoreCurrentStateBase = RestoreCurrentStateBase;

package/lib/UseCases/Handlers/ShowAlertBase.d.ts

@@ -0,0 +1,16 @@
+import { RequestHandler } from "../../Components";
+import { HostHandlerX } from "../../Entities";
+export interface ShowAlertActionDTO {
+    title: string;
+    message: string;
+    closeButtonLabel: string;
+    closeCallback: () => void;
+}
+export declare type ShowAlertAction = (confirmData: ShowAlertActionDTO) => void;
+export declare class ShowAlertBase implements RequestHandler {
+    readonly requestType = "SHOW_ALERT";
+    action: ShowAlertAction;
+    handleRequest: (version: number, payload: unknown) => void;
+    private castPayloadV1;
+    constructor(hostHandler: HostHandlerX);
+}

package/lib/UseCases/Handlers/ShowAlertBase.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShowAlertBase = void 0;
+const Components_1 = require("../../Components");
+class ShowAlertBase {
+    constructor(hostHandler) {
+        this.requestType = "SHOW_ALERT";
+        this.action = () => {
+            throw new Components_1.ActionNotImplemented(this.requestType);
+        };
+        this.handleRequest = (version, payload) => {
+            if (version === 1) {
+                const castPayload = this.castPayloadV1(payload);
+                this.action(castPayload);
+            }
+            else {
+                throw new Components_1.UnsupportedRequestVersion(this.requestType, version);
+            }
+        };
+        hostHandler.registerRequestHandler(this);
+    }
+    castPayloadV1(payload) {
+        const castPayload = payload;
+        if (castPayload.title === undefined ||
+            castPayload.message === undefined ||
+            castPayload.closeButtonLabel === undefined ||
+            castPayload.closeCallback === undefined) {
+            throw new Components_1.UnableToParsePayload(this.requestType, 1, JSON.stringify(payload));
+        }
+        return castPayload;
+    }
+}
+exports.ShowAlertBase = ShowAlertBase;

package/lib/UseCases/Handlers/ShowConfirmBase.d.ts

@@ -0,0 +1,18 @@
+import { RequestHandler } from "../../Components";
+import { HostHandlerX } 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 class ShowConfirmBase implements RequestHandler {
+    readonly requestType = "SHOW_CONFIRM";
+    action: ShowConfirmAction;
+    handleRequest: (version: number, payload: unknown) => void;
+    private castPayloadV1;
+    constructor(hostHandler: HostHandlerX);
+}

package/lib/UseCases/Handlers/ShowConfirmBase.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShowConfirmBase = void 0;
+const Components_1 = require("../../Components");
+class ShowConfirmBase {
+    constructor(hostHandler) {
+        this.requestType = "SHOW_CONFIRM";
+        this.action = () => {
+            throw new Components_1.ActionNotImplemented(this.requestType);
+        };
+        this.handleRequest = (version, payload) => {
+            if (version === 1) {
+                const castPayload = this.castPayloadV1(payload);
+                this.action(castPayload);
+            }
+            else {
+                throw new Components_1.UnsupportedRequestVersion(this.requestType, version);
+            }
+        };
+        hostHandler.registerRequestHandler(this);
+    }
+    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 Components_1.UnableToParsePayload(this.requestType, 1, JSON.stringify(payload));
+        }
+        return castPayload;
+    }
+}
+exports.ShowConfirmBase = ShowConfirmBase;

package/lib/UseCases/Handlers/ShowMarkDownEditorBase.d.ts

@@ -0,0 +1,15 @@
+import { RequestHandler } from "../../Components";
+import { HostHandlerX } 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 class ShowMarkDownEditorBase implements RequestHandler {
+    readonly requestType = "SHOW_MARKDOWN_EDITOR";
+    action: ShowMarkDownEditorAction;
+    handleRequest: (version: number, payload: unknown) => void;
+    private castPayloadV1;
+    constructor(hostHandler: HostHandlerX);
+}

package/lib/UseCases/Handlers/ShowMarkDownEditorBase.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShowMarkDownEditorBase = void 0;
+const Components_1 = require("../../Components");
+class ShowMarkDownEditorBase {
+    constructor(hostHandler) {
+        this.requestType = "SHOW_MARKDOWN_EDITOR";
+        this.action = () => {
+            throw new Components_1.ActionNotImplemented(this.requestType);
+        };
+        this.handleRequest = (version, payload) => {
+            if (version === 1) {
+                const castPayload = this.castPayloadV1(payload);
+                this.action(castPayload);
+            }
+            else {
+                throw new Components_1.UnsupportedRequestVersion(this.requestType, version);
+            }
+        };
+        hostHandler.registerRequestHandler(this);
+    }
+    castPayloadV1(payload) {
+        const castPayload = payload;
+        if (castPayload.initialText === undefined ||
+            castPayload.submitCallback === undefined) {
+            throw new Components_1.UnableToParsePayload(this.requestType, 1, JSON.stringify(payload));
+        }
+        return castPayload;
+    }
+}
+exports.ShowMarkDownEditorBase = ShowMarkDownEditorBase;

package/lib/UseCases/Handlers/ShowSelectModelBase.d.ts

@@ -0,0 +1,10 @@
+import { RequestHandler } from "../../Components";
+import { HostHandlerX } from "../../Entities";
+export declare type ShowSelectModelAction = (callback: (modelId: string) => void) => void;
+export declare class ShowSelectModelBase implements RequestHandler {
+    readonly requestType = "SHOW_SELECT_MODEL";
+    action: ShowSelectModelAction;
+    handleRequest: (version: number, payload: unknown) => void;
+    private castPayloadV1;
+    constructor(hostHandler: HostHandlerX);
+}

package/lib/UseCases/Handlers/ShowSelectModelBase.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShowSelectModelBase = void 0;
+const Components_1 = require("../../Components");
+class ShowSelectModelBase {
+    constructor(hostHandler) {
+        this.requestType = "SHOW_SELECT_MODEL";
+        this.action = () => {
+            throw new Components_1.ActionNotImplemented(this.requestType);
+        };
+        this.handleRequest = (version, payload) => {
+            if (version === 1) {
+                const castPayload = this.castPayloadV1(payload);
+                this.action(castPayload);
+            }
+            else {
+                throw new Components_1.UnsupportedRequestVersion(this.requestType, version);
+            }
+        };
+        hostHandler.registerRequestHandler(this);
+    }
+    castPayloadV1(payload) {
+        const castPayload = payload;
+        if (castPayload.callback === undefined) {
+            throw new Components_1.UnableToParsePayload(this.requestType, 1, JSON.stringify(payload));
+        }
+        return castPayload.callback;
+    }
+}
+exports.ShowSelectModelBase = ShowSelectModelBase;

package/lib/UseCases/Handlers/ShowSpinnerBase.d.ts

@@ -0,0 +1,15 @@
+import { RequestHandler } from "../../Components";
+import { HostHandlerX } from "../../Entities";
+export interface ShowSpinnerActionDTO {
+    message: string;
+    title: string;
+    closeCallback: (closeSpinner: () => void) => void;
+}
+export declare type ShowSpinnerAction = (confirmData: ShowSpinnerActionDTO) => void;
+export declare class ShowSpinnerBase implements RequestHandler {
+    readonly requestType = "SHOW_SPINNER";
+    action: ShowSpinnerAction;
+    handleRequest: (version: number, payload: unknown) => void;
+    private castPayloadV1;
+    constructor(hostHandler: HostHandlerX);
+}

package/lib/UseCases/Handlers/ShowSpinnerBase.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShowSpinnerBase = void 0;
+const Components_1 = require("../../Components");
+class ShowSpinnerBase {
+    constructor(hostHandler) {
+        this.requestType = "SHOW_SPINNER";
+        this.action = () => {
+            throw new Components_1.ActionNotImplemented(this.requestType);
+        };
+        this.handleRequest = (version, payload) => {
+            if (version === 1) {
+                const castPayload = this.castPayloadV1(payload);
+                this.action(castPayload);
+            }
+            else {
+                throw new Components_1.UnsupportedRequestVersion(this.requestType, version);
+            }
+        };
+        hostHandler.registerRequestHandler(this);
+    }
+    castPayloadV1(payload) {
+        const castPayload = payload;
+        if (castPayload.message === undefined ||
+            castPayload.title === undefined ||
+            castPayload.closeCallback === undefined) {
+            throw new Components_1.UnableToParsePayload(this.requestType, 1, JSON.stringify(payload));
+        }
+        return castPayload;
+    }
+}
+exports.ShowSpinnerBase = ShowSpinnerBase;

package/lib/UseCases/Handlers/StartZSpaceBase.d.ts

@@ -0,0 +1,9 @@
+import { RequestHandler } from "../../Components";
+import { HostHandlerX } from "../../Entities";
+export declare class StartZSpaceBase implements RequestHandler {
+    readonly requestType = "START_ZSPACE";
+    readonly payloadVersion = 1;
+    action: () => void;
+    handleRequest: (version: number) => void;
+    constructor(handler: HostHandlerX);
+}

package/lib/UseCases/Handlers/StartZSpaceBase.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StartZSpaceBase = void 0;
+const Components_1 = require("../../Components");
+class StartZSpaceBase {
+    constructor(handler) {
+        this.requestType = "START_ZSPACE";
+        this.payloadVersion = 1;
+        this.action = () => {
+            throw new Components_1.ActionNotImplemented(this.requestType);
+        };
+        this.handleRequest = (version) => {
+            if (version === this.payloadVersion) {
+                this.action();
+            }
+            else {
+                throw new Components_1.UnsupportedRequestVersion(this.requestType, version);
+            }
+        };
+        handler.registerRequestHandler(this);
+    }
+}
+exports.StartZSpaceBase = StartZSpaceBase;

package/lib/UseCases/Handlers/StopZSpaceBase.d.ts

@@ -0,0 +1,9 @@
+import { RequestHandler } from "../../Components";
+import { HostHandlerX } from "../../Entities";
+export declare class StopZSpaceBase implements RequestHandler {
+    readonly requestType = "STOP_ZSPACE";
+    readonly payloadVersion = 1;
+    action: () => void;
+    handleRequest: (version: number) => void;
+    constructor(handler: HostHandlerX);
+}

package/lib/UseCases/Handlers/StopZSpaceBase.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StopZSpaceBase = void 0;
+const Components_1 = require("../../Components");
+class StopZSpaceBase {
+    constructor(handler) {
+        this.requestType = "STOP_ZSPACE";
+        this.payloadVersion = 1;
+        this.action = () => {
+            throw new Components_1.ActionNotImplemented(this.requestType);
+        };
+        this.handleRequest = (version) => {
+            if (version === this.payloadVersion) {
+                this.action();
+            }
+            else {
+                throw new Components_1.UnsupportedRequestVersion(this.requestType, version);
+            }
+        };
+        handler.registerRequestHandler(this);
+    }
+}
+exports.StopZSpaceBase = StopZSpaceBase;

package/lib/UseCases/Handlers/SubmitActivityAssetBase.d.ts

@@ -0,0 +1,10 @@
+import { RequestHandler } from "../../Components";
+import { HostHandlerX } from "../../Entities";
+export declare type SubmitActivityAssetAction = (assetFile: File, callback: (assetID: string | undefined) => void) => void;
+export declare class SubmitActivityAssetBase implements RequestHandler {
+    readonly requestType = "SUBMIT_ACTIVITY_ASSET";
+    action: SubmitActivityAssetAction;
+    handleRequest: (version: number, payload: unknown) => void;
+    private castPayloadV1;
+    constructor(hostHandler: HostHandlerX);
+}

package/lib/UseCases/Handlers/SubmitActivityAssetBase.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubmitActivityAssetBase = void 0;
+const Components_1 = require("../../Components");
+class SubmitActivityAssetBase {
+    constructor(hostHandler) {
+        this.requestType = "SUBMIT_ACTIVITY_ASSET";
+        this.action = () => {
+            throw new Components_1.ActionNotImplemented(this.requestType);
+        };
+        this.handleRequest = (version, payload) => {
+            if (version === 1) {
+                const { assetFile, callback } = this.castPayloadV1(payload);
+                this.action(assetFile, callback);
+            }
+            else {
+                throw new Components_1.UnsupportedRequestVersion(this.requestType, version);
+            }
+        };
+        hostHandler.registerRequestHandler(this);
+    }
+    castPayloadV1(payload) {
+        const castPayload = payload;
+        if (!castPayload.assetFile || !castPayload.callback) {
+            throw new Components_1.UnableToParsePayload(this.requestType, 1, JSON.stringify(payload));
+        }
+        return castPayload;
+    }
+}
+exports.SubmitActivityAssetBase = SubmitActivityAssetBase;