@vived/host 3.0.0

package/lib/Components/Handler/Mocks/MockGetAssetsForOwnerHandler.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="jest" />
+import { HostAppObject } from "../../../HostAppObject";
+import { GetAssetsForOwnerHandler } from "../UCs";
+export declare class MockGetAssetsForOwnerHandler extends GetAssetsForOwnerHandler {
+    action: jest.Mock<any, any>;
+    handleRequest: jest.Mock<any, any>;
+    constructor(appObject: HostAppObject);
+}

package/lib/Components/Handler/Mocks/MockGetAssetsForOwnerHandler.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockGetAssetsForOwnerHandler = void 0;
+const UCs_1 = require("../UCs");
+class MockGetAssetsForOwnerHandler extends UCs_1.GetAssetsForOwnerHandler {
+    constructor(appObject) {
+        super(appObject, UCs_1.GetAssetsForOwnerHandler.type);
+        this.action = jest.fn();
+        this.handleRequest = jest.fn();
+    }
+}
+exports.MockGetAssetsForOwnerHandler = MockGetAssetsForOwnerHandler;

package/lib/Components/Handler/Mocks/MockGetLinkedAssetsHandler.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="jest" />
+import { HostAppObject } from "../../../HostAppObject";
+import { GetLinkedAssetsHandler } from "../UCs/GetLinkedAssetsHandler";
+export declare class MockGetLinkedAssetsHandler extends GetLinkedAssetsHandler {
+    action: jest.Mock<any, any>;
+    handleRequest: jest.Mock<any, any>;
+    constructor(appObject: HostAppObject);
+}

package/lib/Components/Handler/Mocks/MockGetLinkedAssetsHandler.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockGetLinkedAssetsHandler = void 0;
+const GetLinkedAssetsHandler_1 = require("../UCs/GetLinkedAssetsHandler");
+class MockGetLinkedAssetsHandler extends GetLinkedAssetsHandler_1.GetLinkedAssetsHandler {
+    constructor(appObject) {
+        super(appObject, GetLinkedAssetsHandler_1.GetLinkedAssetsHandler.type);
+        this.action = jest.fn();
+        this.handleRequest = jest.fn();
+    }
+}
+exports.MockGetLinkedAssetsHandler = MockGetLinkedAssetsHandler;

package/lib/Components/Handler/Mocks/MockGoToNextStateHandler.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="jest" />
+import { HostAppObject } from "../../../HostAppObject";
+import { GoToNextStateHandler } from "../UCs";
+export declare class MockGoToNextStateHandler extends GoToNextStateHandler {
+    action: jest.Mock<any, any>;
+    handleRequest: jest.Mock<any, any>;
+    constructor(appObject: HostAppObject);
+}

package/lib/Components/Handler/Mocks/MockGoToNextStateHandler.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockGoToNextStateHandler = void 0;
+const UCs_1 = require("../UCs");
+class MockGoToNextStateHandler extends UCs_1.GoToNextStateHandler {
+    constructor(appObject) {
+        super(appObject, UCs_1.GoToNextStateHandler.type);
+        this.action = jest.fn();
+        this.handleRequest = jest.fn();
+    }
+}
+exports.MockGoToNextStateHandler = MockGoToNextStateHandler;

package/lib/Components/Handler/Mocks/MockGoToPreviousStateHandler.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="jest" />
+import { HostAppObject } from "../../../HostAppObject";
+import { GoToPreviousStateHandler } from "../UCs";
+export declare class MockGoToPreviousStateHandler extends GoToPreviousStateHandler {
+    action: jest.Mock<any, any>;
+    handleRequest: jest.Mock<any, any>;
+    constructor(appObject: HostAppObject);
+}

package/lib/Components/Handler/Mocks/MockGoToPreviousStateHandler.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockGoToPreviousStateHandler = void 0;
+const UCs_1 = require("../UCs");
+class MockGoToPreviousStateHandler extends UCs_1.GoToPreviousStateHandler {
+    constructor(appObject) {
+        super(appObject, UCs_1.GoToPreviousStateHandler.type);
+        this.action = jest.fn();
+        this.handleRequest = jest.fn();
+    }
+}
+exports.MockGoToPreviousStateHandler = MockGoToPreviousStateHandler;

package/lib/Components/Handler/Mocks/MockHasNextStateHandler.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="jest" />
+import { HostAppObject } from "../../../HostAppObject";
+import { HasNextStateHandler } from "../UCs";
+export declare class MockHasNextStateHandler extends HasNextStateHandler {
+    action: jest.Mock<any, any>;
+    handleRequest: jest.Mock<any, any>;
+    constructor(appObject: HostAppObject);
+}

package/lib/Components/Handler/Mocks/MockHasNextStateHandler.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockHasNextStateHandler = void 0;
+const UCs_1 = require("../UCs");
+class MockHasNextStateHandler extends UCs_1.HasNextStateHandler {
+    constructor(appObject) {
+        super(appObject, UCs_1.HasNextStateHandler.type);
+        this.action = jest.fn();
+        this.handleRequest = jest.fn();
+    }
+}
+exports.MockHasNextStateHandler = MockHasNextStateHandler;

package/lib/Components/Handler/Mocks/MockHasPreviousStateHandler.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="jest" />
+import { HostAppObject } from "../../../HostAppObject";
+import { HasPreviousStateHandler } from "../UCs";
+export declare class MockHasPreviousStateHandler extends HasPreviousStateHandler {
+    action: jest.Mock<any, any>;
+    handleRequest: jest.Mock<any, any>;
+    constructor(appObject: HostAppObject);
+}

package/lib/Components/Handler/Mocks/MockHasPreviousStateHandler.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockHasPreviousStateHandler = void 0;
+const UCs_1 = require("../UCs");
+class MockHasPreviousStateHandler extends UCs_1.HasPreviousStateHandler {
+    constructor(appObject) {
+        super(appObject, UCs_1.HasPreviousStateHandler.type);
+        this.action = jest.fn();
+        this.handleRequest = jest.fn();
+    }
+}
+exports.MockHasPreviousStateHandler = MockHasPreviousStateHandler;

package/lib/Components/Handler/Mocks/MockIsAssetFetchedHandler.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="jest" />
+import { HostAppObject } from "../../../HostAppObject";
+import { IsAssetFetchedHandler } from "../UCs";
+export declare class MockIsAssetFetchedHandler extends IsAssetFetchedHandler {
+    action: jest.Mock<any, any>;
+    handleRequest: jest.Mock<any, any>;
+    constructor(appObject: HostAppObject);
+}

package/lib/Components/Handler/Mocks/MockIsAssetFetchedHandler.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockIsAssetFetchedHandler = void 0;
+const UCs_1 = require("../UCs");
+class MockIsAssetFetchedHandler extends UCs_1.IsAssetFetchedHandler {
+    constructor(appObject) {
+        super(appObject, UCs_1.IsAssetFetchedHandler.type);
+        this.action = jest.fn();
+        this.handleRequest = jest.fn();
+    }
+}
+exports.MockIsAssetFetchedHandler = MockIsAssetFetchedHandler;

package/lib/Components/Handler/Mocks/MockIsZSpaceAvailableHandler.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="jest" />
+import { HostAppObject } from "../../../HostAppObject";
+import { IsZSpaceAvailableHandler } from "../UCs";
+export declare class MockIsZSpaceAvailableHandler extends IsZSpaceAvailableHandler {
+    action: jest.Mock<any, any>;
+    handleRequest: jest.Mock<any, any>;
+    constructor(appObject: HostAppObject);
+}

package/lib/Components/Handler/Mocks/MockIsZSpaceAvailableHandler.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockIsZSpaceAvailableHandler = void 0;
+const UCs_1 = require("../UCs");
+class MockIsZSpaceAvailableHandler extends UCs_1.IsZSpaceAvailableHandler {
+    constructor(appObject) {
+        super(appObject, UCs_1.IsZSpaceAvailableHandler.type);
+        this.action = jest.fn();
+        this.handleRequest = jest.fn();
+    }
+}
+exports.MockIsZSpaceAvailableHandler = MockIsZSpaceAvailableHandler;

package/lib/Components/Handler/Mocks/MockNewActivityAssetHandler.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="jest" />
+import { HostAppObject } from "../../../HostAppObject";
+import { NewActivityAssetHandler } from "../UCs";
+export declare class MockNewActivityAssetHandler extends NewActivityAssetHandler {
+    action: jest.Mock<any, any>;
+    handleRequest: jest.Mock<any, any>;
+    constructor(appObject: HostAppObject);
+}

package/lib/Components/Handler/Mocks/MockNewActivityAssetHandler.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockNewActivityAssetHandler = void 0;
+const UCs_1 = require("../UCs");
+class MockNewActivityAssetHandler extends UCs_1.NewActivityAssetHandler {
+    constructor(appObject) {
+        super(appObject, UCs_1.NewActivityAssetHandler.type);
+        this.action = jest.fn();
+        this.handleRequest = jest.fn();
+    }
+}
+exports.MockNewActivityAssetHandler = MockNewActivityAssetHandler;

package/lib/Components/Handler/Mocks/MockOnAppIsReadyHandler.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="jest" />
+import { HostAppObject } from "../../../HostAppObject";
+import { OnAppIsReadyHandler } from "../UCs";
+export declare class MockOnAppIsReadyHandler extends OnAppIsReadyHandler {
+    action: jest.Mock<any, any>;
+    handleRequest: jest.Mock<any, any>;
+    constructor(appObject: HostAppObject);
+}

package/lib/Components/Handler/Mocks/MockOnAppIsReadyHandler.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockOnAppIsReadyHandler = void 0;
+const UCs_1 = require("../UCs");
+class MockOnAppIsReadyHandler extends UCs_1.OnAppIsReadyHandler {
+    constructor(appObject) {
+        super(appObject, UCs_1.OnAppIsReadyHandler.type);
+        this.action = jest.fn();
+        this.handleRequest = jest.fn();
+    }
+}
+exports.MockOnAppIsReadyHandler = MockOnAppIsReadyHandler;

package/lib/Components/Handler/Mocks/MockOnStateChangeHandler.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="jest" />
+import { HostAppObject } from "../../../HostAppObject";
+import { OnStateChangeHandler } from "../UCs";
+export declare class MockOnStateChangeHandler extends OnStateChangeHandler {
+    action: jest.Mock<any, any>;
+    handleRequest: jest.Mock<any, any>;
+    constructor(appObject: HostAppObject);
+}

package/lib/Components/Handler/Mocks/MockOnStateChangeHandler.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockOnStateChangeHandler = void 0;
+const UCs_1 = require("../UCs");
+class MockOnStateChangeHandler extends UCs_1.OnStateChangeHandler {
+    constructor(appObject) {
+        super(appObject, UCs_1.OnStateChangeHandler.type);
+        this.action = jest.fn();
+        this.handleRequest = jest.fn();
+    }
+}
+exports.MockOnStateChangeHandler = MockOnStateChangeHandler;

package/lib/Components/Handler/Mocks/MockOnStateCompleteHandler.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="jest" />
+import { HostAppObject } from "../../../HostAppObject";
+import { OnStateCompleteHandler } from "../UCs";
+export declare class MockOnStateCompleteHandler extends OnStateCompleteHandler {
+    action: jest.Mock<any, any>;
+    handleRequest: jest.Mock<any, any>;
+    constructor(appObject: HostAppObject);
+}

package/lib/Components/Handler/Mocks/MockOnStateCompleteHandler.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockOnStateCompleteHandler = void 0;
+const UCs_1 = require("../UCs");
+class MockOnStateCompleteHandler extends UCs_1.OnStateCompleteHandler {
+    constructor(appObject) {
+        super(appObject, UCs_1.OnStateCompleteHandler.type);
+        this.action = jest.fn();
+        this.handleRequest = jest.fn();
+    }
+}
+exports.MockOnStateCompleteHandler = MockOnStateCompleteHandler;

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

@@ -0,0 +1,13 @@
+export * from "./MockGetAssetBlobURLHandler";
+export * from "./MockGetAssetFolderURLHandler";
+export * from "./MockGetAssetMetaHandler";
+export * from "./MockGetAssetsForOwnerHandler";
+export * from "./MockGetLinkedAssetsHandler";
+export * from "./MockGoToNextStateHandler";
+export * from "./MockGoToPreviousStateHandler";
+export * from "./MockHasNextStateHandler";
+export * from "./MockHasPreviousStateHandler";
+export * from "./MockIsAssetFetchedHandler";
+export * from "./MockIsZSpaceAvailableHandler";
+export * from "./MockNewActivityAssetHandler";
+export * from "./MockOnAppIsReadyHandler";

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

@@ -0,0 +1,25 @@
+"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("./MockGetAssetBlobURLHandler"), exports);
+__exportStar(require("./MockGetAssetFolderURLHandler"), exports);
+__exportStar(require("./MockGetAssetMetaHandler"), exports);
+__exportStar(require("./MockGetAssetsForOwnerHandler"), exports);
+__exportStar(require("./MockGetLinkedAssetsHandler"), exports);
+__exportStar(require("./MockGoToNextStateHandler"), exports);
+__exportStar(require("./MockGoToPreviousStateHandler"), exports);
+__exportStar(require("./MockHasNextStateHandler"), exports);
+__exportStar(require("./MockHasPreviousStateHandler"), exports);
+__exportStar(require("./MockIsAssetFetchedHandler"), exports);
+__exportStar(require("./MockIsZSpaceAvailableHandler"), exports);
+__exportStar(require("./MockNewActivityAssetHandler"), exports);
+__exportStar(require("./MockOnAppIsReadyHandler"), exports);

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

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

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

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

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

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

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

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeGetAssetBlobURLHandler = exports.GetAssetBlobURLHandler = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+const Assets_1 = require("../../Assets");
+const Entities_1 = require("../Entities");
+class GetAssetBlobURLHandler extends HostAppObject_1.HostAppObjectUC {
+    constructor() {
+        super(...arguments);
+        this.requestType = "GET_ASSET_BLOB";
+    }
+}
+exports.GetAssetBlobURLHandler = GetAssetBlobURLHandler;
+GetAssetBlobURLHandler.type = "GetAssetBlobURLHandler";
+function makeGetAssetBlobURLHandler(appObject) {
+    return new GetAssetBlobURLHandlerImp(appObject);
+}
+exports.makeGetAssetBlobURLHandler = makeGetAssetBlobURLHandler;
+class GetAssetBlobURLHandlerImp extends GetAssetBlobURLHandler {
+    constructor(appObject) {
+        super(appObject, GetAssetBlobURLHandler.type);
+        this.action = (assetID, callback) => {
+            if (!this.getBlobUC) {
+                this.error("Unable to find GetAssetBlobURLUC");
+                callback(undefined);
+                return;
+            }
+            this.getBlobUC
+                .getAssetBlobURL(assetID)
+                .then((url) => {
+                callback(url);
+            })
+                .catch((e) => {
+                this.appObjects.submitError("GetAssetBlob", e.message);
+                callback(undefined);
+            });
+        };
+        this.handleRequest = (version, payload) => {
+            if (version === 1) {
+                const { assetID, callback } = this.castPayloadV1(payload);
+                this.action(assetID, callback);
+            }
+            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 getBlobUC() {
+        return this.getCachedSingleton(Assets_1.GetAssetBlobURLUC.type);
+    }
+    castPayloadV1(payload) {
+        const castPayload = payload;
+        if (!castPayload.assetID || !castPayload.callback) {
+            throw new Entities_1.UnableToParsePayload(this.requestType, 1, JSON.stringify(payload));
+        }
+        return castPayload;
+    }
+}

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

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

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

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeGetAssetFolderURLHandler = exports.GetAssetFolderURLHandler = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+const Entities_1 = require("../Entities");
+class GetAssetFolderURLHandler extends HostAppObject_1.HostAppObjectUC {
+    constructor() {
+        super(...arguments);
+        this.requestType = "GET_APP_ASSET_URL";
+    }
+}
+exports.GetAssetFolderURLHandler = GetAssetFolderURLHandler;
+GetAssetFolderURLHandler.type = "GetAssetFolderURLHandler";
+function makeGetAssetFolderURLHandler(appObject) {
+    return new GetAssetFolderURLHandlerImp(appObject);
+}
+exports.makeGetAssetFolderURLHandler = makeGetAssetFolderURLHandler;
+class GetAssetFolderURLHandlerImp extends GetAssetFolderURLHandler {
+    constructor(appObject) {
+        super(appObject, GetAssetFolderURLHandler.type);
+        this.action = () => {
+            this.warn("Action has not been setup");
+        };
+        this.handleRequest = (version, payload) => {
+            if (version === 1) {
+                const { callback } = this.castPayloadV1(payload);
+                this.action(callback);
+            }
+            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) {
+            throw new Entities_1.UnableToParsePayload(this.requestType, 1, JSON.stringify(payload));
+        }
+        return castPayload;
+    }
+}

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

@@ -0,0 +1,11 @@
+import { HostAppObject, HostAppObjectUC } from "../../../HostAppObject";
+import { RequestHandler } from "../Entities";
+import { CallbackAssetMeta } from "./CallbackAssetDTO";
+export declare type GetAssetMetaAction = (assetID: string, callback: (assetMeta: CallbackAssetMeta | undefined) => void) => void;
+export declare abstract class GetAssetMetaHandler extends HostAppObjectUC implements RequestHandler {
+    static readonly type = "GetAssetMetaHandler";
+    readonly requestType = "GET_ASSET_META";
+    abstract action: GetAssetMetaAction;
+    abstract handleRequest: (version: number, payload?: unknown) => void;
+}
+export declare function makeGetAssetMetaHandler(appObject: HostAppObject): GetAssetMetaHandler;

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

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeGetAssetMetaHandler = exports.GetAssetMetaHandler = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+const Assets_1 = require("../../Assets");
+const Entities_1 = require("../Entities");
+class GetAssetMetaHandler extends HostAppObject_1.HostAppObjectUC {
+    constructor() {
+        super(...arguments);
+        this.requestType = "GET_ASSET_META";
+    }
+}
+exports.GetAssetMetaHandler = GetAssetMetaHandler;
+GetAssetMetaHandler.type = "GetAssetMetaHandler";
+function makeGetAssetMetaHandler(appObject) {
+    return new GetAssetMetaHandlerImp(appObject);
+}
+exports.makeGetAssetMetaHandler = makeGetAssetMetaHandler;
+class GetAssetMetaHandlerImp extends GetAssetMetaHandler {
+    constructor(appObject) {
+        super(appObject, GetAssetMetaHandler.type);
+        this.action = (assetID, callback) => {
+            if (!this.getAssetUC) {
+                this.error("Unable to find GetAssetUC");
+                callback(undefined);
+                return;
+            }
+            this.getAssetUC
+                .getAsset(assetID)
+                .then((asset) => {
+                const { id, name, description } = asset;
+                const meta = {
+                    id,
+                    name,
+                    description
+                };
+                callback(meta);
+            })
+                .catch((e) => {
+                this.error(e.message);
+                callback(undefined);
+            });
+        };
+        this.handleRequest = (version, payload) => {
+            if (version === 1) {
+                const { assetID, callback } = this.castPayloadV1(payload);
+                this.action(assetID, callback);
+            }
+            else {
+                throw new Entities_1.UnsupportedRequestVersion(this.requestType, version);
+            }
+        };
+        const hostHander = Entities_1.HostHandlerEntity.get(appObject);
+        if (!hostHander) {
+            this.error("UC added to an entity that does not have HostHandlerEntity");
+            return;
+        }
+        hostHander.registerRequestHandler(this);
+    }
+    get getAssetUC() {
+        return this.getCachedSingleton(Assets_1.GetAssetUC.type);
+    }
+    castPayloadV1(payload) {
+        const castPayload = payload;
+        if (!castPayload.assetID || !castPayload.callback) {
+            throw new Entities_1.UnableToParsePayload(this.requestType, 1, JSON.stringify(payload));
+        }
+        return castPayload;
+    }
+}

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

@@ -0,0 +1,11 @@
+import { HostAppObject, HostAppObjectUC } from "../../../HostAppObject";
+import { RequestHandler } from "../Entities";
+import { CallbackAssetMeta } from "./CallbackAssetDTO";
+export declare type GetOwnerAssetsMetaAction = (ownerID: string, callback: (assetMetas: CallbackAssetMeta[]) => void) => void;
+export declare abstract class GetAssetsForOwnerHandler extends HostAppObjectUC implements RequestHandler {
+    static readonly type = "GetAssetsForOwnerHandler";
+    readonly requestType = "GET_ASSET_FOR_OWNER";
+    abstract action: GetOwnerAssetsMetaAction;
+    abstract handleRequest: (version: number, payload?: unknown) => void;
+}
+export declare function makeGetAssetsForOwnerHandler(appObject: HostAppObject): GetAssetsForOwnerHandler;

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

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

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

@@ -0,0 +1,11 @@
+import { HostAppObject, HostAppObjectUC } from "../../../HostAppObject";
+import { RequestHandler } from "../Entities";
+import { CallbackAssetMeta } from "./CallbackAssetDTO";
+export declare type GetLinkedAssetsAction = (assetID: string, type: string, callback: (linkedAssets: CallbackAssetMeta[] | undefined) => void) => void;
+export declare abstract class GetLinkedAssetsHandler extends HostAppObjectUC implements RequestHandler {
+    static readonly type = "GetLinkedAssetsHandler";
+    readonly requestType = "GET_LINKED_ASSETS";
+    abstract action: GetLinkedAssetsAction;
+    abstract handleRequest: (version: number, payload?: unknown) => void;
+}
+export declare function makeGetLinkedAssetsHandler(appObject: HostAppObject): GetLinkedAssetsHandler;