@vived/host 3.0.0

package/lib/AppObject/AppObject.d.ts

@@ -0,0 +1,14 @@
+import { ObservableEntity } from "../Entities";
+import { AppObjectComponent } from "./AppObjectComponent";
+import { AppObjectRepo } from "./AppObjectRepo";
+export declare abstract class AppObject extends ObservableEntity {
+    abstract readonly id: string;
+    abstract readonly appObjectRepo: AppObjectRepo;
+    abstract hasComponent(type: string): boolean;
+    abstract addComponent(component: AppObjectComponent): void;
+    abstract getComponent<T extends AppObjectComponent>(type: string): T | undefined;
+    abstract removeComponent(type: string): void;
+    abstract allComponents(): AppObjectComponent[];
+    abstract dispose(): void;
+}
+export declare function makeAppObject(id: string, repo: AppObjectRepo): AppObject;

package/lib/AppObject/AppObject.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeAppObject = exports.AppObject = void 0;
+const Entities_1 = require("../Entities");
+class AppObject extends Entities_1.ObservableEntity {
+}
+exports.AppObject = AppObject;
+function makeAppObject(id, repo) {
+    return new AppObjectImp(id, repo);
+}
+exports.makeAppObject = makeAppObject;
+class AppObjectImp extends AppObject {
+    constructor(id, repo) {
+        super();
+        this.componentLookup = new Map();
+        this.dispose = () => {
+            const components = Array.from(this.componentLookup.values());
+            this.componentLookup.clear();
+            components.forEach(c => c.dispose());
+            if (this.appObjectRepo.has(this.id)) {
+                this.appObjectRepo.remove(this.id);
+            }
+        };
+        this.id = id;
+        this.appObjectRepo = repo;
+        this.appObjectRepo.add(this);
+    }
+    hasComponent(type) {
+        return this.componentLookup.has(type);
+    }
+    addComponent(component) {
+        const currentComponent = this.componentLookup.get(component.type);
+        if (currentComponent) {
+            console.warn(`[AppObject] Component ${component.type} is being replaced on ${this.id}`);
+            currentComponent.dispose();
+        }
+        this.componentLookup.set(component.type, component);
+        this.notify();
+    }
+    getComponent(type) {
+        if (this.componentLookup.has(type)) {
+            return this.componentLookup.get(type);
+        }
+        else {
+            return undefined;
+        }
+    }
+    removeComponent(type) {
+        const component = this.componentLookup.get(type);
+        if (!component)
+            return;
+        this.componentLookup.delete(type);
+        this.notify();
+    }
+    allComponents() {
+        return Array.from(this.componentLookup.values());
+    }
+}

package/lib/AppObject/AppObjectComponent.d.ts

@@ -0,0 +1,15 @@
+import { AppObject } from "./AppObject";
+import { AppObjectRepo } from "./AppObjectRepo";
+export declare class AppObjectComponent {
+    readonly type: string;
+    readonly appObject: AppObject;
+    get appObjects(): AppObjectRepo;
+    private cachedSingletons;
+    getCachedSingleton<T extends AppObjectComponent>(type: string): T | undefined;
+    getSingleton<T extends AppObjectComponent>(type: string, logType?: "LOG" | "WARN" | "ERROR"): T | undefined;
+    dispose(): void;
+    log(message: string): void;
+    warn(message: string): void;
+    error(message: string): void;
+    constructor(appObject: AppObject, type: string);
+}

package/lib/AppObject/AppObjectComponent.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppObjectComponent = void 0;
+class AppObjectComponent {
+    constructor(appObject, type) {
+        this.cachedSingletons = new Map();
+        this.appObject = appObject;
+        this.type = type;
+        appObject.addComponent(this);
+    }
+    get appObjects() {
+        return this.appObject.appObjectRepo;
+    }
+    getCachedSingleton(type) {
+        if (!this.cachedSingletons.has(type)) {
+            const component = this.appObjects.getSingleton(type);
+            if (!component) {
+                this.warn("Unable to get cached singleton type " + type);
+            }
+            else {
+                this.cachedSingletons.set(type, component);
+            }
+        }
+        return this.cachedSingletons.get(type);
+    }
+    getSingleton(type, logType = "WARN") {
+        const comp = this.appObjects.getSingleton(type);
+        if (!comp) {
+            const msg = "Unable to get singleton type " + type;
+            switch (logType) {
+                case "ERROR":
+                    this.error(msg);
+                    break;
+                case "LOG":
+                    this.log(msg);
+                    break;
+                case "WARN":
+                    this.warn(msg);
+                    break;
+            }
+        }
+        return comp;
+    }
+    ;
+    dispose() {
+        if (this.appObject.getComponent(this.type) === this) {
+            this.appObject.removeComponent(this.type);
+        }
+    }
+    log(message) {
+        this.appObjects.submitLog(`${this.appObject.id}/${this.type}`, message);
+    }
+    warn(message) {
+        this.appObjects.submitWarning(`${this.appObject.id}/${this.type}`, message);
+    }
+    ;
+    error(message) {
+        this.appObjects.submitError(`${this.appObject.id}/${this.type}`, message);
+    }
+}
+exports.AppObjectComponent = AppObjectComponent;

package/lib/AppObject/AppObjectController.d.ts

@@ -0,0 +1,3 @@
+import { AppObjectComponent } from "./AppObjectComponent";
+export declare class AppObjectController extends AppObjectComponent {
+}

package/lib/AppObject/AppObjectController.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppObjectController = void 0;
+const AppObjectComponent_1 = require("./AppObjectComponent");
+class AppObjectController extends AppObjectComponent_1.AppObjectComponent {
+}
+exports.AppObjectController = AppObjectController;

package/lib/AppObject/AppObjectEntity.d.ts

@@ -0,0 +1,14 @@
+import { AppObject } from "./AppObject";
+import { AppObjectComponent } from "./AppObjectComponent";
+export declare type AppObjectEntityObserver = () => void;
+export declare class AppObjectEntity extends AppObjectComponent {
+    private onDisposeObserverList;
+    addOnDisposeObserver: (observer: AppObjectEntityObserver) => void;
+    removeOnDisposeObserver: (observer: AppObjectEntityObserver) => void;
+    private onChangeObserverList;
+    addChangeObserver: (observer: AppObjectEntityObserver) => void;
+    removeChangeObserver: (observer: AppObjectEntityObserver) => void;
+    notifyOnChange: () => void;
+    dispose(): void;
+    constructor(appObject: AppObject, type: string);
+}

package/lib/AppObject/AppObjectEntity.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppObjectEntity = void 0;
+const Entities_1 = require("../Entities");
+const AppObjectComponent_1 = require("./AppObjectComponent");
+class AppObjectEntity extends AppObjectComponent_1.AppObjectComponent {
+    constructor(appObject, type) {
+        super(appObject, type);
+        this.onDisposeObserverList = new Entities_1.ObserverList();
+        this.addOnDisposeObserver = (observer) => {
+            this.onDisposeObserverList.add(observer);
+        };
+        this.removeOnDisposeObserver = (observer) => {
+            this.onDisposeObserverList.remove(observer);
+        };
+        this.onChangeObserverList = new Entities_1.ObserverList();
+        this.addChangeObserver = (observer) => {
+            this.onChangeObserverList.add(observer);
+        };
+        this.removeChangeObserver = (observer) => {
+            this.onChangeObserverList.remove(observer);
+        };
+        this.notifyOnChange = () => {
+            this.onChangeObserverList.notify();
+        };
+        this.addChangeObserver(appObject.notify);
+    }
+    dispose() {
+        this.removeChangeObserver(this.appObject.notify);
+        this.onDisposeObserverList.notify();
+        this.onChangeObserverList.clear();
+        this.onDisposeObserverList.clear();
+        super.dispose();
+    }
+}
+exports.AppObjectEntity = AppObjectEntity;

package/lib/AppObject/AppObjectEntityRepo.d.ts

@@ -0,0 +1,15 @@
+import { AppObjectEntity } from "./AppObjectEntity";
+export declare class AppObjectEntityRepo<T extends AppObjectEntity> extends AppObjectEntity {
+    private entityLookup;
+    private onEntityAddedObservers;
+    addEntityAddedObserver: (observer: (addedEntity: T) => void) => void;
+    removeEntityAddedObserver: (observer: (addedEntity: T) => void) => void;
+    private onEntityRemovedObservers;
+    addEntityRemovedObserver: (observer: (removedEntity: T) => void) => void;
+    removeEntityRemovedObserver: (observer: (removedEntity: T) => void) => void;
+    hasForAppObject: (appObjectID: string) => boolean;
+    add(entity: T): void;
+    removeForAppObject: (id: string) => void;
+    getForAppObject: (appObjectID: string) => T | undefined;
+    getAll: () => T[];
+}

package/lib/AppObject/AppObjectEntityRepo.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppObjectEntityRepo = void 0;
+const Entities_1 = require("../Entities");
+const AppObjectEntity_1 = require("./AppObjectEntity");
+class AppObjectEntityRepo extends AppObjectEntity_1.AppObjectEntity {
+    constructor() {
+        super(...arguments);
+        this.entityLookup = new Map();
+        this.onEntityAddedObservers = new Entities_1.ObserverList();
+        this.addEntityAddedObserver = (observer) => {
+            this.onEntityAddedObservers.add(observer);
+        };
+        this.removeEntityAddedObserver = (observer) => {
+            this.onEntityAddedObservers.remove(observer);
+        };
+        this.onEntityRemovedObservers = new Entities_1.ObserverList();
+        this.addEntityRemovedObserver = (observer) => {
+            this.onEntityRemovedObservers.add(observer);
+        };
+        this.removeEntityRemovedObserver = (observer) => {
+            this.onEntityRemovedObservers.remove(observer);
+        };
+        this.hasForAppObject = (appObjectID) => {
+            return this.entityLookup.has(appObjectID);
+        };
+        this.removeForAppObject = (id) => {
+            const existing = this.entityLookup.get(id);
+            if (!existing)
+                return;
+            this.entityLookup.delete(id);
+            existing.removeChangeObserver(this.notifyOnChange);
+            this.notifyOnChange();
+            this.onEntityRemovedObservers.notify(existing);
+        };
+        this.getForAppObject = (appObjectID) => {
+            return this.entityLookup.get(appObjectID);
+        };
+        this.getAll = () => {
+            return Array.from(this.entityLookup.values());
+        };
+    }
+    add(entity) {
+        const existing = this.entityLookup.get(entity.appObject.id);
+        if (existing) {
+            existing.removeChangeObserver(this.notifyOnChange);
+        }
+        this.entityLookup.set(entity.appObject.id, entity);
+        entity.addChangeObserver(this.notifyOnChange);
+        this.notifyOnChange();
+        this.onEntityAddedObservers.notify(entity);
+    }
+    ;
+}
+exports.AppObjectEntityRepo = AppObjectEntityRepo;

package/lib/AppObject/AppObjectPM.d.ts

@@ -0,0 +1,11 @@
+import { AppObjectComponent } from "./AppObjectComponent";
+export declare abstract class AppObjectPM<T> extends AppObjectComponent {
+    abstract vmsAreEqual(a: T, b: T): boolean;
+    private _lastVM?;
+    get lastVM(): T | undefined;
+    private observerList;
+    addView(updateView: (vm: T) => void): void;
+    removeView(updateView: (vm: T) => void): void;
+    doUpdateView(vm: T): void;
+    dispose(): void;
+}

package/lib/AppObject/AppObjectPM.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppObjectPM = void 0;
+const Entities_1 = require("../Entities");
+const AppObjectComponent_1 = require("./AppObjectComponent");
+class AppObjectPM extends AppObjectComponent_1.AppObjectComponent {
+    constructor() {
+        super(...arguments);
+        this.observerList = new Entities_1.ObserverList();
+    }
+    get lastVM() {
+        return this._lastVM;
+    }
+    addView(updateView) {
+        this.observerList.add(updateView);
+        if (this._lastVM !== undefined) {
+            updateView(this._lastVM);
+        }
+    }
+    removeView(updateView) {
+        this.observerList.remove(updateView);
+    }
+    doUpdateView(vm) {
+        if (this._lastVM && this.vmsAreEqual(this._lastVM, vm)) {
+            return;
+        }
+        this._lastVM = vm;
+        this.observerList.notify(vm);
+    }
+    dispose() {
+        this.observerList.clear();
+        if (this.appObject.getComponent(this.type) === this) {
+            this.appObject.removeComponent(this.type);
+        }
+        super.dispose();
+    }
+}
+exports.AppObjectPM = AppObjectPM;

package/lib/AppObject/AppObjectRepo.d.ts

@@ -0,0 +1,25 @@
+import { ObservableEntity } from "../Entities";
+import { AppObject } from "./AppObject";
+import { AppObjectComponent } from "./AppObjectComponent";
+export declare abstract class AppObjectRepo extends ObservableEntity {
+    abstract has(appObjectID: string): boolean;
+    abstract add(appObject: AppObject): void;
+    abstract remove(appObjectID: string): void;
+    abstract get(appObjectID: string): AppObject | undefined;
+    abstract getOrCreate(appObjectID: string): AppObject;
+    abstract getAll(): AppObject[];
+    abstract submitLog(sender: string, message: string): void;
+    abstract submitWarning(sender: string, message: string): void;
+    abstract submitError(sender: string, message: string): void;
+    abstract submitFatal(sender: string, message: string): void;
+    abstract registerSingleton(component: AppObjectComponent): void;
+    abstract getSingleton<T extends AppObjectComponent>(type: string): T | undefined;
+    abstract getAppObjectComponent<T extends AppObjectComponent>(appObjectID: string, type: string): T | undefined;
+    abstract getAllAppObjectsWithComponent(componentType: string): AppObject[];
+    abstract getAllComponents<T extends AppObjectComponent>(type: string): T[];
+    abstract addAppObjectAddedObserver: (observer: (addedEntity: AppObject) => void) => void;
+    abstract removeAppObjectAddedObserver: (observer: (addedEntity: AppObject) => void) => void;
+    abstract addAppObjectRemovedObserver: (observer: (addedEntity: AppObject) => void) => void;
+    abstract removedAppObjectRemovedObserver: (observer: (addedEntity: AppObject) => void) => void;
+}
+export declare function makeAppObjectRepo(): AppObjectRepo;

package/lib/AppObject/AppObjectRepo.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeAppObjectRepo = exports.AppObjectRepo = void 0;
+const Entities_1 = require("../Entities");
+const AppObject_1 = require("./AppObject");
+class AppObjectRepo extends Entities_1.ObservableEntity {
+}
+exports.AppObjectRepo = AppObjectRepo;
+function makeAppObjectRepo() {
+    return new AppObjectRepoImp();
+}
+exports.makeAppObjectRepo = makeAppObjectRepo;
+class AppObjectRepoImp extends AppObjectRepo {
+    constructor() {
+        super(...arguments);
+        this.appObjectLookup = new Map();
+        this.singletons = new Map();
+        this.onAppObjectAddedObserver = new Entities_1.ObserverList();
+        this.addAppObjectAddedObserver = (observer) => {
+            this.onAppObjectAddedObserver.add(observer);
+        };
+        this.removeAppObjectAddedObserver = (observer) => {
+            this.onAppObjectAddedObserver.remove(observer);
+        };
+        this.onAppObjectRemovedObservers = new Entities_1.ObserverList();
+        this.addAppObjectRemovedObserver = (observer) => {
+            this.onAppObjectRemovedObservers.add(observer);
+        };
+        this.removedAppObjectRemovedObserver = (observer) => {
+            this.onAppObjectRemovedObservers.remove(observer);
+        };
+        this.has = (id) => {
+            return this.appObjectLookup.has(id);
+        };
+        this.add = (appObject) => {
+            const existing = this.appObjectLookup.get(appObject.id);
+            if (existing) {
+                existing.removeObserver(this.notify);
+            }
+            this.appObjectLookup.set(appObject.id, appObject);
+            appObject.addObserver(this.notify);
+            this.notify();
+            this.onAppObjectAddedObserver.notify(appObject);
+        };
+        this.remove = (id) => {
+            const existing = this.appObjectLookup.get(id);
+            if (!existing)
+                return;
+            this.appObjectLookup.delete(id);
+            existing.removeObserver(this.notify);
+            this.notify();
+            this.onAppObjectRemovedObservers.notify(existing);
+        };
+        this.get = (id) => {
+            return this.appObjectLookup.get(id);
+        };
+        this.getOrCreate = (id) => {
+            const existing = this.appObjectLookup.get(id);
+            if (!existing) {
+                return AppObject_1.makeAppObject(id, this);
+            }
+            else {
+                return existing;
+            }
+        };
+        this.getAll = () => {
+            return Array.from(this.appObjectLookup.values());
+        };
+    }
+    getAllAppObjectsWithComponent(componentType) {
+        const rArray = [];
+        this.appObjectLookup.forEach((appObj) => {
+            if (appObj.hasComponent(componentType)) {
+                rArray.push(appObj);
+            }
+        });
+        return rArray;
+    }
+    getAllComponents(type) {
+        const rArray = [];
+        this.appObjectLookup.forEach((appObj) => {
+            const aoEntity = appObj.getComponent(type);
+            if (aoEntity) {
+                rArray.push(aoEntity);
+            }
+        });
+        return rArray;
+    }
+    getAppObjectComponent(id, entityType) {
+        const ao = this.appObjectLookup.get(id);
+        if (!ao) {
+            return undefined;
+        }
+        return ao.getComponent(entityType);
+    }
+    submitLog(sender, message) {
+        console.log(`[${sender}]: ${message}`);
+    }
+    submitWarning(sender, message) {
+        console.warn(`[${sender}]: ${message}`);
+    }
+    submitError(sender, message) {
+        console.error(`[${sender}]: ${message}`);
+    }
+    submitFatal(sender, message) {
+        console.error(`FATAL ERROR - [${sender}]: ${message}`);
+    }
+    registerSingleton(component) {
+        if (this.singletons.has(component.type)) {
+            this.submitWarning("AppObjectRepo", `Singleton for type ${component.type} already exists. Relpacing`);
+        }
+        this.singletons.set(component.type, component);
+    }
+    getSingleton(type) {
+        if (this.singletons.has(type)) {
+            return this.singletons.get(type);
+        }
+        const components = this.getAllComponents(type);
+        if (components.length === 1) {
+            this.singletons.set(components[0].type, components[0]);
+            return components[0];
+        }
+        else if (components.length === 0) {
+            this.submitWarning("AppObjectRepo", `Unable to find a singleton for ${type}`);
+            return undefined;
+        }
+        else if (components.length > 1) {
+            this.submitWarning("AppObjectRepo", `Multiple ${type} found. There should only be one if it truly a singleton. Using the first one`);
+            return components[0];
+        }
+    }
+}

package/lib/AppObject/AppObjectUC.d.ts

@@ -0,0 +1,3 @@
+import { AppObjectComponent } from "./AppObjectComponent";
+export declare class AppObjectUC extends AppObjectComponent {
+}

package/lib/AppObject/AppObjectUC.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppObjectUC = void 0;
+const AppObjectComponent_1 = require("./AppObjectComponent");
+class AppObjectUC extends AppObjectComponent_1.AppObjectComponent {
+}
+exports.AppObjectUC = AppObjectUC;

package/lib/AppObject/AppObjectView.d.ts

@@ -0,0 +1,3 @@
+import { AppObjectComponent } from "./AppObjectComponent";
+export declare class AppObjectView extends AppObjectComponent {
+}

package/lib/AppObject/AppObjectView.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppObjectView = void 0;
+const AppObjectComponent_1 = require("./AppObjectComponent");
+class AppObjectView extends AppObjectComponent_1.AppObjectComponent {
+}
+exports.AppObjectView = AppObjectView;

package/lib/AppObject/getSingletonComponent.d.ts

@@ -0,0 +1,3 @@
+import { AppObjectComponent } from "./AppObjectComponent";
+import { AppObjectRepo } from "./AppObjectRepo";
+export declare function getSingletonComponent<T extends AppObjectComponent>(type: string, appObjects: AppObjectRepo): T | undefined;

package/lib/AppObject/getSingletonComponent.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSingletonComponent = void 0;
+function getSingletonComponent(type, appObjects) {
+    return appObjects.getSingleton(type);
+}
+exports.getSingletonComponent = getSingletonComponent;

package/lib/AppObject/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./AppObject";
+export * from "./AppObjectEntity";
+export * from "./AppObjectEntityRepo";
+export * from "./AppObjectPM";
+export * from "./AppObjectRepo";
+export * from "./AppObjectUC";
+export * from "./AppObjectController";
+export * from "./AppObjectView";
+export * from "./getSingletonComponent";

package/lib/AppObject/index.js

@@ -0,0 +1,21 @@
+"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("./AppObject"), exports);
+__exportStar(require("./AppObjectEntity"), exports);
+__exportStar(require("./AppObjectEntityRepo"), exports);
+__exportStar(require("./AppObjectPM"), exports);
+__exportStar(require("./AppObjectRepo"), exports);
+__exportStar(require("./AppObjectUC"), exports);
+__exportStar(require("./AppObjectController"), exports);
+__exportStar(require("./AppObjectView"), exports);
+__exportStar(require("./getSingletonComponent"), exports);

package/lib/Components/Assets/Controllers/archiveAsset.d.ts

@@ -0,0 +1,2 @@
+import { HostAppObjectRepo } from "../../../HostAppObject";
+export declare function archiveAsset(assetID: string, archive: boolean, appObjects: HostAppObjectRepo): Promise<void>;

package/lib/Components/Assets/Controllers/archiveAsset.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.archiveAsset = void 0;
+const ArchiveAssetUC_1 = require("../UCs/ArchiveAssetUC");
+function archiveAsset(assetID, archive, appObjects) {
+    const uc = ArchiveAssetUC_1.ArchiveAssetUC.get(assetID, appObjects);
+    if (!uc) {
+        appObjects.submitWarning("archiveAsset", "Unable to find ArchiveAssetUC");
+        return Promise.reject();
+    }
+    return uc.setArchived(archive);
+}
+exports.archiveAsset = archiveAsset;

package/lib/Components/Assets/Controllers/deleteAsset.d.ts

@@ -0,0 +1,2 @@
+import { HostAppObjectRepo } from "../../../HostAppObject";
+export declare function deleteAsset(assetID: string, appObjects: HostAppObjectRepo): void;

package/lib/Components/Assets/Controllers/deleteAsset.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteAsset = void 0;
+const DeleteAssetUC_1 = require("../UCs/DeleteAssetUC");
+function deleteAsset(assetID, appObjects) {
+    const uc = DeleteAssetUC_1.DeleteAssetUC.get(assetID, appObjects);
+    if (!uc) {
+        appObjects.submitWarning("deleteAsset", "Unable to find DeleteAssetUC");
+        return;
+    }
+    uc.deleteWithConfirm();
+}
+exports.deleteAsset = deleteAsset;

package/lib/Components/Assets/Controllers/downloadAssetFile.d.ts

@@ -0,0 +1,2 @@
+import { HostAppObjectRepo } from "../../../HostAppObject";
+export declare function downloadAssetFile(assetID: string, appObjects: HostAppObjectRepo): void;

package/lib/Components/Assets/Controllers/downloadAssetFile.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.downloadAssetFile = void 0;
+const DownloadAssetFileUC_1 = require("../UCs/DownloadAssetFileUC");
+function downloadAssetFile(assetID, appObjects) {
+    const uc = DownloadAssetFileUC_1.DownloadAssetFileUC.get(assetID, appObjects);
+    if (!uc) {
+        appObjects.submitWarning("deleteAsset", "Unable to find DownloadAssetFileUC");
+        return;
+    }
+    uc.download();
+}
+exports.downloadAssetFile = downloadAssetFile;

package/lib/Components/Assets/Controllers/getAppAssets.d.ts

@@ -0,0 +1,2 @@
+import { HostAppObjectRepo } from "../../../HostAppObject";
+export declare function getAppAssets(appID: string, appObjects: HostAppObjectRepo): void;

package/lib/Components/Assets/Controllers/getAppAssets.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAppAssets = void 0;
+const GetAppAssetsUC_1 = require("../UCs/GetAppAssetsUC");
+function getAppAssets(appID, appObjects) {
+    const uc = GetAppAssetsUC_1.GetAppAssetsUC.get(appObjects);
+    if (!uc) {
+        appObjects.submitWarning("getAppAssets", "Unable to find GetAppAssetsUC");
+        return;
+    }
+    uc.getAppAssets(appID);
+}
+exports.getAppAssets = getAppAssets;

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

@@ -0,0 +1,6 @@
+export * from "./archiveAsset";
+export * from "./deleteAsset";
+export * from "./downloadAssetFile";
+export * from "./getAppAssets";
+export * from "./toggleShowArchivedAssets";
+export * from "./updateAssetFile";