@vived/host 3.0.0

package/lib/PresentationManagers/Dialog/SpinnerDialogPM.d.ts

@@ -0,0 +1,16 @@
+import { DialogRepo, DialogSpinner } from "../../Entities";
+export interface SpinnerDialogVM {
+    message: string;
+    title: string;
+}
+export declare class SpinnerDialogPM {
+    private repo;
+    private updateView;
+    private observingAlert;
+    private lastVM?;
+    doUpdateView: () => void;
+    updateAlertObserver(alert: DialogSpinner | null): void;
+    private vmHasChanged;
+    dispose: () => void;
+    constructor(repo: DialogRepo, updateView: (vm: SpinnerDialogVM | null) => void);
+}

package/lib/PresentationManagers/Dialog/SpinnerDialogPM.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpinnerDialogPM = void 0;
+const Entities_1 = require("../../Entities");
+class SpinnerDialogPM {
+    constructor(repo, updateView) {
+        this.repo = repo;
+        this.updateView = updateView;
+        this.observingAlert = null;
+        this.doUpdateView = () => {
+            let vm = null;
+            if (this.repo.activeDialog &&
+                this.repo.activeDialog.type === Entities_1.spinnerDialogType) {
+                const spinnerDialog = this.repo.activeDialog;
+                this.updateAlertObserver(spinnerDialog);
+                vm = {
+                    message: spinnerDialog.message,
+                    title: spinnerDialog.title,
+                };
+            }
+            else {
+                this.updateAlertObserver(null);
+            }
+            if (!this.vmHasChanged(vm))
+                return;
+            this.updateView(vm);
+            this.lastVM = vm;
+        };
+        this.dispose = () => {
+            this.repo.removeObserver(this.doUpdateView);
+            if (this.observingAlert) {
+                this.observingAlert.removeObserver(this.doUpdateView);
+            }
+        };
+        repo.addObserver(this.doUpdateView);
+        this.doUpdateView();
+    }
+    updateAlertObserver(alert) {
+        if (alert === this.observingAlert)
+            return;
+        if (this.observingAlert !== null) {
+            this.observingAlert.removeObserver(this.doUpdateView);
+        }
+        if (alert !== null) {
+            alert.addObserver(this.doUpdateView);
+        }
+        this.observingAlert = alert;
+    }
+    vmHasChanged(vm) {
+        var _a, _b;
+        if (this.lastVM === undefined)
+            return true;
+        if (vm === null && this.lastVM === null)
+            return false;
+        if ((vm === null || vm === void 0 ? void 0 : vm.message) === ((_a = this.lastVM) === null || _a === void 0 ? void 0 : _a.message) &&
+            (vm === null || vm === void 0 ? void 0 : vm.title) === ((_b = this.lastVM) === null || _b === void 0 ? void 0 : _b.title)) {
+            return false;
+        }
+        return true;
+    }
+}
+exports.SpinnerDialogPM = SpinnerDialogPM;

package/lib/PresentationManagers/PresentationManager.d.ts

@@ -0,0 +1,8 @@
+import { EntityObserver, ObservableEntity } from "../Entities";
+export declare abstract class PresentionManager {
+    private observableEntity;
+    abstract doUpdateView: EntityObserver;
+    private internalDoUodateView;
+    dispose: () => void;
+    constructor(observableEntity: ObservableEntity);
+}

package/lib/PresentationManagers/PresentationManager.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PresentionManager = void 0;
+class PresentionManager {
+    constructor(observableEntity) {
+        this.observableEntity = observableEntity;
+        this.internalDoUodateView = () => {
+            this.doUpdateView();
+        };
+        this.dispose = () => {
+            this.observableEntity.removeObserver(this.internalDoUodateView);
+        };
+        observableEntity.addObserver(this.internalDoUodateView);
+    }
+}
+exports.PresentionManager = PresentionManager;

package/lib/PresentationManagers/Snackbar/SnackbarPM.d.ts

@@ -0,0 +1,13 @@
+import { SnackbarRepo } from "../..";
+export interface SnackbarVM {
+    message: string | undefined;
+    durationInSeconds: number;
+    actionButtonText: string | undefined;
+}
+export declare class SnackbarPM {
+    private snackbarRepo;
+    private updateView;
+    dispose(): void;
+    private doUpdateView;
+    constructor(snackbarUC: SnackbarRepo, updateView: (viewMode: SnackbarVM) => void);
+}

package/lib/PresentationManagers/Snackbar/SnackbarPM.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SnackbarPM = void 0;
+class SnackbarPM {
+    constructor(snackbarUC, updateView) {
+        this.doUpdateView = (snackbar) => {
+            let model = {
+                message: undefined,
+                durationInSeconds: 0,
+                actionButtonText: undefined
+            };
+            if (snackbar) {
+                model = {
+                    message: snackbar.message,
+                    durationInSeconds: snackbar.durationInSeconds,
+                    actionButtonText: snackbar.snackbarAction ? snackbar.snackbarAction.actionButtonText : undefined
+                };
+            }
+            this.updateView(model);
+        };
+        this.snackbarRepo = snackbarUC;
+        this.updateView = updateView;
+        this.doUpdateView(undefined);
+        this.snackbarRepo.addObserver(this.doUpdateView);
+    }
+    dispose() {
+        this.snackbarRepo.removeObserver(this.doUpdateView);
+    }
+}
+exports.SnackbarPM = SnackbarPM;

package/lib/PresentationManagers/index.d.ts

@@ -0,0 +1,6 @@
+export * from '../Components/Dialog/PMs/AlertDialogPM';
+export * from '../Components/Dialog/PMs/ConfirmDialogPM';
+export * from '../Components/Dialog/PMs/DialogQueuePM';
+export * from '../Components/Dialog/PMs/SpinnerDialogPM';
+export * from './Snackbar/SnackbarPM';
+export * from './PresentationManager';

package/lib/PresentationManagers/index.js

@@ -0,0 +1,18 @@
+"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("../Components/Dialog/PMs/AlertDialogPM"), exports);
+__exportStar(require("../Components/Dialog/PMs/ConfirmDialogPM"), exports);
+__exportStar(require("../Components/Dialog/PMs/DialogQueuePM"), exports);
+__exportStar(require("../Components/Dialog/PMs/SpinnerDialogPM"), exports);
+__exportStar(require("./Snackbar/SnackbarPM"), exports);
+__exportStar(require("./PresentationManager"), exports);

package/lib/Types/PluginBoundary.d.ts

@@ -0,0 +1,10 @@
+export declare type Handler = (request: Request) => void;
+export interface Request {
+    type: string;
+    version: number;
+    payload?: unknown;
+}
+export interface VIVEDApp_3 {
+    mount(hostRequestHandler: Handler): Handler;
+    mountDev(container: HTMLElement): void;
+}

package/lib/Types/PluginBoundary.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/Types/index.d.ts

@@ -0,0 +1 @@
+export * from './PluginBoundary';

package/lib/Types/index.js

@@ -0,0 +1,13 @@
+"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("./PluginBoundary"), exports);

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

@@ -0,0 +1,5 @@
+export interface CallbackAssetMeta {
+    id: string;
+    name: string;
+    description: string;
+}

package/lib/UseCases/Handlers/CallbackAssetDTO.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

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

package/lib/UseCases/Handlers/GetAssetBlobURLBase.js

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

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

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

package/lib/UseCases/Handlers/GetAssetFolderURLBase.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetAssetFolderURLBase = void 0;
+const Components_1 = require("../../Components");
+class GetAssetFolderURLBase {
+    constructor(hostHandler) {
+        this.requestType = 'GET_APP_ASSET_URL';
+        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.UnsupportedRequestVerion(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.GetAssetFolderURLBase = GetAssetFolderURLBase;

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

@@ -0,0 +1,11 @@
+import { RequestHandler } from "../../Components";
+import { HostHandlerX } from "../../Entities";
+import { CallbackAssetMeta } from "./CallbackAssetDTO";
+export declare type GetAssetMetaAction = (assetID: string, callback: (assetMeta: CallbackAssetMeta | undefined) => void) => void;
+export declare class GetAssetMetaBase implements RequestHandler {
+    readonly requestType = "GET_ASSET_META";
+    action: GetAssetMetaAction;
+    handleRequest: (version: number, payload: unknown) => void;
+    private castPayloadV1;
+    constructor(hostHandler: HostHandlerX);
+}

package/lib/UseCases/Handlers/GetAssetMetaBase.js

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

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

@@ -0,0 +1,11 @@
+import { RequestHandler } from "../../Components";
+import { HostHandlerX } from "../../Entities";
+import { CallbackAssetMeta } from "../../Components/Handler/UCs/CallbackAssetDTO";
+export declare type GetOwnerAssetsMetaAction = (ownerID: string, callback: (assetMetas: CallbackAssetMeta[]) => void) => void;
+export declare class GetAssetsForOwnerBase implements RequestHandler {
+    readonly requestType = "GET_ASSET_FOR_OWNER";
+    action: GetOwnerAssetsMetaAction;
+    handleRequest: (version: number, payload: unknown) => void;
+    private castPayloadV1;
+    constructor(hostHandler: HostHandlerX);
+}

package/lib/UseCases/Handlers/GetAssetsForOwnerBase.js

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

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

@@ -0,0 +1,11 @@
+import { RequestHandler } from "../../Components";
+import { HostHandlerX } from "../../Entities";
+import { CallbackAssetMeta } from "../../Components/Handler/UCs/CallbackAssetDTO";
+export declare type GetLinkedAssetsAction = (assetID: string, type: string, callback: (linkedAssets: CallbackAssetMeta[] | undefined) => void) => void;
+export declare class GetLinkedAssetsBase implements RequestHandler {
+    readonly requestType = "GET_LINKED_ASSETS";
+    action: GetLinkedAssetsAction;
+    handleRequest: (version: number, payload: unknown) => void;
+    private castPayloadV1;
+    constructor(hostHandler: HostHandlerX);
+}

package/lib/UseCases/Handlers/GetLinkedAssetsBase.js

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

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

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

package/lib/UseCases/Handlers/GoToNextStateBase.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoToNextStateBase = void 0;
+const Components_1 = require("../../Components");
+class GoToNextStateBase {
+    constructor(handler) {
+        this.requestType = "GO_TO_NEXT_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.UnsupportedRequestVerion(this.requestType, version);
+            }
+        };
+        handler.registerRequestHandler(this);
+    }
+}
+exports.GoToNextStateBase = GoToNextStateBase;

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

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

package/lib/UseCases/Handlers/GoToPreviousStateBase.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoToPreviousStateBase = void 0;
+const Components_1 = require("../../Components");
+class GoToPreviousStateBase {
+    constructor(handler) {
+        this.requestType = "GO_TO_PREVIOUS_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.UnsupportedRequestVerion(this.requestType, version);
+            }
+        };
+        handler.registerRequestHandler(this);
+    }
+}
+exports.GoToPreviousStateBase = GoToPreviousStateBase;

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

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

package/lib/UseCases/Handlers/HasNextStateBase.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HasNextStateBase = void 0;
+const Components_1 = require("../../Components");
+class HasNextStateBase {
+    constructor(hostHandler) {
+        this.requestType = "HAS_NEXT_STATE";
+        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.UnsupportedRequestVerion(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.HasNextStateBase = HasNextStateBase;

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

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

package/lib/UseCases/Handlers/HasPreviousStateBase.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HasPreviousStateBase = void 0;
+const Components_1 = require("../../Components");
+class HasPreviousStateBase {
+    constructor(hostHandler) {
+        this.requestType = "HAS_PREVIOUS_STATE";
+        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.UnsupportedRequestVerion(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.HasPreviousStateBase = HasPreviousStateBase;

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

@@ -0,0 +1,14 @@
+import { RequestHandler } from "../../Components";
+import { HostHandlerX } from "../../Entities";
+export interface IsAssetFetchedActionDTO {
+    assetId: string;
+    callback: (isFetched: boolean) => void;
+}
+export declare type IsAssetFetchedAction = (confirmData: IsAssetFetchedActionDTO) => void;
+export declare class IsAssetFetchedBase implements RequestHandler {
+    readonly requestType = "IS_ASSET_FILE_FETCHED";
+    action: IsAssetFetchedAction;
+    handleRequest: (version: number, payload: unknown) => void;
+    private castPayloadV1;
+    constructor(hostHandler: HostHandlerX);
+}

package/lib/UseCases/Handlers/IsAssetFetchedBase.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsAssetFetchedBase = void 0;
+const Components_1 = require("../../Components");
+class IsAssetFetchedBase {
+    constructor(hostHandler) {
+        this.requestType = "IS_ASSET_FILE_FETCHED";
+        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.assetId === undefined ||
+            castPayload.callback === undefined) {
+            throw new Components_1.UnableToParsePayload(this.requestType, 1, JSON.stringify(payload));
+        }
+        return castPayload;
+    }
+}
+exports.IsAssetFetchedBase = IsAssetFetchedBase;