@vived/host 3.0.0

package/lib/Components/Assets/PMs/AssetPM.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultAssetVM = exports.AssetPM = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+const AssetEntity_1 = require("../Entities/AssetEntity");
+class AssetPM extends HostAppObject_1.HostAppObjectPM {
+    constructor(appObject) {
+        super(appObject, AssetPM.type);
+        this.onAssetChange = () => {
+            if (!this.asset)
+                return;
+            const vm = {
+                archived: this.asset.archived,
+                description: this.asset.description,
+                id: this.asset.id,
+                name: this.asset.name,
+            };
+            this.doUpdateView(vm);
+        };
+        this.asset = appObject.getComponent(AssetEntity_1.AssetEntity.type);
+        if (!this.asset) {
+            this.warn('PM has been added to an App Object without an AssetEntity');
+            return;
+        }
+        this.asset.addChangeObserver(this.onAssetChange);
+        this.onAssetChange();
+    }
+    static getByID(assetID, appObjects) {
+        const appObject = appObjects.get(assetID);
+        if (!appObject) {
+            appObjects.submitWarning('AssetPM.getByID', 'Unable to find app object by ID ' + assetID);
+            return;
+        }
+        const pm = appObject.getComponent(AssetPM.type);
+        if (!pm) {
+            appObjects.submitWarning('AssetPM.getByID', 'App Object does not have a AssetPM');
+            return;
+        }
+        return pm;
+    }
+    vmsAreEqual(a, b) {
+        if (a.archived !== b.archived)
+            return false;
+        if (a.description !== b.description)
+            return false;
+        if (a.name !== b.name)
+            return false;
+        if (a.id !== b.id)
+            return false;
+        return true;
+    }
+}
+exports.AssetPM = AssetPM;
+AssetPM.type = 'AssetPM';
+exports.defaultAssetVM = {
+    archived: false,
+    description: '',
+    id: '',
+    name: '',
+};

package/lib/Components/Assets/PMs/EditingAppAssetPM.d.ts

@@ -0,0 +1,16 @@
+import { HostAppObject, HostAppObjectPM, HostAppObjectRepo } from '../../../HostAppObject';
+export interface EditingAppAssetVM {
+    id: string;
+    name: string;
+    description: string;
+    archived: boolean;
+    filename: string;
+}
+export declare class EditingAppAssetPM extends HostAppObjectPM<EditingAppAssetVM | undefined> {
+    static type: string;
+    static get(appObjects: HostAppObjectRepo): EditingAppAssetPM | undefined;
+    private appAssets?;
+    vmsAreEqual(a: EditingAppAssetVM | undefined, b: EditingAppAssetVM | undefined): boolean;
+    private onAssetChange;
+    constructor(appObject: HostAppObject);
+}

package/lib/Components/Assets/PMs/EditingAppAssetPM.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EditingAppAssetPM = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+const AppAssetsEntity_1 = require("../Entities/AppAssetsEntity");
+class EditingAppAssetPM extends HostAppObject_1.HostAppObjectPM {
+    constructor(appObject) {
+        super(appObject, EditingAppAssetPM.type);
+        this.onAssetChange = () => {
+            if (!this.appAssets)
+                return;
+            if (this.appAssets.editingAsset) {
+                const { id, name, description, archived, filename } = this.appAssets.editingAsset;
+                const vm = {
+                    id,
+                    name,
+                    description,
+                    archived,
+                    filename,
+                };
+                this.doUpdateView(vm);
+            }
+            else {
+                this.doUpdateView(undefined);
+            }
+        };
+        this.appAssets = appObject.getComponent(AppAssetsEntity_1.AppAssetsEntity.type);
+        if (!this.appAssets) {
+            this.warn('PM has been added to an App Object without an AppAssetsEntity');
+            return;
+        }
+        this.appObjects.registerSingleton(this);
+        this.appAssets.addChangeObserver(this.onAssetChange);
+        this.onAssetChange();
+    }
+    static get(appObjects) {
+        return HostAppObject_1.getSingletonComponent(EditingAppAssetPM.type, appObjects);
+    }
+    vmsAreEqual(a, b) {
+        if (a === undefined && b === undefined)
+            return true;
+        if ((a === null || a === void 0 ? void 0 : a.archived) !== (b === null || b === void 0 ? void 0 : b.archived))
+            return false;
+        if ((a === null || a === void 0 ? void 0 : a.description) !== (b === null || b === void 0 ? void 0 : b.description))
+            return false;
+        if ((a === null || a === void 0 ? void 0 : a.filename) !== (b === null || b === void 0 ? void 0 : b.filename))
+            return false;
+        if ((a === null || a === void 0 ? void 0 : a.id) !== (b === null || b === void 0 ? void 0 : b.id))
+            return false;
+        if ((a === null || a === void 0 ? void 0 : a.name) !== (b === null || b === void 0 ? void 0 : b.name))
+            return false;
+        return true;
+    }
+}
+exports.EditingAppAssetPM = EditingAppAssetPM;
+EditingAppAssetPM.type = 'EditingAppAssetPM';

package/lib/Components/Assets/PMs/ShowArchivedAppAssetPM.d.ts

@@ -0,0 +1,9 @@
+import { HostAppObject, HostAppObjectPM, HostAppObjectRepo } from '../../../HostAppObject';
+export declare class ShowArchivedAppAssetPM extends HostAppObjectPM<boolean> {
+    static type: string;
+    static get(appObjects: HostAppObjectRepo): ShowArchivedAppAssetPM | undefined;
+    private appAssets?;
+    vmsAreEqual(a: boolean, b: boolean): boolean;
+    private onAssetChange;
+    constructor(appObject: HostAppObject);
+}

package/lib/Components/Assets/PMs/ShowArchivedAppAssetPM.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShowArchivedAppAssetPM = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+const AppAssetsEntity_1 = require("../Entities/AppAssetsEntity");
+class ShowArchivedAppAssetPM extends HostAppObject_1.HostAppObjectPM {
+    constructor(appObject) {
+        super(appObject, ShowArchivedAppAssetPM.type);
+        this.onAssetChange = () => {
+            if (!this.appAssets)
+                return;
+            this.doUpdateView(this.appAssets.showArchived);
+        };
+        this.appAssets = appObject.getComponent(AppAssetsEntity_1.AppAssetsEntity.type);
+        if (!this.appAssets) {
+            this.warn('PM has been added to an App Object without an AppAssetsEntity');
+            return;
+        }
+        this.appObjects.registerSingleton(this);
+        this.appAssets.addChangeObserver(this.onAssetChange);
+        this.onAssetChange();
+    }
+    static get(appObjects) {
+        return HostAppObject_1.getSingletonComponent(ShowArchivedAppAssetPM.type, appObjects);
+    }
+    vmsAreEqual(a, b) {
+        return a === b;
+    }
+}
+exports.ShowArchivedAppAssetPM = ShowArchivedAppAssetPM;
+ShowArchivedAppAssetPM.type = 'ShowArchivedAppAssetPM';

package/lib/Components/Assets/PMs/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./AppAssetListPM";
+export * from "./AssetPM";
+export * from "./EditingAppAssetPM";
+export * from "./ShowArchivedAppAssetPM";

package/lib/Components/Assets/PMs/index.js

@@ -0,0 +1,16 @@
+"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("./AppAssetListPM"), exports);
+__exportStar(require("./AssetPM"), exports);
+__exportStar(require("./EditingAppAssetPM"), exports);
+__exportStar(require("./ShowArchivedAppAssetPM"), exports);

package/lib/Components/Assets/UCs/ArchiveAssetUC.d.ts

@@ -0,0 +1,7 @@
+import { HostAppObject, HostAppObjectRepo, HostAppObjectUC } from "../../../HostAppObject";
+export declare abstract class ArchiveAssetUC extends HostAppObjectUC {
+    static type: string;
+    abstract setArchived(archived: boolean): Promise<void>;
+    static get(assetID: string, appObjects: HostAppObjectRepo): ArchiveAssetUC | undefined;
+}
+export declare function makeArchiveAssetUC(appObject: HostAppObject): ArchiveAssetUC;

package/lib/Components/Assets/UCs/ArchiveAssetUC.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeArchiveAssetUC = exports.ArchiveAssetUC = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+const Dialog_1 = require("../../Dialog");
+const VivedAPI_1 = require("../../VivedAPI");
+const AppAssetsEntity_1 = require("../Entities/AppAssetsEntity");
+const AssetEntity_1 = require("../Entities/AssetEntity");
+class ArchiveAssetUC extends HostAppObject_1.HostAppObjectUC {
+    static get(assetID, appObjects) {
+        const appObject = appObjects.get(assetID);
+        if (!appObject) {
+            appObjects.submitWarning("ArchiveAssetUC.get", "Unable to find app object");
+            return undefined;
+        }
+        const uc = appObject.getComponent(ArchiveAssetUC.type);
+        if (!uc) {
+            appObjects.submitWarning("ArchiveAssetUC.get", "App Object does not have ArchiveAssetUC");
+            return undefined;
+        }
+        return uc;
+    }
+}
+exports.ArchiveAssetUC = ArchiveAssetUC;
+ArchiveAssetUC.type = "ArchiveAssetUC";
+function makeArchiveAssetUC(appObject) {
+    return new ArchiveAssetUCImp(appObject);
+}
+exports.makeArchiveAssetUC = makeArchiveAssetUC;
+class ArchiveAssetUCImp extends ArchiveAssetUC {
+    constructor(appObject) {
+        super(appObject, ArchiveAssetUC.type);
+        this.setArchived = (archived) => {
+            const asset = this.asset;
+            if (!asset) {
+                return Promise.reject(new Error("No Asset Entity"));
+            }
+            if (asset.archived === archived) {
+                return Promise.resolve();
+            }
+            const patchAssetIsArchived = this.patchAssetIsArchived;
+            const dialogQueue = this.dialogQueue;
+            if (!patchAssetIsArchived || !dialogQueue) {
+                return Promise.reject();
+            }
+            const title = archived ? "Archiving Asset" : "Unarchiving Asset";
+            const spinner = dialogQueue.spinnerDialogFactory({
+                title,
+                message: "Updating asset's archived flag..."
+            });
+            if (!spinner) {
+                return Promise.reject();
+            }
+            dialogQueue.submitDialog(spinner);
+            return new Promise((resolve, reject) => {
+                patchAssetIsArchived(asset.id, archived)
+                    .then(() => {
+                    asset.archived = archived;
+                    if (this.appAssets && this.appAssets.has(asset.id)) {
+                        this.appAssets.notifyOnChange();
+                    }
+                    spinner === null || spinner === void 0 ? void 0 : spinner.close();
+                    resolve();
+                })
+                    .catch((e) => {
+                    this.error("Archive asset error: " + e.message);
+                    spinner.close();
+                    const dialogDTO = {
+                        buttonLabel: "OK",
+                        message: `Something went wrong when setting the asset's archived flag. Check the console. ${e.message}`,
+                        title: "Archive Asset Error",
+                    };
+                    const confirmDialog = dialogQueue.alertDialogFactory(dialogDTO);
+                    if (confirmDialog)
+                        dialogQueue.submitDialog(confirmDialog);
+                    resolve();
+                });
+            });
+        };
+        this.asset = appObject.getComponent(AssetEntity_1.AssetEntity.type);
+        if (!this.asset) {
+            this.error("UC has been added to an App Object that does not have ArchiveAssetUC");
+        }
+    }
+    get patchAssetIsArchived() {
+        var _a;
+        return (_a = this.getCachedSingleton(VivedAPI_1.PatchAssetIsArchivedUC.type)) === null || _a === void 0 ? void 0 : _a.doPatch;
+    }
+    get appAssets() {
+        return this.getCachedSingleton(AppAssetsEntity_1.AppAssetsEntity.type);
+    }
+    get dialogQueue() {
+        return this.getCachedSingleton(Dialog_1.DialogQueue.type);
+    }
+}

package/lib/Components/Assets/UCs/DeleteAssetUC.d.ts

@@ -0,0 +1,8 @@
+import { HostAppObject, HostAppObjectRepo, HostAppObjectUC } from "../../../HostAppObject";
+export declare abstract class DeleteAssetUC extends HostAppObjectUC {
+    static type: string;
+    abstract delete(): Promise<void>;
+    abstract deleteWithConfirm(): void;
+    static get(assetID: string, appObjects: HostAppObjectRepo): DeleteAssetUC | undefined;
+}
+export declare function makeDeleteAssetUC(appObject: HostAppObject): DeleteAssetUC;

package/lib/Components/Assets/UCs/DeleteAssetUC.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeDeleteAssetUC = exports.DeleteAssetUC = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+const Dialog_1 = require("../../Dialog");
+const VivedAPI_1 = require("../../VivedAPI");
+const AppAssetsEntity_1 = require("../Entities/AppAssetsEntity");
+const AssetEntity_1 = require("../Entities/AssetEntity");
+const AssetRepo_1 = require("../Entities/AssetRepo");
+class DeleteAssetUC extends HostAppObject_1.HostAppObjectUC {
+    static get(assetID, appObjects) {
+        const appObject = appObjects.get(assetID);
+        if (!appObject) {
+            appObjects.submitWarning("DeleteAssetUC.get", "Unable to find app object");
+            return undefined;
+        }
+        const uc = appObject.getComponent(DeleteAssetUC.type);
+        if (!uc) {
+            appObjects.submitWarning("DeleteAssetUC.get", "App Object does not have DeleteAssetUC");
+            return undefined;
+        }
+        return uc;
+    }
+}
+exports.DeleteAssetUC = DeleteAssetUC;
+DeleteAssetUC.type = "DeleteAssetUC";
+function makeDeleteAssetUC(appObject) {
+    return new DeleteAssetUCImp(appObject);
+}
+exports.makeDeleteAssetUC = makeDeleteAssetUC;
+class DeleteAssetUCImp extends DeleteAssetUC {
+    constructor(appObject) {
+        super(appObject, DeleteAssetUC.type);
+        this.deleteWithConfirm = () => {
+            if (!this.dialogQueue)
+                return;
+            const confirmDialog = this.dialogQueue.confirmDialogFactory({
+                cancelButtonLabel: "Cancel",
+                confirmButtonLabel: "Delete Asset",
+                message: "Are you sure you want to delete this asset. This cannot be undone and could affect users. Consider archiving it instead",
+                title: "Delete Asset",
+                onConfirm: this.delete
+            });
+            if (confirmDialog)
+                this.dialogQueue.submitDialog(confirmDialog);
+        };
+        this.delete = () => {
+            const asset = this.asset;
+            if (!asset) {
+                return Promise.reject(new Error("No Asset Entity"));
+            }
+            const doDelete = this.doDelete;
+            const dialogQueue = this.dialogQueue;
+            if (!doDelete || !dialogQueue) {
+                return Promise.reject();
+            }
+            const title = "Delete Asset";
+            const spinnerDialog = dialogQueue.spinnerDialogFactory({
+                title,
+                message: "Deleting asset..."
+            });
+            if (spinnerDialog)
+                dialogQueue.submitDialog(spinnerDialog);
+            return new Promise((resolve) => {
+                doDelete(asset.id)
+                    .then(() => {
+                    if (this.appAssets && this.appAssets.has(asset.id)) {
+                        this.appAssets.remove(asset.id);
+                    }
+                    if (this.assetRepo && this.assetRepo.has(asset.id)) {
+                        this.assetRepo.remove(asset.id);
+                    }
+                    spinnerDialog === null || spinnerDialog === void 0 ? void 0 : spinnerDialog.close();
+                    resolve();
+                })
+                    .catch((e) => {
+                    this.error("Archive asset error: " + e.message);
+                    spinnerDialog === null || spinnerDialog === void 0 ? void 0 : spinnerDialog.close();
+                    const dialogDTO = {
+                        buttonLabel: "OK",
+                        message: `Something went wrong when setting the asset's archived flag. Check the console. ${e.message}`,
+                        title: "Archive Asset Error",
+                    };
+                    const confirmDialog = dialogQueue.alertDialogFactory(dialogDTO);
+                    if (confirmDialog)
+                        dialogQueue.submitDialog(confirmDialog);
+                    resolve();
+                });
+            });
+        };
+        this.asset = appObject.getComponent(AssetEntity_1.AssetEntity.type);
+        if (!this.asset) {
+            this.error("UC has been added to an App Object that does not have ArchiveAssetUC");
+        }
+    }
+    get doDelete() {
+        var _a;
+        return (_a = this.getCachedSingleton(VivedAPI_1.DeleteAssetOnAPIUC.type)) === null || _a === void 0 ? void 0 : _a.doDelete;
+    }
+    get appAssets() {
+        return this.getCachedSingleton(AppAssetsEntity_1.AppAssetsEntity.type);
+    }
+    get assetRepo() {
+        return this.getCachedSingleton(AssetRepo_1.AssetRepo.type);
+    }
+    get dialogQueue() {
+        return this.getCachedSingleton(Dialog_1.DialogQueue.type);
+    }
+}

package/lib/Components/Assets/UCs/DownloadAssetFileUC.d.ts

@@ -0,0 +1,8 @@
+import { HostAppObject, HostAppObjectRepo, HostAppObjectUC } from "../../../HostAppObject";
+export declare abstract class DownloadAssetFileUC extends HostAppObjectUC {
+    static type: string;
+    abstract download(): Promise<void>;
+    abstract saveFileLocally(): void;
+    static get(assetID: string, appObjects: HostAppObjectRepo): DownloadAssetFileUC | undefined;
+}
+export declare function makeDownloadAssetFileUC(appObject: HostAppObject): DownloadAssetFileUC;

package/lib/Components/Assets/UCs/DownloadAssetFileUC.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeDownloadAssetFileUC = exports.DownloadAssetFileUC = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+const Dialog_1 = require("../../Dialog");
+const AssetEntity_1 = require("../Entities/AssetEntity");
+const GetAssetFileUC_1 = require("./GetAssetFileUC");
+class DownloadAssetFileUC extends HostAppObject_1.HostAppObjectUC {
+    static get(assetID, appObjects) {
+        const appObject = appObjects.get(assetID);
+        if (!appObject) {
+            appObjects.submitWarning("DownloadAssetFileUC.get", "Unable to find app object");
+            return undefined;
+        }
+        const uc = appObject.getComponent(DownloadAssetFileUC.type);
+        if (!uc) {
+            appObjects.submitWarning("DownloadAssetFileUC.get", "App Object does not have DownloadAssetFileUC");
+            return undefined;
+        }
+        return uc;
+    }
+}
+exports.DownloadAssetFileUC = DownloadAssetFileUC;
+DownloadAssetFileUC.type = "DownloadAssetFileUC";
+function makeDownloadAssetFileUC(appObject) {
+    return new DownloadAssetFileUCImp(appObject);
+}
+exports.makeDownloadAssetFileUC = makeDownloadAssetFileUC;
+class DownloadAssetFileUCImp extends DownloadAssetFileUC {
+    constructor(appObject) {
+        super(appObject, DownloadAssetFileUC.type);
+        this.download = () => {
+            const asset = this.asset;
+            if (!asset) {
+                return Promise.reject(new Error("No Asset Entity"));
+            }
+            if (asset.blobURL) {
+                this.saveFileLocally();
+                return Promise.resolve();
+            }
+            const getAssetFile = this.getAssetFile;
+            const dialogQueue = this.dialogQueue;
+            if (!getAssetFile || !dialogQueue) {
+                return Promise.reject();
+            }
+            const title = "Download Asset";
+            const spinnerDialog = dialogQueue.spinnerDialogFactory({
+                title,
+                message: "Downloading asset..."
+            });
+            if (spinnerDialog)
+                dialogQueue.submitDialog(spinnerDialog);
+            return new Promise((resolve) => {
+                getAssetFile(asset.id)
+                    .then(() => {
+                    spinnerDialog === null || spinnerDialog === void 0 ? void 0 : spinnerDialog.close();
+                    this.saveFileLocally();
+                    resolve();
+                })
+                    .catch((e) => {
+                    this.error("Archive asset error: " + e.message);
+                    spinnerDialog === null || spinnerDialog === void 0 ? void 0 : spinnerDialog.close();
+                    const dialogDTO = {
+                        buttonLabel: "OK",
+                        message: `Something went wrong when setting the asset's archived flag. Check the console. ${e.message}`,
+                        title: "Archive Asset Error",
+                    };
+                    const confirmDialog = dialogQueue.alertDialogFactory(dialogDTO);
+                    if (confirmDialog)
+                        dialogQueue.submitDialog(confirmDialog);
+                    resolve();
+                });
+            });
+        };
+        this.saveFileLocally = () => {
+            if (!this.asset) {
+                this.error("No Asset");
+                return;
+            }
+            if (!this.asset.blobURL) {
+                this.error("No blob URL");
+                return;
+            }
+            const a = document.createElement("a");
+            a.href = this.asset.blobURL;
+            a.download = this.asset.filename;
+            a.click();
+        };
+        this.asset = appObject.getComponent(AssetEntity_1.AssetEntity.type);
+        if (!this.asset) {
+            this.error("UC has been added to an App Object that does not have ArchiveAssetUC");
+        }
+    }
+    get getAssetFile() {
+        var _a;
+        return (_a = this.getCachedSingleton(GetAssetFileUC_1.GetAssetFileUC.type)) === null || _a === void 0 ? void 0 : _a.getAssetFile;
+    }
+    get dialogQueue() {
+        return this.getCachedSingleton(Dialog_1.DialogQueue.type);
+    }
+}

package/lib/Components/Assets/UCs/GetAppAssetsUC.d.ts

@@ -0,0 +1,7 @@
+import { HostAppObject, HostAppObjectRepo, HostAppObjectUC } from "../../../HostAppObject";
+export declare abstract class GetAppAssetsUC extends HostAppObjectUC {
+    static type: string;
+    abstract getAppAssets(appID: string): Promise<void>;
+    static get(appObjects: HostAppObjectRepo): GetAppAssetsUC | undefined;
+}
+export declare function makeGetAppAssetUC(appObject: HostAppObject): GetAppAssetsUC;

package/lib/Components/Assets/UCs/GetAppAssetsUC.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeGetAppAssetUC = exports.GetAppAssetsUC = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+const VivedAPI_1 = require("../../VivedAPI");
+const AppAssetsEntity_1 = require("../Entities/AppAssetsEntity");
+const AssetRepo_1 = require("../Entities/AssetRepo");
+class GetAppAssetsUC extends HostAppObject_1.HostAppObjectUC {
+    static get(appObjects) {
+        return HostAppObject_1.getSingletonComponent(GetAppAssetsUC.type, appObjects);
+    }
+}
+exports.GetAppAssetsUC = GetAppAssetsUC;
+GetAppAssetsUC.type = "GetAppAssetsUC";
+function makeGetAppAssetUC(appObject) {
+    return new GetAppAssetsUCImp(appObject);
+}
+exports.makeGetAppAssetUC = makeGetAppAssetUC;
+class GetAppAssetsUCImp extends GetAppAssetsUC {
+    constructor(appObject) {
+        super(appObject, GetAppAssetsUC.type);
+        this.getAppAssets = (appID) => {
+            const appAssets = this.appAssets;
+            const getAssetsUC = this.getAssetsUC;
+            const assetRepo = this.assetRepo;
+            if (!appAssets || !getAssetsUC || !assetRepo) {
+                return Promise.reject();
+            }
+            return new Promise((resolve, reject) => {
+                getAssetsUC(appID)
+                    .then((dtos) => {
+                    dtos.forEach((dto) => {
+                        assetRepo.addFromDTO(dto);
+                        appAssets.add(dto.id);
+                    });
+                    resolve();
+                })
+                    .catch((e) => {
+                    reject(e);
+                });
+            });
+        };
+        this.appObjects.registerSingleton(this);
+        this.appAssets = appObject.getComponent(AppAssetsEntity_1.AppAssetsEntity.type);
+        if (!this.appAssets) {
+            this.error("UC added to an App Object that does not have AppAssetsEntity");
+            return;
+        }
+    }
+    get getAssetsUC() {
+        var _a;
+        return (_a = this.getCachedSingleton(VivedAPI_1.GetAssetsForOwnerFromAPIUC.type)) === null || _a === void 0 ? void 0 : _a.getAssets;
+    }
+    get assetRepo() {
+        return this.getCachedSingleton(AssetRepo_1.AssetRepo.type);
+    }
+}

package/lib/Components/Assets/UCs/GetAssetBlobURLUC.d.ts

@@ -0,0 +1,7 @@
+import { HostAppObject, HostAppObjectRepo, HostAppObjectUC } from "../../../HostAppObject";
+export declare abstract class GetAssetBlobURLUC extends HostAppObjectUC {
+    static type: string;
+    abstract getAssetBlobURL(assetID: string): Promise<string>;
+    static get(appObjects: HostAppObjectRepo): GetAssetBlobURLUC | undefined;
+}
+export declare function makeGetAssetBlobURLUC(appObject: HostAppObject): GetAssetBlobURLUC;